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/Euronext/MarketData/OptiqMdg/ABI.h>
#include <OnixS/Euronext/MarketData/OptiqMdg/Integral.h>
#include <OnixS/Euronext/MarketData/OptiqMdg/Defines.h>
#include <OnixS/Euronext/MarketData/OptiqMdg/WatchService.h>
 
#include <string>
 
namespace OnixS
{
    namespace Euronext
    {
        namespace MarketData
        {
            namespace OptiqMdg
            {
                class NetFeedEngineProcessResult
                {
                public:
                    typedef UInt32 Flags;

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

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

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

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

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

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

                    void reserved(Flags flags) ONIXS_EURONEXT_OPTIQMDG_NOTHROW
                    {
                        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_EURONEXT_OPTIQMDG_API FeedEngine
                {
                public:
                    NetFeedEngineProcessResult process();

                    std::string info();

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

                inline bool process(FeedEngine& engine)
                {
                    return engine.process().eventsDispatched();
                }

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

                    ~SocketFeedEngine() ONIXS_EURONEXT_OPTIQMDG_OVERRIDE;
                };

                class ONIXS_EURONEXT_OPTIQMDG_API EfViFeedEngine : public FeedEngine
                {
                public:
                    explicit EfViFeedEngine(UInt32 receiveRingSize = 4095, WatchService& watch = NicWatch::service());

                    ~EfViFeedEngine() ONIXS_EURONEXT_OPTIQMDG_OVERRIDE;
                };

                struct FeedEngineThreadIdle
                {
                    enum Reason
                    {
                        DataWaitTimeout,

                        Redundant
                    };
                };

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

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

                    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:
                    ThreadAffinity threadAffinity_;
                    UInt32 spinBeforeIdleTime_;
                    UInt32 threadCount_;
                };
 
                class ONIXS_EURONEXT_OPTIQMDG_API FeedEngineThreadPool;

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

                    virtual void onFeedEngineThreadEnd(const FeedEngineThreadPool&) {}

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

                    virtual ~FeedEngineThreadPoolListener() {}
                };

                class ONIXS_EURONEXT_OPTIQMDG_API FeedEngineThreadPool
                {
                public:
                    FeedEngineThreadPool(
                        const FeedEngineThreadPoolSettings&, FeedEngine*, FeedEngineThreadPoolListener* = ONIXS_EURONEXT_OPTIQMDG_NULLPTR);
 
                    ~FeedEngineThreadPool();
 
                    const FeedEngineThreadPoolSettings settings() const;
 
                private:
                    FeedEngineThreadPool(const FeedEngineThreadPool&);
                    FeedEngineThreadPool& operator=(const FeedEngineThreadPool&);
 
                    const FeedEngineThreadPoolSettings settings_;
                    class FeedEngineThreadPoolImpl;
                    FeedEngineThreadPoolImpl* impl_;
                };

                class ONIXS_EURONEXT_OPTIQMDG_API ThisThread
                {
                public:
                    static void affinity(const ThreadAffinity&);
                    static void affinity(CpuIndex);
                };
            }
        }
    }
}