FeedEngine.h

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.
*/
 
#pragma once
 
#include <OnixS/B3/MarketData/UMDF/ABI.h>
#include <OnixS/B3/MarketData/UMDF/Integral.h>
#include <OnixS/B3/MarketData/UMDF/Defines.h>
#include <OnixS/B3/MarketData/UMDF/WatchService.h>
#include <OnixS/B3/MarketData/UMDF/LogSettings.h>
 
#include <string>
#include <vector>
#include <cassert>
 
namespace OnixS
{
    namespace B3
    {
        namespace MarketData
        {
            namespace UMDF
            {
                namespace System
                {
                    class ONIXS_B3_UMDF_MD_API ThisThread
                    {
                    public:
                        static void affinity(const System::ThreadAffinity&);
                        static void affinity(System::CpuIndex);
 
#if defined (_WIN32)
                        typedef unsigned int ThreadId;
#else
                        typedef pthread_t ThreadId;
#endif
 
                        static ThreadId threadId();
                    };
                }

                class NetFeedEngineProcessResult
                {
                public:
                    typedef UInt32 Flags;

                    explicit NetFeedEngineProcessResult(UInt32 flags) noexcept
                    {
                        value_.raw_ = flags;
                    }

                    bool eventsDispatched() const noexcept
                    {
                        return 0 != value_.bits_.eventsDispatched_;
                    }

                    void eventsDispatched(bool state) noexcept
                    {
                        value_.bits_.eventsDispatched_ = state ? 1 : 0;
                    }

                    bool ioWaited() const noexcept
                    {
                        return 0 != value_.bits_.ioWaited_;
                    }

                    void ioWaited(bool state) noexcept
                    {
                        value_.bits_.ioWaited_ = state ? 1 : 0;
                    }

                    Flags reserved() const noexcept
                    {
                        return value_.bits_.reserved_;
                    }

                    void reserved(Flags flags) noexcept
                    {
                        value_.bits_.reserved_ = flags;
                    }
 
                private:
                    struct Bitset
                    {
                        Flags eventsDispatched_ : 1;
                        Flags ioWaited_         : 1;
                        Flags reserved_         : 30;
                    };
 
                    union Value
                    {
                        Bitset bits_;
                        Flags raw_;
                    };
 
                    Value value_;
                };

                class ONIXS_B3_UMDF_MD_API FeedEngine
                {
                public:
                    std::string info();

                    virtual ~FeedEngine();
 
                protected:
                    explicit FeedEngine(void* impl);
 
                protected:
                    FeedEngine(const FeedEngine&) =delete;
                    FeedEngine& operator=(const FeedEngine&) =delete;
 
                    void* const impl_;
                    friend struct FeHelper;
                };

                class ONIXS_B3_UMDF_MD_API SocketFeedEngine : public FeedEngine
                {
                public:
                    SocketFeedEngine(
                        const LoggerSettings& loggerSettings, UInt32 dataWaitTime = 10,
                        UInt32 socketBufferSize = 8 * 1024 * 1024, WatchService& watch = UtcWatch::service());

                    explicit SocketFeedEngine(UInt32 dataWaitTime = 10, UInt32 socketBufferSize = 8 * 1024 * 1024,
                        WatchService& watch = UtcWatch::service());

                    NetFeedEngineProcessResult process();

                    ~SocketFeedEngine() override;
                };

                class ONIXS_B3_UMDF_MD_API SingleThreadedSocketFeedEngine : public FeedEngine
                {
                public:
                    SingleThreadedSocketFeedEngine(
                        const LoggerSettings& loggerSettings,
                        UInt32 socketBufferSize = 8 * 1024 * 1024);

                    explicit SingleThreadedSocketFeedEngine(UInt32 socketBufferSize = 8 * 1024 * 1024);

                    NetFeedEngineProcessResult process()
                    {
                        assert(threadId_ == System::ThisThread::threadId() && "External thread is detected.");
                        return processImpl();
                    }

                    ~SingleThreadedSocketFeedEngine() override;
 
                private:
                    NetFeedEngineProcessResult processImpl();
                    const System::ThisThread::ThreadId threadId_ = System::ThisThread::threadId();
                };

                class ONIXS_B3_UMDF_MD_API SingleThreadedHardwareTimestampSocketFeedEngine : public FeedEngine
                {
                public:
                    SingleThreadedHardwareTimestampSocketFeedEngine(
                        const LoggerSettings& loggerSettings,
                        UInt32 socketBufferSize = 8 * 1024 * 1024);

                    explicit SingleThreadedHardwareTimestampSocketFeedEngine(UInt32 socketBufferSize = 8 * 1024 * 1024);

                    NetFeedEngineProcessResult process()
                    {
                        assert(threadId_ == System::ThisThread::threadId() && "External thread is detected.");
                        return processImpl();
                    }

