---

oscl_scheduler.h

Go to the documentation of this file.

#ifndef OSCL_SCHEDULER_H_INCLUDED
#define OSCL_SCHEDULER_H_INCLUDED

#ifndef OSCL_SCHEDULER_TYPES_H_INCLUDED
#include "oscl_scheduler_types.h"
#endif

#ifndef OSCL_SCHEDULER_AO_H_INCLUDED
#include "oscl_scheduler_ao.h"
#endif

#ifndef OSCL_SCHEDULER_THREADCONTEXT_H_INCLUDED
#include "oscl_scheduler_threadcontext.h"
#endif

#ifndef OSCL_MUTEX_H_INCLUDED
#include "oscl_mutex.h"
#endif

#ifndef OSCL_SEMAPHORE_H_INCLUDED
#include "oscl_semaphore.h"
#endif

#ifndef OSCL_SCHEDULER_READYQ_H_INCLUDED
#include "oscl_scheduler_readyq.h"
#endif

#ifndef OSCL_DEFALLOC_H_INCLUDED
#include "oscl_defalloc.h"
#endif

#ifndef OSCL_MEM_H_INCLUDED
#include "oscl_mem.h"
#endif

class Oscl_DefAlloc;
class OsclCoeActiveScheduler;


class OsclScheduler
{
    public:
        OSCL_IMPORT_REF static void Init(const char *name, Oscl_DefAlloc *alloc = NULL, int nreserve = 20);


        OSCL_IMPORT_REF static void Cleanup();
};


#define PVSCHEDNAMELEN 30

class PVSchedulerStopper;
class PVJump;
class PVLogger;

class OsclSchedulerObserver
{
    public:
        virtual void OsclSchedulerTimerCallback(OsclAny* aContext, uint32 aDelayMsec) = 0;

        virtual void OsclSchedulerReadyCallback(OsclAny* aContext) = 0;

        virtual ~OsclSchedulerObserver() {}
};


/*
** A common base class for variations of OsclExecScheduler
**/

class OsclExecSchedulerCommonBase
{
    public:
        OSCL_IMPORT_REF void StartScheduler(OsclSemaphore *sem = NULL);

        OSCL_IMPORT_REF void StopScheduler();

        OSCL_IMPORT_REF void SuspendScheduler();

        OSCL_IMPORT_REF void ResumeScheduler();

        OSCL_IMPORT_REF void StartNativeScheduler();

        OSCL_IMPORT_REF static OsclNameString<PVSCHEDNAMELEN> *GetName();

        OSCL_IMPORT_REF static uint32 GetId();


    protected:
        /*
        static OsclExecScheduler *NewL(const char *name,Oscl_DefAlloc *a,int nreserve);
        */
        virtual ~OsclExecSchedulerCommonBase();
        void InstallScheduler();
        void UninstallScheduler();
        friend class OsclScheduler;

    protected:
        void Error(int32 anError) const;

    protected:
        static OsclExecSchedulerCommonBase* GetScheduler();
        static OsclExecSchedulerCommonBase* SetScheduler(OsclExecSchedulerCommonBase*);
        friend class PVThreadContext;
        friend class OsclCoeActiveScheduler;

    protected:
        OsclExecSchedulerCommonBase(Oscl_DefAlloc*);
        virtual void ConstructL(const char *name, int);

        void BeginScheduling(bool blocking, bool native);
        void EndScheduling();

        void BlockingLoopL();

        bool iBlockingMode;//current blocking mode setting.
        bool iNativeMode;//current native mode setting.

        bool IsStarted();
        inline bool IsInstalled();

        //Stopper AO is a special PV AO used to implement
        //the StopScheduler and SuspendScheduler functions.
        PVSchedulerStopper *iStopper;
        OsclNoYieldMutex iStopperCrit;

        //Scheduler thread context
        PVThreadContext iThreadContext;

        //Scheduler name
        OsclNameString<PVSCHEDNAMELEN> iName;

        //For stop, suspend, and resume commands.
        bool iDoStop;
        bool iDoSuspend;
        bool iSuspended;
        OsclSemaphore iResumeSem;

        OsclErrorTrapImp* iErrorTrapImp;

