TCPStandardBenchmark.cpp

Go to the documentation of this file.

/*
 * Copyright Onix Solutions Limited [OnixS]. All rights reserved.
 *
 * This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law
 * and international copyright treaties.
 *
 * Access to and use of the software is governed by the terms of the applicable ONIXS Software
 * Services Agreement (the Agreement) and Customer end user license agreements granting
 * a non-assignable, non-transferable and non-exclusive license to use the software
 * for it's own data processing purposes under the terms defined in the Agreement.
 *
 * Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part
 * of this source code or associated reference material to any other location for further reproduction
 * or redistribution, and any amendments to this copyright notice, are expressly prohibited.
 *
 * Any reproduction or redistribution for sale or hiring of the Software not in accordance with
 * the terms of the Agreement is a violation of copyright law.
 */
// Uncomment to disable using of huge pages.
//#define ONIXS_USE_HUGE_PAGE 0
 
// Uncomment to enable debug mode.
//#define ONIXS_DEBUGGING
 
#include <OnixS/ICE/BOE/IceBoe.h>
 
using namespace ONIXS_ICEBOE_NAMESPACE;
using namespace ONIXS_ICEBOE_MESSAGING_NAMESPACE;
 
#include <Settings/Defaults.h>
#include <Common/Helpers.h>
#include <Common/Listener.h>
#include <Common/Settings.h>
#include <Common/Signal.h>
#include <Common/Emulator.h>
#include <Common/BenchmarkSessionListener.h>
 
#include <algorithm>
 
using namespace Samples;
 
int main(int argc, char* argv[])
{
    // `--help` to show options.
    const AppConfiguration<
            SettingsConfiguration
            , ConnectivityConfiguration
            , LogonConfiguration
            , StorageConfiguration<SessionStorageType::MemoryBased>
            , MainThreadAffinityConfiguration
            , BenchmarkConfiguration
        > cfg{"TCPStandardBenchmark", argc, argv};
 
    int result = 0;
    try
    {
        const auto numberOfMessages = cfg.numberOfMessages();
        const auto warmupInterval = cfg.warmupInterval();
        const auto intervalBetweenSending = (std::max)(cfg.intervalBetweenSending(), warmupInterval);
        const auto storageType = cfg.storage();
 
        ThisThread::affinity(cfg.mainThreadCpu());
        SignalHelper::manageSignals();
 
        auto settings = fillSettings(cfg);
        const auto emulator = createEmulator(settings, cfg);
 
        // Request Binary Order Gateway credentials from Binary Utility Service Gateway.
        const auto bgwCredentials = receiveBgwCredentials(settings, cfg.host(), cfg.port());
 
        settings
            .receiveSpinningTimeout(1000 * 1000)
            .useSpinLock(true)
            .logBeforeSending(false)
            .threadingModel(ThreadingModel::External);
 
        printBenchmarkSettings(std::clog, numberOfMessages, intervalBetweenSending, warmupInterval, storageType);
 
        const auto guard = setPriorityAndPolicy();
 
        TcpStandardStack stack;
 
        ReactorBenchmarkListener listener{numberOfMessages};
        listener.measureOverhead();
 
        try
        {
            const auto bgwSession = std::make_unique<BgwSession>(stack, settings, &listener, cfg.storage());
 
            const auto connected = bgwSession->connectAsync(bgwCredentials);
 
            while(!connected.is_ready())
                stack.dispatchEvents();
 
            if(connected.has_exception())
                connected.get();
 
            auto order = Helper::createOrder(cfg.traderId());
 
            std::clog << "\nWarm-up phase to make first calls faster..." << std::endl;
 
            listener.collectSessionTimeMarks(
                stack, *bgwSession, order, numberOfMessages, intervalBetweenSending, warmupInterval);
 
            if(listener.receivedAllMessages())
            {
                std::clog << "\nMeasurement phase..." << std::endl;
 
                listener.collectSessionTimeMarks(
                    stack, *bgwSession, order, numberOfMessages, intervalBetweenSending, warmupInterval);
            }
 
            const auto disconnected = bgwSession->disconnectAsync();
 
            while(!disconnected.is_ready())
                stack.dispatchEvents();
 
            if(disconnected.has_exception())
                disconnected.get();
        }
        catch(const std::exception& ex)
        {
            std::cerr << "\nEXCEPTION: " << ex.what() << std::endl;
            result = 1;
        }
 
        while(!stack.isQuiescent())
            stack.dispatchEvents();
 
        if(listener.receivedAllMessages())
        {
            if(listener.packetGroupingDetected())
                std::clog << "Attention: packet grouping detected! Increase the interval between sending!" << std::endl;
 
            BenchmarkData::reportResults("Latency", listener.sendMarks(), listener.receiveMarks(), numberOfMessages, listener.overhead());
        }
    }
    catch (const std::exception& ex)
    {
        std::cerr << "\nEXCEPTION: " << ex.what() << std::endl;
        result = 1;
    }
 
    return result;
}
 
#include <Common/PerformanceCounter.inc.h>