RTController.h

/*
 * Licensed Materials - Property of HCL and/or IBM
 * Copyright HCL Technologies Ltd. 2016, 2021. All Rights Reserved.
 * Copyright IBM Corporation 1999, 2016. All Rights Reserved.
 *
 * U.S. Government Users Restricted Rights -  Use, duplication or 
 * disclosure restricted by GSA ADP Schedule.
 */
 
#ifndef __RTController_h__
#define __RTController_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTJob_h__
#include <RTJob.h>
#endif
 
#ifndef __RTMessageQ_h__
#include <RTMessageQ.h>
#endif
 
#ifndef __RTPriority_h__
#include <RTPriority.h>
#endif
 
#ifndef __RTResourceMgr_h__
#include <RTResourceMgr.h>
#endif
 
#if RTS_COUNT && ! defined( __RTCounts_h__ )
#include <RTCounts.h>
#endif
 
class  RTActor;
struct RTActorClass;
struct RTComponentDescriptor;
class  RTDaemonInfo;
class  RTDebugger;
class  RTEventInfo;
class  RTSyncObject;
class  RTTimerNode;
 
typedef void ( RTActor:: * RTActorFunction )( void );
 
class RTController : public RTJob
{
private:
    friend class RTMessage;
    friend class RTProtocol;
 
    const char        * _name;
 
#if OTRTSDEBUG != DEBUG_NONE
    friend class RTDebugger;
 
    RTDebugger        * _debugger;
    RTController      * _prev;
    RTController      * _next;
 
    enum
    {
        detached,       // execution is independent of the debugger
        execSystem,     // executing in system code (between chains)
        waitBegin,      // awaiting permission to begin executing a chain
        waitDone,       // executing in system code (in a chain)
        execUser,       // executing in user code (in a chain)
        waitContinue    // awaiting permission to continue executing a chain
    } _state;
#endif // OTRTSDEBUG != DEBUG_NONE
 
public:
    RTController( RTDebugger * debug,
                  const char * name );
    virtual             ~RTController( void );
 
    enum Primitive
    {
        CommDefer,
        CommDeliver,
        CommInvoke,
        CommPurge,
        CommRecall,
        CommRecallAll,
        CommReply,
        CommSend,
        ExceptionRaise,
        FrameDeport,
        FrameDestroy,
        FrameImport,
        FrameIncarnate,
        LayerBind,
        LayerRegisterSAP,
        LayerDeregisterSAP,
        LayerRegisterSPP,
        LayerDeregisterSPP,
        LayerResize,
        LayerResizeSAP,
        LayerResizeSPP,
        RegisterLayer,
        TimerCancel,
        TimerInform,
 
        SystemService
    };
 
    enum Error
    {
        ok,
 
        // code             triggered by
        // ====             ============
 
        alreadyDeferred, // CommDefer
        badActor,        // FrameDeport FrameDestroy FrameImport
        badClass,        // CommDeliver CommInvoke CommReply CommSend FrameImport FrameIncarnate
        badId,           // TimerCancel
        badIndex,        // FrameIncarnate CommInvoke CommSend
        badInterface,    // FrameImport FrameIncarnate
        badOperation,    // LayerDeregister LayerRegister, RegisterLayer, LayerResize{,SAP,SPP}
        badRef,          // FrameImport FrameIncarnate
        badSignal,       // CommInvoke CommReply CommSend
        badValue,        // LayerResize{,SAP,SPP}
        deferInvoke,     // CommDefer CommInvoke
        dereg,           // LayerDeregister
        imported,        // FrameDestroy FrameIncarnate
        noConnect,       // CommInvoke CommReply TimerInform
        noFreePorts,     // FrameImport
        noMem,           // all
        noReply,         // CommInvoke
        notImported,     // FrameDeport FrameImport
        notOptional,     // FrameDestroy
        notOwner,        // FrameDeport FrameDestroy FrameImport FrameIncarnate
        prio,            // CommReply CommSend TimerInform
        protocolSignal,  // FrameImport FrameIncarnate LayerBind
        protocolType,    // FrameImport FrameIncarnate LayerBind
        recursiveInvoke, // CommInvoke
        refFull,         // FrameImport FrameIncarnate
        reg,             // LayerRegister
        replRef,         // FrameImport
        smallInterface,  // FrameImport FrameIncarnate
        tooManySAPs,     // (nothing)
        xRtsInvoke       // CommInvoke
    };
 
#if RTS_COMPATIBLE <= 520
    typedef Error       rtsErrors; // for backwards compatibility
#endif
 
    Error               canPlugIn( const RTActorClass          *,
                                   const RTComponentDescriptor * );
 
private:
    Error               errorNumber;
 
public:
    RTS_INLINE Error    getError( void ) const;
 