                    ~SingleThreadedHardwareTimestampSocketFeedEngine() override;
 
                private:
                    NetFeedEngineProcessResult processImpl();
                    const System::ThisThread::ThreadId threadId_ = System::ThisThread::threadId();
                };

                class ONIXS_B3_UMDF_MD_API EfViFeedEngine : public FeedEngine
                {
                public:
                    EfViFeedEngine(const LoggerSettings& loggerSettings,
                        UInt32 receiveRingSize = 4095, WatchService& watch = NicWatch::service());

                    explicit EfViFeedEngine(UInt32 receiveRingSize = 4095, WatchService& watch = NicWatch::service());

                    NetFeedEngineProcessResult process();

                    ~EfViFeedEngine() override;
                };

                class ONIXS_B3_UMDF_MD_API SingleThreadedEfViFeedEngine : public FeedEngine
                {
                public:
                    SingleThreadedEfViFeedEngine(const LoggerSettings& loggerSettings, const std::string& ifName, UInt16 memregSize = 512, UInt32 receiveRingSize = 1024);

                    explicit SingleThreadedEfViFeedEngine(const std::string& ifName, UInt16 memregSize = 512, UInt32 receiveRingSize = 1024);

                    NetFeedEngineProcessResult process()
                    {
                        assert(threadId_ == System::ThisThread::threadId() && "External thread is detected.");
                        return processImpl();
                    }

                    ~SingleThreadedEfViFeedEngine() override;
 
                private:
                    NetFeedEngineProcessResult processImpl();
                    const System::ThisThread::ThreadId threadId_ = System::ThisThread::threadId();
                };

                template <typename EngineT>
                typename std::enable_if<std::is_base_of<FeedEngine, EngineT>::value, bool>::type
                process(EngineT& engine)
                {
                    return engine.process().eventsDispatched();
                }
 
                template <typename EngineT, typename... T>
                bool process(EngineT& engine, T &&... args)
                {
                    return process(engine) + process(args...);
                }

                struct FeedEngineThreadIdle
                {
                    enum Reason
                    {
                        DataWaitTimeout,

                        Redundant
                    };
                };

                struct FeedEngineThreadPoolSettings
                {
                    FeedEngineThreadPoolSettings()
                      : threadAffinity_()
                      , spinBeforeIdleTime_(1)
                      , threadCount_(1)
                    {
                    }

                    const System::ThreadAffinity& threadAffinity() const
                    {
                        return threadAffinity_;
                    }

                    System::ThreadAffinity& threadAffinity()
                    {
                        return threadAffinity_;
                    }

                    UInt32 threadCount() const
                    {
                        return threadCount_;
                    }

                    void threadCount(UInt32 value)
                    {
                        threadCount_ = value;
                    }

                    UInt32 spinBeforeIdleTime() const
                    {
                        return spinBeforeIdleTime_;
                    }

                    void spinBeforeIdleTime(UInt32 value)
                    {
                        spinBeforeIdleTime_ = value;
                    }
 
                private:
                    System::ThreadAffinity threadAffinity_;
                    UInt32 spinBeforeIdleTime_;
                    UInt32 threadCount_;
                };
 
                class ONIXS_B3_UMDF_MD_API FeedEngineThreadPool;

                struct ONIXS_B3_UMDF_MD_API FeedEngineThreadPoolListener
                {
                    virtual void onFeedEngineThreadBegin(const FeedEngineThreadPool&) {}

                    virtual void onFeedEngineThreadEnd(const FeedEngineThreadPool&) {}

                    virtual void onFeedEngineThreadIdle(const FeedEngineThreadPool&, FeedEngineThreadIdle::Reason, UInt32&) {}

                    virtual ~FeedEngineThreadPoolListener() = 0;
                };

                class ONIXS_B3_UMDF_MD_API FeedEngineThreadPool
                {
                public:
                    FeedEngineThreadPool(
                        const FeedEngineThreadPoolSettings&, FeedEngine*, FeedEngineThreadPoolListener* = nullptr);
 
                    FeedEngineThreadPool(
                        const FeedEngineThreadPoolSettings&, const std::vector<FeedEngine*>&, FeedEngineThreadPoolListener* = nullptr);
 
                    ~FeedEngineThreadPool();
 
                    const FeedEngineThreadPoolSettings& settings() const;
 
                private:
                    FeedEngineThreadPool(const FeedEngineThreadPool&);
                    FeedEngineThreadPool& operator=(const FeedEngineThreadPool&);
 
                    const FeedEngineThreadPoolSettings settings_;
                    class FeedEngineThreadPoolImpl;
                    FeedEngineThreadPoolImpl* const impl_;
                };
            }
        }
    }
}