Diff for /libaitsched/src/tasks.c between versions 1.2.2.1 and 1.5

version 1.2.2.1, 2011/10/04 20:12:01 version 1.5, 2012/01/24 21:59:47
Line 46  SUCH DAMAGE. Line 46  SUCH DAMAGE.
 #include "global.h"  #include "global.h"
   
   
   #pragma GCC visibility push(hidden)
   
   inline sched_task_t *
   _sched_useTask(sched_root_task_t * __restrict root)
   {
           sched_task_t *task;
   
           TAILQ_FOREACH(task, &root->root_unuse, task_node) {
                   if (!TASK_ISLOCKED(task)) {
   #ifdef HAVE_LIBPTHREAD
                           pthread_mutex_lock(&root->root_mtx[taskUNUSE]);
   #endif
                           TAILQ_REMOVE(&root->root_unuse, task, task_node);
   #ifdef HAVE_LIBPTHREAD
                           pthread_mutex_unlock(&root->root_mtx[taskUNUSE]);
   #endif
                           break;
                   }
           }
   
           if (!task) {
                   task = malloc(sizeof(sched_task_t));
                   if (!task) {
                           LOGERR;
                           return NULL;
                   }
           }
   
           return task;
   }
   
   inline sched_task_t *
   _sched_unuseTask(sched_task_t * __restrict task)
   {
           TASK_UNLOCK(task);
           TASK_TYPE(task) = taskUNUSE;
   #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;
   
           return task;
   }
   
   #pragma GCC visibility pop
   
   
 /*  /*
  * schedRead() - Add READ I/O task to scheduler queue   * schedRead() - Add READ I/O task to scheduler queue
  * @root = root task   * @root = root 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 64  schedRead(sched_root_task_t * __restrict root, sched_t Line 118  schedRead(sched_root_task_t * __restrict root, sched_t
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if ((task = TAILQ_FIRST(&root->root_unuse)))        if (!(task = _sched_useTask(root)))
                TAILQ_REMOVE(&root->root_unuse, task, task_node);                return NULL;
        else { 
                task = malloc(sizeof(sched_task_t)); 
                if (!task) { 
                        LOGERR; 
                        return NULL; 
                } 
        } 
   
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
        task->task_type = taskREAD;        task->task_lock = 0;
        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
                task->task_type = taskUNUSE;                pthread_mutex_unlock(&root->root_mtx[taskREAD]);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);#endif
                task = NULL;        } else
        }                task = _sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 105  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 117  schedWrite(sched_root_task_t * __restrict root, sched_ Line 174  schedWrite(sched_root_task_t * __restrict root, sched_
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if ((task = TAILQ_FIRST(&root->root_unuse)))        if (!(task = _sched_useTask(root)))
                TAILQ_REMOVE(&root->root_unuse, task, task_node);                return NULL;
        else { 
                task = malloc(sizeof(sched_task_t)); 
                if (!task) { 
                        LOGERR; 
                        return NULL; 
                } 
        } 
   
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
        task->task_type = taskWRITE;        task->task_lock = 0;
        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
                task->task_type = taskUNUSE;                pthread_mutex_unlock(&root->root_mtx[taskWRITE]);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);#endif
                task = NULL;        } else
        }                task = _sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 157  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;
   
         /* get new task */          /* get new task */
        if ((task = TAILQ_FIRST(&root->root_unuse)))        if (!(task = _sched_useTask(root)))
                TAILQ_REMOVE(&root->root_unuse, task, task_node);                return NULL;
        else { 
                task = malloc(sizeof(sched_task_t)); 
                if (!task) { 
                        LOGERR; 
                        return NULL; 
                } 
        } 
   
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
        task->task_type = taskTIMER;        task->task_lock = 0;
        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 209  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
        } else {#ifdef HAVE_LIBPTHREAD
                task->task_type = taskUNUSE;                pthread_mutex_unlock(&root->root_mtx[taskTIMER]);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);#endif
                task = NULL;        } else
        }                task = _sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 235  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 247  schedEvent(sched_root_task_t * __restrict root, sched_ Line 309  schedEvent(sched_root_task_t * __restrict root, sched_
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if ((task = TAILQ_FIRST(&root->root_unuse)))        if (!(task = _sched_useTask(root)))
                TAILQ_REMOVE(&root->root_unuse, task, task_node);                return NULL;
        else { 
                task = malloc(sizeof(sched_task_t)); 
                if (!task) { 
                        LOGERR; 
                        return NULL; 
                } 
        } 
   
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
        task->task_type = taskEVENT;        task->task_lock = 0;
        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
                task->task_type = taskUNUSE;                pthread_mutex_unlock(&root->root_mtx[taskEVENT]);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);#endif
                task = NULL;        } else
        }                task = _sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 289  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 301  schedEventLo(sched_root_task_t * __restrict root, sche Line 366  schedEventLo(sched_root_task_t * __restrict root, sche
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if ((task = TAILQ_FIRST(&root->root_unuse)))        if (!(task = _sched_useTask(root)))
                TAILQ_REMOVE(&root->root_unuse, task, task_node);                return NULL;
        else { 
                task = malloc(sizeof(sched_task_t)); 
                if (!task) { 
                        LOGERR; 
                        return NULL; 
                } 
        } 
   
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
        task->task_type = taskEVENT;        task->task_lock = 0;
        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
                task->task_type = taskUNUSE;                pthread_mutex_unlock(&root->root_mtx[taskEVENTLO]);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node);#endif
                task = NULL;        } else
        }                task = _sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 342  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 422  schedCallOnce(sched_root_task_t * __restrict root, sch
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if ((task = TAILQ_FIRST(&root->root_unuse)))        if (!(task = _sched_useTask(root)))
                TAILQ_REMOVE(&root->root_unuse, task, task_node);                return NULL;
        else { 
                task = malloc(sizeof(sched_task_t)); 
                if (!task) { 
                        LOGERR; 
                        return NULL; 
                } 
        } 
   
         memset(task, 0, sizeof(sched_task_t));          memset(task, 0, sizeof(sched_task_t));
         task->task_id = 0;          task->task_id = 0;
        task->task_type = taskEVENT;        task->task_lock = 0;
        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);
   
        task->task_type = taskUNUSE;        _sched_unuseTask(task);
        TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node); 
         return ret;          return ret;
 }  }

Removed from v.1.2.2.1  
changed lines
  Added in v.1.5


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