    const char        * strerror( void ) const;
 
    void                perror( const char * s = "error" );
 
#if OTRTSDEBUG == DEBUG_NONE
    RTS_INLINE
#endif
 
    void                setError( Error error,
                                  Primitive primitive,
                                  const void * info,
                                  const void * detail);
 
#if OTRTSDEBUG < DEBUG_VERBOSE
    RTS_INLINE
#endif
    void                trace( Primitive, const void *, const void * );
#if OBSERVABLE
    void                breakPoint( RTActor *, RTEventInfo * );
    void                evtMsgQueue( void );
 
    void                getMessages( const RTDaemonInfo & daemonInfo );
#endif
 
    virtual const char * name( void ) const override;
 
    virtual void        kill( void ) override;
 
    virtual void        printStats( void ) const;
 
    void                abort( void );
 
    RTS_INLINE RTDebugger * debugger( void );
 
    void                destroy( RTActor * actor, RTActor * owner );
 
    int                 send( RTActor              * receiver,
                              int                    controlSignal,
                              const void           * data,
                              const RTObject_class * type,
                              int                    priority );
 
    RTS_INLINE void     receive( RTMessage *, RTController * sender );
 
    // Receive a copy of the message
    RTS_INLINE int      receiveMsgCopy(const RTMessage*, RTController * sender);
 
#if USE_THREADS
    void                peer_receive( RTMessage * );
#endif
 
    void                requeueMsg( RTMessage *, int front );
 
    RTS_INLINE RTMessage * newMsg( void );
    RTS_INLINE void     freeMsg( RTMessage * );
 
    RTTimerNode       * newTimerNode( void );
    void                freeTimerNode( RTTimerNode * node );
 
protected:
    // public to implementation
 
    // values returned by dispatch
    enum
    {
        OneDelivered,
#if OTRTSDEBUG != DEBUG_NONE
        PermissionDenied,
#endif
        NoneToDeliver
    };
 
    int                 dispatch( int priorityLimit );
    void                awaitResponse( void );
    virtual void        waitForEvents( void ) = 0;
#if USE_THREADS
    virtual void        wakeup( void );
#endif
 
#if USE_THREADS
    RTSyncObject      * _sync;
#endif
 
private:
    static const unsigned char topPriority[ 1 << OTRTS_NUMPRIO ];
 
    RTMessageQ          internalQ[ OTRTS_NUMPRIO ];
 
#if USE_THREADS
    RTMessageQ          incomingQ[ OTRTS_NUMPRIO ];
#endif
 
    short               internalBits;
#if USE_THREADS
    short               incomingBits;
#endif
 
    RTMessage         * freeList;
    unsigned            freeListSize;
 
    RTTimerNode       * freeTimerList;
    unsigned            freeTimerListSize;
 
    // invoke reply messages are stored here
    RTMessage         * replyBuffer;
 
#if ! DEFER_IN_ACTOR
    RTMessageQ          deferredQ; // Deferred Messages Queue
#endif
 
    void                filterMessages( RTActor * receiver, RTQFilter & );
#if USE_THREADS
    void                acceptIncoming( void );
#endif
 
    static RTResourceMgr resourceMgr;
 
public:
    RTS_INLINE RTMessage * getReplyBuffer( void );
    RTS_INLINE RTMessage * setReplyBuffer( RTMessage * );
    RTS_INLINE void        restoreReplyBuffer( RTMessage * );
    virtual void           registerLayer(  RTActor * ,  RTActorFunction,
                RTActorFunction, RTActorFunction );
 
#if RTS_COUNT
    void                countActorDestroy   ( void );
    void                countActorIncarnate ( void );
    void                countMessageTransfer( RTMessage * );
    void                countPortDestroy    ( int );
    void                countPortIncarnate  ( int );
    void                countTimerCancel    ( void );
    void                countTimerExpire    ( void );
    void                countTimerStart     ( void );
 
protected:
    RTCounts            counts;
#else
    RTS_INLINE void     countActorDestroy   ( void );
    RTS_INLINE void     countActorIncarnate ( void );
    RTS_INLINE void     countMessageTransfer( RTMessage * );
    RTS_INLINE void     countPortDestroy    ( int );
    RTS_INLINE void     countPortIncarnate  ( int );
    RTS_INLINE void     countTimerCancel    ( void );
    RTS_INLINE void     countTimerExpire    ( void );
    RTS_INLINE void     countTimerStart     ( void );
#endif
 
private:
    // unavailable methods
    RTController( const RTController & );
    RTController & operator=( const RTController & );
}; //lint !e1712
 
#if RTS_INLINES
#include <RTController.inl>
#endif
 
#endif // __RTController_h__