OSDLScheduler.h

Go to the documentation of this file.

#ifndef OSDL_SCHEDULER_H_
#define OSDL_SCHEDULER_H_



// for ListOfActiveObjects, SchedulingException, etc. :
#include "OSDLEngineCommon.h"         
#include "OSDLEvents.h"               // for SimulationTick
#include "OSDLPeriodicSlot.h"         // for PeriodicSlot


// for inheritance, SingletonException, time units :
#include "Ceylan.h"                   


#include <string>
#include <list>
#include <map>



namespace OSDL
{

    namespace Events
    {
    
    
        // Scheduler is managed by the event module.
        class EventsModule ;
        
    }


    namespace Rendering
    {
    
    
        // The scheduler may use a dedicated renderer for rendering concerns.
        class Renderer ;
        
    }

    
    namespace Video
    {
    
        /*
         * The scheduler fallbacks to the video module if no renderer is 
         * being used.
         *
         */
        class VideoModule ;
        
    }
    
    
    namespace Engine 
    {
    
        
        // The scheduler schedules active objects.
        class ActiveObject ;


        // The scheduler uses periodic slots for periodically activated objects.
        class PeriodicSlot ;
        
                
        class OSDL_DLL Scheduler : public Ceylan::Object
        {
        
        
            typedef Ceylan::Uint32 Delay ;
            
            
            public:
            
            
                
                virtual bool hasRenderer() const throw() ;


                virtual Rendering::Renderer & getRenderer() const 
                    throw( SchedulingException ) ;


                virtual void setRenderer( Rendering::Renderer & newRenderer )
                    throw() ;
                
                
                
                virtual void setScreenshotMode( bool on, 
                    const std::string & frameFilenamePrefix, 
                    Events::Hertz frameFrequency = 25 ) throw() ;
                
                
                virtual void setTimeSliceDuration( 
                    Ceylan::System::Microsecond engineTickDuration ) throw() ;

    
                virtual Ceylan::System::Microsecond getTimeSliceDuration() 
                    const throw() ;
                
                
                virtual void setSimulationFrequency( Events::Hertz frequency ) 
                    throw( SchedulingException ) ;

                
                virtual Events::Period getSimulationTickCount() const throw() ;
                
                
                virtual void setRenderingFrequency( Events::Hertz frequency ) 
                    throw( SchedulingException ) ;

                
                virtual Events::Period getRenderingTickCount() const throw() ;
            
                
                virtual void setScreenshotFrequency( Events::Hertz frequency ) 
                    throw( SchedulingException ) ;

                
                virtual Events::Period getScreenshotTickCount() const throw() ;
                
                
                virtual void setInputPollingFrequency( 
                    Events::Hertz frequency ) throw( SchedulingException ) ;


                virtual Events::Period getInputPollingTickCount() 
                    const throw() ;

                
                virtual void setIdleCallback( 
                    Ceylan::System::Callback idleCallback = 0 , 
                    void * callbackData = 0,
                    Ceylan::System::Microsecond 
                        callbackExpectedMaxDuration = 0 ) throw() ;
                
                
                
                
                virtual Events::EngineTick getCurrentEngineTick() 
                    const throw() ;
                
                
                virtual Events::SimulationTick getCurrentSimulationTick() 
                    const throw() ;
                
                
                virtual Events::RenderingTick getCurrentRenderingTick() 
                    const throw() ;
                
                
                virtual Events::RenderingTick getCurrentInputTick() 
                    const throw() ;
                
                
                virtual void registerObject( ActiveObject & toRegister ) 
                    throw() ;
                        
                
                virtual void schedule() throw( SchedulingException ) ;
                            
                                
                virtual void stop() throw() ;
                
                                        
                virtual const std::string toString( 
                        Ceylan::VerbosityLevels level = Ceylan::high ) 
                    const throw() ;



                // Static section.


                static Scheduler & GetExistingScheduler() 
                    throw( SchedulingException ) ;

            
                static Scheduler & GetScheduler() throw() ;


                static void DeleteExistingScheduler() 
                    throw( SchedulingException ) ;
        
        
                static void DeleteScheduler() throw() ;
        
    
                    
                static const Ceylan::System::Microsecond
                    DefaultEngineTickDuration = 1000 ;
                    
                    
                static const Events::Hertz DefaultSimulationFrequency = 100 ;
                    
                    
                static const Events::Hertz DefaultRenderingFrequency = 40 ;
                    
                    
                static const Ceylan::Uint32 DefaultMovieFrameFrequency = 25 ;
                
                
                static const Events::Hertz DefaultInputFrequency = 20 ;
                    

                    
            protected:
            

                explicit Scheduler() throw() ;
                
                
                virtual ~Scheduler() throw() ;


                virtual void scheduleBestEffort() throw( SchedulingException ) ;
                

