Changeset 12 for nrEngine


Ignore:
Timestamp:
12/16/2006 10:39:50 PM (13 years ago)
Author:
art
Message:
  • Friendly thread execution added (yielding of threads and main thread)
  • Test directory added, where simple test programms will be build
  • Each Makefile now contains the TOPDIR variable
Location:
nrEngine
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/Makefile

    r11 r12  
    1 #------------------------------------ 
    2 # Bypass the targets to subdirs 
    3 #------------------------------------ 
    4 include ../Make/Makedefs 
     1TOPDIR = .. 
     2 
     3include $(TOPDIR)/Make/Makedefs 
    54 
    65SUBDIRS = include/events include src 
    76         
    8 include ../Make/Makedirrules 
     7include $(TOPDIR)/Make/Makedirrules 
  • nrEngine/include/Engine.h

    r1 r12  
    158158                        static Engine* instance(bool release = false); 
    159159 
     160                        /** 
     161                         * Get the pointer to the instance of the engine 
     162                         **/ 
     163                        static Engine* sEngine() { return instance(); } 
     164                         
    160165                         /** 
    161166                         * Check whenever the engine'S singleton was created before 
  • nrEngine/include/IThread.h

    r11 r12  
    7070         * methods in ITask interface. 
    7171         * 
     72         * Our threads does yield their time slice to another threads after each execution cycle. 
     73         * In this manner we get a friendly and intuitive behaviour of threads running in parallel. 
     74         * 
    7275         * NOTE: The IThread interaface and Kernel does do all the job for you to manage 
    7376         * themself as a threads and to let them run in parallel. The only one thing it 
     
    129132                         **/ 
    130133                        static void* run(void* mythread); 
    131                         //static void run(IThread* mythread); 
    132134 
    133135                        //! Kernel is a friend class 
    134136                        friend class Kernel; 
    135137 
     138                        /** 
     139                         * Call the appropriate yield method of the threading library. 
     140                         * The thread calling this method will yield its remaining timeslice 
     141                         * to other threads. 
     142                         * 
     143                         * @param mythread Pointer to the thread which yields. 
     144                         *              If NULL specified, so the called thread will be yield. 
     145                         **/ 
     146                        static void yield(IThread* mythread = NULL); 
     147                         
    136148                        /** 
    137149                         * Kernel does call this method if the appropriate task is running 
     
    178190 
    179191                        // Mutex to lock the data before use 
    180                         //pthread_mutex_t mMutex; 
     192                        // pthread_mutex_t mMutex; 
    181193 
    182194                        //! Store here the thread instance 
     
    184196 
    185197                        //! Thread attributes 
    186                         pthread_attr_t mThreadJoinableAttr; 
     198                        pthread_attr_t mThreadAttr; 
    187199                         
    188200                        //! Change a thread to new state, use mutex to lock the state 
  • nrEngine/src/IThread.cpp

    r11 r12  
    4949                NR_Log(Log::LOG_KERNEL, "IThread: Create thread and start it"); 
    5050 
     51                // initialise the attribute 
     52                pthread_attr_init(&mThreadAttr); 
     53 
    5154                // create the joinable attribute for thsi thread 
    52                 pthread_attr_init(&mThreadJoinableAttr); 
    53                 pthread_attr_setdetachstate(&mThreadJoinableAttr, PTHREAD_CREATE_JOINABLE); 
     55                pthread_attr_setdetachstate(&mThreadAttr, PTHREAD_CREATE_JOINABLE); 
    5456 
     57                // setup thread scheduling attribute 
     58                pthread_attr_setschedpolicy(&mThreadAttr, SCHED_RR); 
     59                /*if ( pthread_attr_setschedparam(&mThreadAttr, &param1) != 0 ) { 
     60                        printf("pthread_attr_setschedparam failed"); 
     61                        exit(0); 
     62                }*/ 
     63                 
    5564                // now create a thread and let it run 
    56                 //mThread = new boost::thread(boost::bind(IThread::run, this));          
    5765                mThreadState = THREAD_RUNNING; 
    58                 int res = pthread_create(&mThread, &mThreadJoinableAttr, IThread::run, (void *)this); 
     66                int res = pthread_create(&mThread, &mThreadAttr, IThread::run, (void *)this); 
    5967                if (res){ 
    6068                        NR_Log(Log::LOG_KERNEL, Log::LL_ERROR, "IThread: creation of a thread failed with error code %d", res); 
     
    7280                // join the thread to the main process 
    7381                //mThread->join(); 
    74                 pthread_attr_destroy(&mThreadJoinableAttr); 
     82                pthread_attr_destroy(&mThreadAttr); 
    7583                int res = pthread_join(mThread, NULL); 
    7684                if (res){ 
     
    107115                //pthread_mutex_unlock(&mMutex); 
    108116                 
     117        } 
     118 
     119        //-------------------------------------------------------------------- 
     120        void IThread::yield(IThread* mythread) 
     121        { 
     122                // use pthread to yield the timeslice 
     123                pthread_yield(); 
    109124        } 
    110125 
     
    147162                        // this is a reading mutex, so do not have to lock it 
    148163                        run = mythread->mThreadState != THREAD_STOP; 
     164 
     165                        // we now yield the used timeslice for another threads 
     166                        yield(mythread); 
    149167                } 
    150168                 
  • nrEngine/src/Kernel.cpp

    r1 r12  
    130130                } 
    131131 
     132                // Now we yield the running thread, so that we get user friendly 
     133                // thread behaviour. 
     134                IThread::yield(); 
     135                 
     136                // return good result 
    132137                return OK; 
    133138        } 
Note: See TracChangeset for help on using the changeset viewer.