Parser Sample

This sample shows how to measure the parsing performance.

Source code

#include <OnixS/FIXEngine.h>
 
#include <cmath>
 
#include "../../Common/PrecisionTimer.h"
#include "../../Common/Helpers.h"
#include "../../Common/Settings.h"
 
using namespace Settings;
using namespace OnixS::FIX;
 
int main(int argc, char * argv[])
{
 
    std::string fileName = (2 == argc) ? argv[1] : "Order.fix";
 
    try {
 
        EngineSettings settings;
        settings.listenPort(-1)  // '-1' disables the telecommunication level.
                .licenseStore(LicenseStore)
                .dictionaryFile("ParserFixDictionary.xml");
 
        Engine::init(settings);
        EngineShutdownGuard engineShutdownGuard;
 
        Dictionary dictionary("ParserDictionaryId");
 
        std::ifstream in(fileName.c_str());
 
        if(!in)
            throw std::domain_error(std::string("Cannot open file ") + fileName);
 
        std::string raw;
        std::getline(in, raw);
 
        std::clog
                << "Raw FIX message:\n"
                << raw
                << std::endl;
 
        const size_t InitialNumberOfCycles = 10000;
        const size_t MaximumNumberOfCycles = 100000000;
        const unsigned long MinimumMeasurementMilliseconds = 100;
        const unsigned int MillisecondsPerSecond = 1000;
        size_t numberOfCycles = InitialNumberOfCycles;
        unsigned long elapsedMilliseconds = 0;
 
        PrecisionTimer timer;
 
        const Message Blank;
        Message parsed;
 
        // Increase the workload until the timer has enough resolution for a meaningful result.
        do
        {
            size_t iteration = numberOfCycles;
            timer.start();
 
            while(iteration--)
            {
                Message::parse(
                    raw.data(), raw.size(),
                    dictionary,
                    MessageParsingFlag::None,
                    parsed);
 
                // Reset the message while retaining its allocated internal structures.
                parsed = Blank;
            }
 
            elapsedMilliseconds = timer.stop();
 
            if(elapsedMilliseconds < MinimumMeasurementMilliseconds)
            {
                if(numberOfCycles == MaximumNumberOfCycles)
                    throw std::runtime_error("Parser measurement duration is too short.");
 
                const size_t doubledNumberOfCycles = numberOfCycles * 2;
                numberOfCycles = doubledNumberOfCycles < MaximumNumberOfCycles
                    ? doubledNumberOfCycles
                    : MaximumNumberOfCycles;
            }
        }
        while(elapsedMilliseconds < MinimumMeasurementMilliseconds);
 
        const double performance = floor(
            static_cast<double>(numberOfCycles) * MillisecondsPerSecond / elapsedMilliseconds);
 
        std::clog << "\nParsing Performance: " << performance << " msg/sec." << std::endl << std::endl;
 
        std::clog << "Press any key to terminate the application." << std::endl;
 
        waitForAnyKey();
    }
    catch(const std::exception & ex) {
        processSampleException(ex.what());
        return 1;
    }
 
    return 0;
}