[BACK]Return to tasks.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitsched / src

Diff for /libaitsched/src/tasks.c between versions 1.4 and 1.4.2.4

version 1.4, 2012/01/08 00:51:17 version 1.4.2.4, 2012/01/24 15:29:09
Line 55  _sched_useTask(sched_root_task_t * __restrict root) Line 55  _sched_useTask(sched_root_task_t * __restrict root)
   
         TAILQ_FOREACH(task, &root->root_unuse, task_node) {          TAILQ_FOREACH(task, &root->root_unuse, task_node) {
                 if (!TASK_ISLOCKED(task)) {                  if (!TASK_ISLOCKED(task)) {
   #ifdef HAVE_LIBPTHREAD
                           pthread_mutex_lock(&root->root_mtx[taskUNUSE]);
   #endif
                         TAILQ_REMOVE(&root->root_unuse, task, task_node);                          TAILQ_REMOVE(&root->root_unuse, task, task_node);
   #ifdef HAVE_LIBPTHREAD
                           pthread_mutex_unlock(&root->root_mtx[taskUNUSE]);
   #endif
                         break;                          break;
                 }                  }
         }          }
Line 75  inline sched_task_t * Line 81  inline sched_task_t *
 _sched_unuseTask(sched_task_t * __restrict task)  _sched_unuseTask(sched_task_t * __restrict task)
 {  {
         TASK_UNLOCK(task);          TASK_UNLOCK(task);
        task->task_type = taskUNUSE;        TASK_TYPE(task) = taskUNUSE;
        TAILQ_INSERT_TAIL(&task->task_root->root_unuse, task, task_node);#ifdef HAVE_LIBPTHREAD
         pthread_mutex_lock(&TASK_ROOT(task)->root_mtx[taskUNUSE]);
 #endif
         TAILQ_INSERT_TAIL(&TASK_ROOT(task)->root_unuse, task, task_node);
 #ifdef HAVE_LIBPTHREAD
         pthread_mutex_unlock(&TASK_ROOT(task)->root_mtx[taskUNUSE]);
 #endif
         task = NULL;          task = NULL;
   
         return task;          return task;
Line 91  _sched_unuseTask(sched_task_t * __restrict task) Line 103  _sched_unuseTask(sched_task_t * __restrict task)
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
  * @fd = fd handle   * @fd = fd handle
    * @opt_data = Optional data
    * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 sched_task_t *  sched_task_t *
schedRead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd)schedRead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, 
                 void *opt_data, size_t opt_dlen)
 {  {
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
Line 109  schedRead(sched_root_task_t * __restrict root, sched_t Line 124  schedRead(sched_root_task_t * __restrict root, sched_t
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
         task->task_lock = 0;          task->task_lock = 0;
         task->task_type = taskREAD;  
         task->task_root = root;  
         task->task_func = func;          task->task_func = func;
           TASK_TYPE(task) = taskREAD;
           TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
         TASK_FD(task) = fd;          TASK_FD(task) = fd;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
         if (root->root_hooks.hook_add.read)          if (root->root_hooks.hook_add.read)
                 ptr = root->root_hooks.hook_add.read(task, NULL);                  ptr = root->root_hooks.hook_add.read(task, NULL);
         else          else
                 ptr = NULL;                  ptr = NULL;
   
        if (!ptr)        if (!ptr) {
 #ifdef HAVE_LIBPTHREAD
                 pthread_mutex_lock(&root->root_mtx[taskREAD]);
 #endif
                 TAILQ_INSERT_TAIL(&root->root_read, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_read, task, task_node);
        else#ifdef HAVE_LIBPTHREAD
                 pthread_mutex_unlock(&root->root_mtx[taskREAD]);
 #endif
         } else
                 task = _sched_unuseTask(task);                  task = _sched_unuseTask(task);
   
         return task;          return task;
Line 135  schedRead(sched_root_task_t * __restrict root, sched_t Line 159  schedRead(sched_root_task_t * __restrict root, sched_t
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
  * @fd = fd handle   * @fd = fd handle
    * @opt_data = Optional data
    * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 sched_task_t *  sched_task_t *
schedWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd)schedWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, 
                 void *opt_data, size_t opt_dlen)
 {  {
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
Line 153  schedWrite(sched_root_task_t * __restrict root, sched_ Line 180  schedWrite(sched_root_task_t * __restrict root, sched_
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
         task->task_lock = 0;          task->task_lock = 0;
         task->task_type = taskWRITE;  
         task->task_root = root;  
         task->task_func = func;          task->task_func = func;
           TASK_TYPE(task) = taskWRITE;
           TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
         TASK_FD(task) = fd;          TASK_FD(task) = fd;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
         if (root->root_hooks.hook_add.write)          if (root->root_hooks.hook_add.write)
                 ptr = root->root_hooks.hook_add.write(task, NULL);                  ptr = root->root_hooks.hook_add.write(task, NULL);
         else          else
                 ptr = NULL;                  ptr = NULL;
   
        if (!ptr)        if (!ptr) {
 #ifdef HAVE_LIBPTHREAD
                 pthread_mutex_lock(&root->root_mtx[taskWRITE]);
 #endif
                 TAILQ_INSERT_TAIL(&root->root_write, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_write, task, task_node);
        else#ifdef HAVE_LIBPTHREAD
                 pthread_mutex_unlock(&root->root_mtx[taskWRITE]);
 #endif
         } else
                 task = _sched_unuseTask(task);                  task = _sched_unuseTask(task);
   
         return task;          return task;
Line 178  schedWrite(sched_root_task_t * __restrict root, sched_ Line 214  schedWrite(sched_root_task_t * __restrict root, sched_
  * @root = root task   * @root = root task
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
 * @tv = timeout argument structure * @ts = timeout argument structure
  * @opt_data = Optional data
  * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 sched_task_t *  sched_task_t *
schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timeval tv)schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts, 
                 void *opt_data, size_t opt_dlen)
 {  {
         sched_task_t *task, *t = NULL;          sched_task_t *task, *t = NULL;
         void *ptr;          void *ptr;
        struct timeval now;        struct timespec now;
        struct timespec nw; 
   
         if (!root || !func)          if (!root || !func)
                 return NULL;                  return NULL;
Line 199  schedTimer(sched_root_task_t * __restrict root, sched_ Line 237  schedTimer(sched_root_task_t * __restrict root, sched_
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
         task->task_lock = 0;          task->task_lock = 0;
         task->task_type = taskTIMER;  
         task->task_root = root;  
         task->task_func = func;          task->task_func = func;
           TASK_TYPE(task) = taskTIMER;
           TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
         /* calculate timeval structure */          /* calculate timeval structure */
        clock_gettime(CLOCK_MONOTONIC, &nw);        clock_gettime(CLOCK_MONOTONIC, &now);
        now.tv_sec = nw.tv_sec + tv.tv_sec;        now.tv_sec += ts.tv_sec;
        now.tv_usec = nw.tv_nsec / 1000 + tv.tv_usec;        now.tv_nsec += ts.tv_nsec;
        if (now.tv_usec >= 1000000) {        if (now.tv_nsec >= 1000000000L) {
                 now.tv_sec++;                  now.tv_sec++;
                now.tv_usec -= 1000000;                now.tv_nsec -= 1000000000L;
        } else if (now.tv_usec < 0) {        } else if (now.tv_nsec < 0) {
                 now.tv_sec--;                  now.tv_sec--;
                now.tv_usec += 1000000;                now.tv_nsec += 1000000000L;
         }          }
        TASK_TV(task) = now;        TASK_TS(task) = now;
   
         if (root->root_hooks.hook_add.timer)          if (root->root_hooks.hook_add.timer)
                 ptr = root->root_hooks.hook_add.timer(task, NULL);                  ptr = root->root_hooks.hook_add.timer(task, NULL);
Line 224  schedTimer(sched_root_task_t * __restrict root, sched_ Line 265  schedTimer(sched_root_task_t * __restrict root, sched_
                 ptr = NULL;                  ptr = NULL;
   
         if (!ptr) {          if (!ptr) {
   #ifdef HAVE_LIBPTHREAD
                   pthread_mutex_lock(&root->root_mtx[taskTIMER]);
   #endif
 #ifdef TIMER_WITHOUT_SORT  #ifdef TIMER_WITHOUT_SORT
                 TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
 #else  #else
                 TAILQ_FOREACH(t, &root->root_timer, task_node)                  TAILQ_FOREACH(t, &root->root_timer, task_node)
                        if (timercmp(&TASK_TV(task), &TASK_TV(t), -) < 1)                        if (sched_timespeccmp(&TASK_TS(task), &TASK_TS(t), -) < 1)
                                 break;                                  break;
                 if (!t)                  if (!t)
                         TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);                          TAILQ_INSERT_TAIL(&root->root_timer, task, task_node);
                 else                  else
                         TAILQ_INSERT_BEFORE(t, task, task_node);                          TAILQ_INSERT_BEFORE(t, task, task_node);
 #endif  #endif
   #ifdef HAVE_LIBPTHREAD
                   pthread_mutex_unlock(&root->root_mtx[taskTIMER]);
   #endif
         } else          } else
                 task = _sched_unuseTask(task);                  task = _sched_unuseTask(task);
   
Line 247  schedTimer(sched_root_task_t * __restrict root, sched_ Line 294  schedTimer(sched_root_task_t * __restrict root, sched_
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
  * @val = additional func argument   * @val = additional func argument
    * @opt_data = Optional data
    * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 sched_task_t *  sched_task_t *
schedEvent(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val)schedEvent(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val, 
                 void *opt_data, size_t opt_dlen)
 {  {
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
Line 265  schedEvent(sched_root_task_t * __restrict root, sched_ Line 315  schedEvent(sched_root_task_t * __restrict root, sched_
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
         task->task_lock = 0;          task->task_lock = 0;
         task->task_type = taskEVENT;  
         task->task_root = root;  
         task->task_func = func;          task->task_func = func;
           TASK_TYPE(task) = taskEVENT;
           TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
         TASK_VAL(task) = val;          TASK_VAL(task) = val;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
         if (root->root_hooks.hook_add.event)          if (root->root_hooks.hook_add.event)
                 ptr = root->root_hooks.hook_add.event(task, NULL);                  ptr = root->root_hooks.hook_add.event(task, NULL);
         else          else
                 ptr = NULL;                  ptr = NULL;
   
        if (!ptr)        if (!ptr) {
 #ifdef HAVE_LIBPTHREAD
                 pthread_mutex_lock(&root->root_mtx[taskEVENT]);
 #endif
                 TAILQ_INSERT_TAIL(&root->root_event, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_event, task, task_node);
        else#ifdef HAVE_LIBPTHREAD
                 pthread_mutex_unlock(&root->root_mtx[taskEVENT]);
 #endif
         } else
                 task = _sched_unuseTask(task);                  task = _sched_unuseTask(task);
   
         return task;          return task;
Line 292  schedEvent(sched_root_task_t * __restrict root, sched_ Line 351  schedEvent(sched_root_task_t * __restrict root, sched_
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
  * @val = additional func argument   * @val = additional func argument
    * @opt_data = Optional data
    * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 sched_task_t *  sched_task_t *
schedEventLo(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val)schedEventLo(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val, 
                 void *opt_data, size_t opt_dlen)
 {  {
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
Line 310  schedEventLo(sched_root_task_t * __restrict root, sche Line 372  schedEventLo(sched_root_task_t * __restrict root, sche
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
         task->task_lock = 0;          task->task_lock = 0;
         task->task_type = taskEVENT;  
         task->task_root = root;  
         task->task_func = func;          task->task_func = func;
           TASK_TYPE(task) = taskEVENT;
           TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
         TASK_VAL(task) = val;          TASK_VAL(task) = val;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
         if (root->root_hooks.hook_add.eventlo)          if (root->root_hooks.hook_add.eventlo)
                 ptr = root->root_hooks.hook_add.eventlo(task, NULL);                  ptr = root->root_hooks.hook_add.eventlo(task, NULL);
         else          else
                 ptr = NULL;                  ptr = NULL;
   
        if (!ptr)        if (!ptr) {
 #ifdef HAVE_LIBPTHREAD
                 pthread_mutex_lock(&root->root_mtx[taskEVENTLO]);
 #endif
                 TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node);
        else#ifdef HAVE_LIBPTHREAD
                 pthread_mutex_unlock(&root->root_mtx[taskEVENTLO]);
 #endif
         } else
                 task = _sched_unuseTask(task);                  task = _sched_unuseTask(task);
   
         return task;          return task;
Line 336  schedEventLo(sched_root_task_t * __restrict root, sche Line 407  schedEventLo(sched_root_task_t * __restrict root, sche
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
  * @val = additional func argument   * @val = additional func argument
    * @opt_data = Optional data
    * @opt_dlen = Optional data length
  * return: return value from called func   * return: return value from called func
  */   */
 sched_task_t *  sched_task_t *
schedCallOnce(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val)schedCallOnce(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val, 
                 void *opt_data, size_t opt_dlen)
 {  {
         sched_task_t *task;          sched_task_t *task;
         void *ret;          void *ret;
Line 354  schedCallOnce(sched_root_task_t * __restrict root, sch Line 428  schedCallOnce(sched_root_task_t * __restrict root, sch
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
         task->task_lock = 0;          task->task_lock = 0;
         task->task_type = taskEVENT;  
         task->task_root = root;  
         task->task_func = func;          task->task_func = func;
           TASK_TYPE(task) = taskEVENT;
           TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
         TASK_VAL(task) = val;          TASK_VAL(task) = val;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
         ret = schedCall(task);          ret = schedCall(task);
   
Removed from v.1.4  
changed lines
  Added in v.1.4.2.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>