Changeset 1474:efb0facc02cc


Ignore:
Timestamp:
08/27/10 05:49:47 (18 months ago)
Author:
niam
Branch:
default
Message:

[pc::execution::scheduler] use pc::execution::thread rather than using pthreads/anything directly

Location:
sources
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • sources/include/libdodo/pcExecutionScheduler.h

    r1439 r1474  
    4545        namespace execution { 
    4646            class job; 
     47            class thread; 
    4748 
    4849            /** 
    … …  
    5152             */ 
    5253            class scheduler { 
    53                 friend struct __manager__; 
    54  
    5554              public: 
    5655 
    … …  
    8685              protected: 
    8786 
     87                /** 
     88                 * schedule manager 
     89                 * @return thread exit status 
     90                 * @param data defines user data 
     91                 */ 
     92                static int manager(void *data); 
     93 
    8894                struct __job__ { 
    8995                    execution::job *job; ///< job for scheduling 
    … …  
    98104 
    99105                sync::protector *keeper;            ///< section locker 
     106                execution::thread *thread; 
    100107 
    101                 __manager__ *manager; ///< schedule manager handle 
     108                __manager__ *handle; ///< schedule manager handle 
    102109            }; 
    103110        }; 

  • sources/src/pcExecutionScheduler.cc

    r1472 r1474  
    5757 
    5858#ifdef PTHREAD_EXT 
    59                 pthread_t      thread;              ///< thread descriptor 
    60  
    6159                pthread_mutex_t     mutex;          ///< event mutex 
    6260                pthread_cond_t      condition;      ///< condition lock 
    63  
    64                 /** 
    65                  * schedule manager 
    66                  * @return thread exit status 
    67                  * @param data defines user data 
    68                  */ 
    69                 static void *manager(void *data); 
    7061#endif 
    7162            }; 
    … …  
    8778 
    8879__manager__::__manager__() : exit(false) 
    89 #ifdef PTHREAD_EXT 
    90                            , 
    91                              thread(0) 
    92 #endif 
    9380{ 
    9481#ifdef PTHREAD_EXT 
    … …  
    130117//------------------------------------------------------------------- 
    131118 
    132 #ifdef PTHREAD_EXT 
    133 void * 
    134 __manager__::manager(void *data) 
     119scheduler::scheduler() : counter(0), 
     120                         keeper(NULL), 
     121                         thread(NULL), 
     122                         handle(NULL) 
     123{ 
     124    dodo_try { 
     125        keeper = new pc::sync::thread; 
     126        handle = new __manager__; 
     127        thread = new execution::thread(scheduler::manager, this, execution::ON_DESTRUCTION_STOP, false); 
     128 
     129        thread->run(); 
     130    } dodo_catch (exception::basic *e UNUSED) { 
     131        delete thread; 
     132        delete handle; 
     133        delete keeper; 
     134 
     135        dodo_rethrow; 
     136    } 
     137} 
     138//------------------------------------------------------------------- 
     139 
     140scheduler::~scheduler() 
     141{ 
     142#ifdef PTHREAD_EXT 
     143    pthread_mutex_lock(&handle->mutex); 
     144 
     145    handle->exit = true; 
     146 
     147    pthread_cond_signal(&handle->condition); 
     148    pthread_mutex_unlock(&handle->mutex); 
     149#endif 
     150 
     151    thread->wait(); 
     152 
     153    delete thread; 
     154    delete handle; 
     155    delete keeper; 
     156} 
     157 
     158//------------------------------------------------------------------- 
     159 
     160int 
     161scheduler::manager(void *data) 
    135162{ 
    136163    scheduler *parent = (scheduler *)data; 
    … …  
    140167    while (true) { 
    141168        if (idle != 0) { 
    142             pthread_mutex_lock(&parent->manager->mutex); 
     169            pthread_mutex_lock(&parent->handle->mutex); 
    143170            if (idle == ~0UL) { 
    144                 pthread_cond_wait(&parent->manager->condition, &parent->manager->mutex); 
     171                pthread_cond_wait(&parent->handle->condition, &parent->handle->mutex); 
    145172            } else { 
    146173                timespec ts; 
    … …  
    150177                ts.tv_nsec += (idle % 1000) * 1000000; 
    151178 
    152                 pthread_cond_timedwait(&parent->manager->condition, &parent->manager->mutex, &ts); 
     179                pthread_cond_timedwait(&parent->handle->condition, &parent->handle->mutex, &ts); 
    153180            } 
    154181 
    155             if (parent->manager->exit) { 
    156                 pthread_mutex_unlock(&parent->manager->mutex); 
    157  
    158                 return NULL; 
     182            if (parent->handle->exit) { 
     183                pthread_mutex_unlock(&parent->handle->mutex); 
     184 
     185                return 0; 
    159186            } 
    160             pthread_mutex_unlock(&parent->manager->mutex); 
     187            pthread_mutex_unlock(&parent->handle->mutex); 
    161188 
    162189            idle = 0; 
    … …  
    168195            dodoMap<unsigned long, scheduler::__job__>::iterator i = parent->handles.begin(), j = parent->handles.end(); 
    169196            while (i!=j) { 
    170                 pthread_mutex_lock(&parent->manager->mutex); 
    171                 if (parent->manager->exit) { 
    172                     pthread_mutex_unlock(&parent->manager->mutex); 
    173  
    174                     return NULL; 
     197                pthread_mutex_lock(&parent->handle->mutex); 
     198                if (parent->handle->exit) { 
     199                    pthread_mutex_unlock(&parent->handle->mutex); 
     200 
     201                    return 0; 
    175202                } 
    176                 pthread_mutex_unlock(&parent->manager->mutex); 
     203                pthread_mutex_unlock(&parent->handle->mutex); 
    177204 
    178205                scheduler::__job__ &j = i->second; 
    … …  
    205232    } 
    206233 
    207     return NULL; 
    208 } 
    209 #endif 
    210  
    211 //------------------------------------------------------------------- 
    212  
    213 scheduler::scheduler() : counter(0), 
    214       keeper(NULL), 
    215       manager(NULL) 
    216 { 
    217     dodo_try { 
    218         keeper = new pc::sync::thread; 
    219         manager = new __manager__; 
    220     } dodo_catch (exception::basic *e UNUSED) { 
    221         delete manager; 
    222         delete keeper; 
    223  
    224         dodo_rethrow; 
    225     } 
    226  
    227 #ifdef PTHREAD_EXT 
    228     errno = pthread_create(&manager->thread, NULL, __manager__::manager, this); 
    229     if (errno != 0) 
    230         dodo_throw exception::basic(exception::MODULE_PCEXECUTIONSCHEDULER, SCHEDULEREX_CONSTRUCTOR, exception::ERRNO_ERRNO, errno, strerror(errno), __LINE__, __FILE__); 
    231 #endif 
    232 } 
    233 //------------------------------------------------------------------- 
    234  
    235 scheduler::~scheduler() 
    236 { 
    237 #ifdef PTHREAD_EXT 
    238     pthread_mutex_lock(&manager->mutex); 
    239  
    240     manager->exit = true; 
    241  
    242     pthread_cond_signal(&manager->condition); 
    243     pthread_mutex_unlock(&manager->mutex); 
    244  
    245     pthread_join(manager->thread, NULL); 
    246 #endif 
    247  
    248     delete manager; 
    249     delete keeper; 
     234    return 0; 
    250235} 
    251236 
    … …  
    265250    switch (job.type) { 
    266251        case execution::job::TYPE_PROCESS: 
    267             _job = new process(*dynamic_cast<process *>(orig)); 
     252            _job = new process(*dynamic_cast<execution::process *>(orig)); 
    268253 
    269254            break; 
    270255 
    271256        case execution::job::TYPE_THREAD: 
    272             _job = new thread(*dynamic_cast<thread *>(orig)); 
     257            _job = new execution::thread(*dynamic_cast<execution::thread *>(orig)); 
    273258 
    274259            break; 
    … …  
    282267    handles.insert(std::make_pair(counter, j)); 
    283268 
    284     pthread_mutex_lock(&manager->mutex); 
    285     pthread_cond_signal(&manager->condition); 
    286     pthread_mutex_unlock(&manager->mutex); 
     269    pthread_mutex_lock(&handle->mutex); 
     270    pthread_cond_signal(&handle->condition); 
     271    pthread_mutex_unlock(&handle->mutex); 
    287272 
    288273    return counter++; 
Note: See TracChangeset for help on using the changeset viewer.