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

version 1.2, 2011/10/04 12:34:33 version 1.4, 2012/01/08 00:51:17
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)) {
                           TAILQ_REMOVE(&root->root_unuse, task, task_node);
                           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->task_type = taskUNUSE;
           TAILQ_INSERT_TAIL(&task->task_root->root_unuse, task, task_node);
           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
Line 64  schedRead(sched_root_task_t * __restrict root, sched_t Line 103  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_lock = 0;
         task->task_type = taskREAD;          task->task_type = taskREAD;
         task->task_root = root;          task->task_root = root;
         task->task_func = func;          task->task_func = func;
Line 90  schedRead(sched_root_task_t * __restrict root, sched_t Line 123  schedRead(sched_root_task_t * __restrict root, sched_t
   
         if (!ptr)          if (!ptr)
                 TAILQ_INSERT_TAIL(&root->root_read, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_read, task, task_node);
        else {        else
                task->task_type = taskUNUSE;                task = _sched_unuseTask(task);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node); 
                task = NULL; 
        } 
   
         return task;          return task;
 }  }
Line 117  schedWrite(sched_root_task_t * __restrict root, sched_ Line 147  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_lock = 0;
         task->task_type = taskWRITE;          task->task_type = taskWRITE;
         task->task_root = root;          task->task_root = root;
         task->task_func = func;          task->task_func = func;
Line 143  schedWrite(sched_root_task_t * __restrict root, sched_ Line 167  schedWrite(sched_root_task_t * __restrict root, sched_
   
         if (!ptr)          if (!ptr)
                 TAILQ_INSERT_TAIL(&root->root_write, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_write, task, task_node);
        else {        else
                task->task_type = taskUNUSE;                task = _sched_unuseTask(task);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node); 
                task = NULL; 
        } 
   
         return task;          return task;
 }  }
Line 157  schedWrite(sched_root_task_t * __restrict root, sched_ Line 178  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
 * @ms = arguments in microSecs, define period 1sec == 1000000 * @tv = timeout argument structure
  * 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, u_int ms)schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timeval tv)
 {  {
         sched_task_t *task, *t = NULL;          sched_task_t *task, *t = NULL;
         void *ptr;          void *ptr;
Line 172  schedTimer(sched_root_task_t * __restrict root, sched_ Line 193  schedTimer(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_lock = 0;
         task->task_type = taskTIMER;          task->task_type = taskTIMER;
         task->task_root = root;          task->task_root = root;
         task->task_func = func;          task->task_func = func;
Line 192  schedTimer(sched_root_task_t * __restrict root, sched_ Line 207  schedTimer(sched_root_task_t * __restrict root, sched_
   
         /* calculate timeval structure */          /* calculate timeval structure */
         clock_gettime(CLOCK_MONOTONIC, &nw);          clock_gettime(CLOCK_MONOTONIC, &nw);
        now.tv_sec = nw.tv_sec + ms / 1000000;        now.tv_sec = nw.tv_sec + tv.tv_sec;
        now.tv_usec = nw.tv_nsec / 1000 + (ms % 1000000);        now.tv_usec = nw.tv_nsec / 1000 + tv.tv_usec;
         if (now.tv_usec >= 1000000) {          if (now.tv_usec >= 1000000) {
                 now.tv_sec++;                  now.tv_sec++;
                 now.tv_usec -= 1000000;                  now.tv_usec -= 1000000;
Line 220  schedTimer(sched_root_task_t * __restrict root, sched_ Line 235  schedTimer(sched_root_task_t * __restrict root, sched_
                 else                  else
                         TAILQ_INSERT_BEFORE(t, task, task_node);                          TAILQ_INSERT_BEFORE(t, task, task_node);
 #endif  #endif
        } else {        } else
                task->task_type = taskUNUSE;                task = _sched_unuseTask(task);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node); 
                task = NULL; 
        } 
   
         return task;          return task;
 }  }
Line 247  schedEvent(sched_root_task_t * __restrict root, sched_ Line 259  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_lock = 0;
         task->task_type = taskEVENT;          task->task_type = taskEVENT;
         task->task_root = root;          task->task_root = root;
         task->task_func = func;          task->task_func = func;
Line 273  schedEvent(sched_root_task_t * __restrict root, sched_ Line 279  schedEvent(sched_root_task_t * __restrict root, sched_
   
         if (!ptr)          if (!ptr)
                 TAILQ_INSERT_TAIL(&root->root_event, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_event, task, task_node);
        else {        else
                task->task_type = taskUNUSE;                task = _sched_unuseTask(task);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node); 
                task = NULL; 
        } 
   
         return task;          return task;
 }  }
Line 301  schedEventLo(sched_root_task_t * __restrict root, sche Line 304  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_lock = 0;
         task->task_type = taskEVENT;          task->task_type = taskEVENT;
         task->task_root = root;          task->task_root = root;
         task->task_func = func;          task->task_func = func;
Line 327  schedEventLo(sched_root_task_t * __restrict root, sche Line 324  schedEventLo(sched_root_task_t * __restrict root, sche
   
         if (!ptr)          if (!ptr)
                 TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node);                  TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node);
        else {        else
                task->task_type = taskUNUSE;                task = _sched_unuseTask(task);
                TAILQ_INSERT_TAIL(&root->root_unuse, task, task_node); 
                task = NULL; 
        } 
   
         return task;          return task;
 }  }
Line 354  schedCallOnce(sched_root_task_t * __restrict root, sch Line 348  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_lock = 0;
         task->task_type = taskEVENT;          task->task_type = taskEVENT;
         task->task_root = root;          task->task_root = root;
         task->task_func = func;          task->task_func = func;
Line 375  schedCallOnce(sched_root_task_t * __restrict root, sch Line 363  schedCallOnce(sched_root_task_t * __restrict root, sch
   
         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  
changed lines
  Added in v.1.4


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