                virtual void scheduleNoDeadline( bool pollInputs = true ) 
                    throw( SchedulingException ) ;
                
                
                virtual Events::EngineTick computeEngineTickFromCurrentTime()
                    throw() ;


                virtual void scheduleSimulation( 
                    Events::SimulationTick current ) throw() ;


                virtual void scheduleProgrammedObjects( 
                    Events::SimulationTick current ) throw() ;


                virtual void schedulePeriodicObjects( 
                    Events::SimulationTick currentSimulationTick ) throw() ;


                virtual void scheduleRendering( 
                    Events::RenderingTick currentRenderingTick ) throw() ;
                     
                     
                virtual void scheduleInput( Events::InputTick currentInputTick )
                     throw() ;


                virtual void scheduleActiveObjectList( 
                    Events::RenderingTick currentSimulationTick, 
                    ListOfActiveObjects & objectList ) throw() ;
                    
                    
                virtual void onSimulationSkipped( 
                        Events::SimulationTick skipped ) 
                    throw( SchedulingException ) ;
                

                virtual void onRenderingSkipped( 
                        Events::RenderingTick skipped ) 
                    throw( SchedulingException ) ;
                                

                virtual void onInputSkipped( Events::InputTick skipped ) 
                    throw( SchedulingException ) ;
                                
                
                virtual void onIdle() throw() ;


                static const Delay ShutdownBucketLevel ;
                
                
                virtual void onScheduleFailure( Delay currentBucket ) throw() ;


                
                virtual void programTriggerFor( ActiveObject & objectToProgram,
                    Events::SimulationTick targetTick ) throw() ;
                

                virtual PeriodicSlot & getPeriodicSlotFor( 
                    Events::Period period ) throw() ;
                


                // Variable section.
                
                
                bool _screenshotMode ;      
                
                
                std::string _frameFilenamePrefix ;      

                
                Events::Hertz _desiredScreenshotFrequency ;
                
                
                 Events::Period _screenshotPeriod ;     
                

/* 
 * Takes care of the awful issue of Windows DLL with templates.
 *
 * @see Ceylan's developer guide and README-build-for-windows.txt 
 * to understand it, and to be aware of the associated risks. 
 * 
 */
#pragma warning( push )
#pragma warning( disable : 4251 )
            
            
                std::list<PeriodicSlot *> _periodicSlots ; 
                
                
                std::map<Events::SimulationTick, ListOfActiveObjects>
                    _programmedActivated ;      
                
#pragma warning( pop ) 

                
                Ceylan::System::Microsecond _engineTickDuration ;
                
                
                Ceylan::Uint32 _secondToEngineTick ;
                
                
                Events::EngineTick _currentEngineTick ;
                
                
                Events::SimulationTick _currentSimulationTick ;
                
                
                Events::RenderingTick _currentRenderingTick ;
                
                
                Events::RenderingTick _currentInputTick ;
                
                
                Events::Period _simulationPeriod ;
                
                
                Events::Period _renderingPeriod ;
                
                
                Events::Period _inputPeriod ;
                
                
                Events::Hertz _desiredSimulationFrequency ;
                
                
                Events::Hertz _desiredRenderingFrequency ;
        
        
                Events::Hertz _desiredInputFrequency ;



                
                // Idle callback section.
                
                

                Ceylan::System::Callback _idleCallback ;
                        
                                
                void * _idleCallbackData ;              
        
        
                Ceylan::System::Microsecond _idleCallbackMaxDuration ;
        
        
                Ceylan::Uint32 _idleCallsCount ;
        
        
        
                bool _stopRequested ;
        
        
                Ceylan::System::Second _scheduleStartingSecond ;
                
                
                Ceylan::System::Microsecond _scheduleStartingMicrosecond ;      
        
        
        
                Ceylan::Uint32 _recoveredSimulationTicks ;
        
        
                Ceylan::Uint32 _missedSimulationTicks ;
        
        
        
                Ceylan::Uint32 _recoveredRenderingTicks ;
        
        
                Ceylan::Uint32 _missedRenderingTicks ;
        
        
        
                Ceylan::Uint32 _recoveredInputPollingTicks ;
        
        
                Ceylan::Uint32 _missedInputPollingTicks ;
        
        
                Ceylan::Uint32 _scheduleFailureCount ;
        

                Events::EventsModule * _eventsModule ;
                
        
                Rendering::Renderer * _renderer ;
        
        
                Video::VideoModule * _videoModule ;
                
                
                 
            private:
            
            
                explicit Scheduler( const Scheduler & source ) throw() ;
            
            
                Scheduler & operator = ( const Scheduler & source ) throw() ;
                            
                
                static Scheduler * _internalScheduler ;
            
                
        } ;

    }

}


#endif // OSDL_SCHEDULER_H_

---