TCPStandardBenchmark.cpp File Reference

Go to the source code of this file.

Functions
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 43 of file TCPStandardBenchmark.cpp.

{
    // `--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 = makeUnique<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;
}