kernel_intf.h

Go to the documentation of this file.

#pragma once
#include <adtfucom3/adtf_ucom3.h>
#include <adtfbase/runnable_intf.h>
#include <adtfbase/string_intf.h>

#define CID_ADTF_KERNEL "kernel.service.adtf.cid"
 
namespace adtf
{
namespace services
{
namespace ant
{

class IKernel: public ucom::IObject
{
    public:
        ADTF_IID(IKernel, "kernel.ant.services.adtf.iid");
 
    protected:
        ~IKernel() = default;
 
    public:
        enum class tSchedulingClass: uint32_t
        {
            Default = 0, 
            Normal = 1, 
            RealTime = 2, 
        };

        enum tThreadFlags // untyped for combinations
        {
            THF_None = 0, 
            THF_Detached = 1 
        };

        enum class tTimerClock: uint32_t
        {
            ADTF = 0, 
            Monotonic = 1, 
            RealTime = 2, 
        };

        enum tTimerFlags: uint8_t
        {
            TIF_None = 0, 
            TIF_Reschedule = 1, 
            TIF_Drop = 2, 
            TIF_ErrorLog = 4, 
            TIF_ErrorStop = 8, 
        };

        struct tSchedulingInfo
        {
            tSchedulingInfo(tSchedulingClass eSchedulingClass = tSchedulingClass::Default,
                            float         fPriority = -1.0,
                            const uint8_t*    pProcessorAffinity = nullptr,
                            size_t            nProcessorAffinityByteCount = 0):
                eSchedulingClass(eSchedulingClass),
                fPriority(fPriority)
            {
                if (pProcessorAffinity == nullptr)
                {
                    adtf_util::cMemoryBlock::MemSet(aProcessorAffinity, 0xFF, sizeof(aProcessorAffinity));
                }
                else
                {
                    adtf_util::cMemoryBlock::MemSet(aProcessorAffinity, 0x00, sizeof(aProcessorAffinity));
                    adtf_util::cMemoryBlock::MemCopy(aProcessorAffinity, pProcessorAffinity,
                                                     std::min<size_t>(nProcessorAffinityByteCount, sizeof(aProcessorAffinity)));
                }
            }
 
            tSchedulingClass eSchedulingClass; 
            float         fPriority; 
            uint8_t           aProcessorAffinity[128]; 
        };

        class IScheduling: public ucom::IObject
        {
            public:
                ADTF_IID(IScheduling, "scheduling.ant.kernel.services.adtf.iid");
 
            protected:
                ~IScheduling() = default;
 
            public:
                virtual tResult GetScheduling(tSchedulingInfo& sScheduling) const = 0;

                virtual tResult SetScheduling(const tSchedulingInfo& sScheduling) = 0;
        };

        class IThread: public ucom::IObject
        {
            public:
                ADTF_IID(IThread, "thread.ant.kernel.services.adtf.iid");
 
            protected:
                ~IThread() = default;
 
            public:
                virtual tResult Detach() = 0;

                virtual bool IsCurrent() const = 0;

                virtual tResult Join(tTimeStamp nTimeout = -1) = 0;
        };

        class ITimer: public ucom::IObject
        {
            public:
                ADTF_IID(ITimer, "timer.ant.kernel.services.adtf.iid");
 
            protected:
                ~ITimer() = default;
            public:
                virtual tResult Stop() = 0;
        };

        enum tSignalFlags // untyped for combinations
        {
            SIG_None = 0, 
            SIG_Async = 1 
        };

        class ISignal: public ucom::IObject
        {
            public:
                ADTF_IID(ISignal, "signal.ant.kernel.services.adtf.iid");
 
            protected:
                ~ISignal() = default;
 
            public:
                virtual int32_t GetClass() const = 0;

                virtual int32_t GetCode() const = 0;
        };

        class ISignalHandler
        {
            protected:
                ~ISignalHandler() = default;
 
            public:
                virtual tResult HandleKernelSignal(const adtf::ucom::iobject_ptr<ISignal>& pSignal) = 0;
        };

        class IKernelRunnable : public adtf::ucom::IObject,
                                public adtf::base::ant::IRunnable
        {
            public:
                ADTF_IID(IKernelRunnable, "runnable.ant.kernel.services.adtf.iid");
            protected:
                ~IKernelRunnable() = default;
        };
 
 
    public:
        virtual tResult ThreadCreate(adtf::ucom::iobject_ptr<IThread>& pThread, const char* strThreadName,
                                     const adtf::ucom::iobject_ptr<IKernelRunnable>& pKernelRunnable,
                                     const void* pUserData = nullptr,
                                     size_t nUserDataSize = 0,
                                     const tSchedulingInfo& sScheduling = tSchedulingInfo(),
                                     uint32_t ui32Flags = tThreadFlags::THF_None) = 0;

        virtual tResult TimerCreate(adtf::ucom::iobject_ptr<ITimer>& pTimer, const char* strTimerName,
                                    tTimeStamp nPeriod,
                                    tTimeStamp nInitialDelay,
                                    const adtf::ucom::iobject_ptr<IKernelRunnable>& pKernelRunnable,
                                    const void* pUserData = nullptr,
                                    size_t nUserDataSize = 0,
                                    tTimerClock eClock = tTimerClock::ADTF,
                                    const tSchedulingInfo& sScheduling = tSchedulingInfo(),
                                    uint32_t ui32Flags = tTimerFlags::TIF_None) = 0;        

        virtual tResult SignalSend(const adtf::ucom::iobject_ptr<ISignal>& pSignal, uint32_t ui32Flags = tSignalFlags::SIG_None) = 0;

        virtual tResult SignalRegister(ISignalHandler& oHandler, uint32_t ui32Flags = tSignalFlags::SIG_None) = 0;

        virtual tResult SignalUnregister(ISignalHandler& oHandler) = 0;

        virtual tResult GetObjects(adtf::ucom::iobject_enum<IObject>& oObjects) = 0;
};
 
}
 
namespace devil
{

class IKernel: public ant::IKernel
{
    public:
        ADTF_IID(IKernel, "kernel.devil.services.adtf.iid");
 
    public:

        class INamedKernelObject: public ucom::ant::IObject
        {
            public:
                ADTF_IID(INamedKernelObject, "named_kernel_object.devil.kernel.services.adtf.iid");
 
            public:
                virtual tResult GetName(base::ant::IString&& strName) const = 0;
        };
};
 
}
 
namespace penguin
{

class IKernel: public devil::IKernel
{
    public:
        ADTF_IID(IKernel, "kernel.penguin.services.adtf.iid");
 
    public:
 
        using devil::IKernel::TimerCreate;

        virtual tResult TimerCreate(adtf::ucom::iobject_ptr<ITimer>& pTimer, const char* strTimerName,
                                    tTimeStamp nPeriod,
                                    tTimeStamp nInitialDelay,
                                    tTimeStamp nMaximumExecutionTime,
                                    const adtf::ucom::iobject_ptr<IKernelRunnable>& pKernelRunnable,
                                    const void* pUserData = nullptr,
                                    size_t nUserDataSize = 0,
                                    tTimerClock eClock = tTimerClock::ADTF,
                                    const tSchedulingInfo& sScheduling = tSchedulingInfo(),
                                    uint32_t ui32Flags = tTimerFlags::TIF_None) = 0;
};
 
}
 
using penguin::IKernel;
 
}
 
}