        //Ready AO queue.  The AOs in this queue are ready to run.
        OsclReadyQ iReadyQ;

        //Pending Timer AO queue.  The AOs in this queue are OsclTimerObjects
        //and have a timeout pending.
        OsclTimerQ iExecTimerQ;
        void AddToExecTimerQ(PVActiveBase *active, uint32);

        void PendComplete(PVActiveBase *, int32 aReason, TPVThreadContext aContext);
        void RequestCanceled(PVActiveBase*);

        //Scheduling loop implementation.
        PVActiveBase* UpdateTimers(uint32 &aDelay);
        PVActiveBase* UpdateTimersMsec(uint32 &aDelay);
        PVActiveBase* WaitForReadyAO();
        void CallRunExec(PVActiveBase*);

        static const uint32 iTimeCompareThreshold;
        friend class OsclTimerCompare;
        friend class OsclReadyQ;

        friend class OsclError;



        uint32 iNumAOAdded;//for non-fair-scheduling sorts.

        //For statistics
#if (PV_SCHED_ENABLE_AO_STATS)
        OsclDoubleList<PVActiveStats> iPVStatQ;//queue of all PV ExecObjs.
        enum TOtherExecStats
        {
            EOtherExecStats_WaitTime //scheduler wait time
            , EOtherExecStats_QueueTime //scheduler queue operation time
            , EOtherExecStats_NativeOS //time in symbian native ExecObjs, not added by PV code (symbian only)
            , EOtherExecStats_ReleaseTime //thread release time (Brew only)
            , EOtherExecStats_Last
        };
        PVActiveStats* iOtherExecStats[EOtherExecStats_Last];//placeholder for stats of all ExecObjs.
        void ConstructStatQ();
        void BeginStats();
        void EndStats();
        static void ShowStats(PVActiveStats *active);
        static void ShowSummaryStats(PVActiveStats *active, PVLogger*, int64, int64&, float&);
        void CleanupStatQ();
        uint8* iTotalTicksTemp;
        int64 iGrandTotalTicks;
        float iTotalPercent;
        friend class PVActiveStats;
        uint32 iTime;
        int32 iDelta;
        PVActiveStats* iPVStats;
#endif //PV_SCHED_ENABLE_AO_STATS

        //Queue utils.
        PVActiveBase *FindPVBase(PVActiveBase *active, OsclDoubleList<PVActiveBase> &);
        void CleanupExecQ();
        void InitExecQ(int);

        PVLogger *iLogger;
        PVLogger* iDebugLogger;

#if(PV_SCHED_ENABLE_PERF_LOGGING)
        //for perf logging
        char* iLogPerfIndentStr;
        int32 iLogPerfIndentStrLen;
        uint32 iLogPerfTotal;
        void ResetLogPerf();
        void IncLogPerf(uint32);
#endif

        Oscl_DefAlloc *iAlloc;//allocator for scheduler.
        OsclMemAllocator iDefAlloc;//default allocator

        friend class OsclActiveObject;
        friend class OsclTimerObject;
        friend class PVActiveBase;
        friend class PVSchedulerStopper;


        friend class OsclExecScheduler;
};

class OsclErrorTrapImp;

class OsclExecScheduler: public OsclExecSchedulerCommonBase
            , public OsclExecSchedulerBase
{
    public:
        OSCL_IMPORT_REF static OsclExecScheduler* Current();

        OSCL_IMPORT_REF void RunSchedulerNonBlocking(int32 aTargetCount, int32 &aReady, uint32 &aDelayMsec);

        OSCL_IMPORT_REF void RegisterForCallback(OsclSchedulerObserver* aCallback, OsclAny* aCallbackContext);


    private:
        static OsclExecScheduler *NewL(const char *name, Oscl_DefAlloc *a, int nreserve);
        ~OsclExecScheduler();
        friend class OsclScheduler;


        OsclExecScheduler(Oscl_DefAlloc*);
        void ConstructL(const char *name, int);

};


class PVSchedulerStopper: public OsclActiveObject
{
    public:
        PVSchedulerStopper();
        ~PVSchedulerStopper();
    private:
        void Run();
};


#endif

---