Add support for multiple work queues

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5081 42af7a65-404d-4744-a932-0658087f49c3

1 files changed, 128 insertions, 87 deletions

diff --git a/nuttx/sched/work_thread.c b/nuttx/sched/work_thread.c
index fe14ae5e5..abd86f771 100644
--- a/nuttx/sched/work_thread.c
+++ b/nuttx/sched/work_thread.c
@@ -1,7 +1,7 @@
 /****************************************************************************
  * sched/work_thread.c
  *
- *   Copyright (C) 2009-2011 Gregory Nutt. All rights reserved.
+ *   Copyright (C) 2009-2012 Gregory Nutt. All rights reserved.
  *   Author: Gregory Nutt <gnutt@nuttx.org>
  *
  * Redistribution and use in source and binary forms, with or without
@@ -67,15 +67,9 @@
  * Public Variables
  ****************************************************************************/
 
-/* The queue of pending work */
+/* The state of each work queue */
 
-struct dq_queue_s g_work;
-
-/* The task ID of the worker thread */
-
-#ifdef CONFIG_SCHED_WORKQUEUE
-pid_t g_worker;
-#endif
+struct wqueue_s g_work[NWORKERS];
 
 /****************************************************************************
  * Private Variables
@@ -86,130 +80,177 @@ pid_t g_worker;
  ****************************************************************************/
 
 /****************************************************************************
- * Public Functions
- ****************************************************************************/
-/****************************************************************************
- * Name: work_thread
+ * Name: work_process
  *
  * Description:
- *   This is the main worker thread that performs actions placed on the work
- *   list.  It also performs periodic garbage collection (that is performed
- *   by the idle thread if CONFIG_SCHED_WORKQUEUE is not defined).
+ *   This is the logic that performs actions placed on any work list.
  *
  * Input parameters:
- *   argc, argv (not used)
+ *   wqueue - Describes the work queue to be processed
  *
  * Returned Value:
- *   Does not return
+ *   None
  *
  ****************************************************************************/
 
-int work_thread(int argc, char *argv[])
+static void work_process(FAR struct wqueue_s *wqueue)
 {
   volatile FAR struct work_s *work;
   worker_t  worker;
+  irqstate_t flags;
   FAR void *arg;
   uint32_t elapsed;
   uint32_t remaining;
   uint32_t next;
-  int usec;
-  irqstate_t flags;
 
-  /* Loop forever */
+  /* Then process queued work.  We need to keep interrupts disabled while
+   * we process items in the work list.
+   */
 
-  usec = CONFIG_SCHED_WORKPERIOD;
+  next  = CONFIG_SCHED_WORKPERIOD / USEC_PER_TICK;
   flags = irqsave();
-  for (;;)
+  work  = (FAR struct work_s *)wqueue->q.head;
+  while (work)
     {
-      /* Wait awhile to check the work list.  We will wait here until either
-       * the time elapses or until we are awakened by a signal.
+      /* Is this work ready?  It is ready if there is no delay or if
+       * the delay has elapsed. qtime is the time that the work was added
+       * to the work queue.  It will always be greater than or equal to
+       * zero.  Therefore a delay of zero will always execute immediately.
        */
 
-      usleep(usec);
-      irqrestore(flags);
+      elapsed = clock_systimer() - work->qtime;
+      if (elapsed >= work->delay)
+        {
+          /* Remove the ready-to-execute work from the list */
 
-      /* First, perform garbage collection.  This cleans-up memory de-allocations
-       * that were queued because they could not be freed in that execution
-       * context (for example, if the memory was freed from an interrupt handler).
-       * NOTE: If the work thread is disabled, this clean-up is performed by
-       * the IDLE thread (at a very, very lower priority).
-       */
+          (void)dq_rem((struct dq_entry_s *)work, &wqueue->q);
 
-      sched_garbagecollection();
+          /* Extract the work description from the entry (in case the work
+           * instance by the re-used after it has been de-queued).
+           */
 
-      /* Then process queued work.  We need to keep interrupts disabled while
-       * we process items in the work list.
-       */
+          worker = work->worker;
+          arg    = work->arg;
+
+          /* Mark the work as no longer being queued */
+
+          work->worker = NULL;
+
+          /* Do the work.  Re-enable interrupts while the work is being
+           * performed... we don't have any idea how long that will take!
+           */
+
+          irqrestore(flags);
+          worker(arg);
 
-      next  = CONFIG_SCHED_WORKPERIOD / USEC_PER_TICK;
-      flags = irqsave();
-      work  = (FAR struct work_s *)g_work.head;
-      while (work)
+          /* Now, unfortunately, since we re-enabled interrupts we don't
+           * know the state of the work list and we will have to start
+           * back at the head of the list.
+           */
+
+          flags = irqsave();
+          work  = (FAR struct work_s *)wqueue->q.head;
+        }
+      else
         {
-          /* Is this work ready?  It is ready if there is no delay or if
-           * the delay has elapsed. qtime is the time that the work was added
-           * to the work queue.  It will always be greater than or equal to
-           * zero.  Therefore a delay of zero will always execute immediately.
+          /* This one is not ready.. will it be ready before the next
+           * scheduled wakeup interval?
            */
 
-          elapsed = clock_systimer() - work->qtime;
-          if (elapsed >= work->delay)
+          remaining = elapsed - work->delay;
+          if (remaining < next)
             {
-              /* Remove the ready-to-execute work from the list */
+              /* Yes.. Then schedule to wake up when the work is ready */
 
-              (void)dq_rem((struct dq_entry_s *)work, &g_work);
+              next = remaining;
+            }
+              
+          /* Then try the next in the list. */
 
-              /* Extract the work description from the entry (in case the work
-               * instance by the re-used after it has been de-queued).
-               */
+          work = (FAR struct work_s *)work->dq.flink;
+        }
+    }
 
-              worker = work->worker;
-              arg    = work->arg;
+  /* Wait awhile to check the work list.  We will wait here until either
+   * the time elapses or until we are awakened by a signal.
+   */
 
-              /* Mark the work as no longer being queued */
+  usleep(next * USEC_PER_TICK);
+  irqrestore(flags);
+}
 
-              work->worker = NULL;
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+/****************************************************************************
+ * Name: work_hpthread and work_lpthread
+ *
+ * Description:
+ *   These are the main worker threads that performs actions placed on the
+ *   work lists.  One thread also performs periodic garbage collection (that
+ *   is performed by the idle thread if CONFIG_SCHED_WORKQUEUE is not defined).
+ *
+ * Input parameters:
+ *   argc, argv (not used)
+ *
+ * Returned Value:
+ *   Does not return
+ *
+ ****************************************************************************/
 
-              /* Do the work.  Re-enable interrupts while the work is being
-               * performed... we don't have any idea how long that will take!
-               */
+int work_hpthread(int argc, char *argv[])
+{
+  /* Loop forever */
 
-              irqrestore(flags);
-              worker(arg);
+  for (;;)
+    {
+      /* First, perform garbage collection.  This cleans-up memory de-allocations
+       * that were queued because they could not be freed in that execution
+       * context (for example, if the memory was freed from an interrupt handler).
+       * NOTE: If the work thread is disabled, this clean-up is performed by
+       * the IDLE thread (at a very, very lower priority).
+       */
 
-              /* Now, unfortunately, since we re-enabled interrupts we don't
-               * know the state of the work list and we will have to start
-               * back at the head of the list.
-               */
+#ifdef CONFIG_SCHED_LPWORK
+      sched_garbagecollection();
+#endif
 
-              flags = irqsave();
-              work  = (FAR struct work_s *)g_work.head;
-            }
-          else
-            {
-              /* This one is not ready.. will it be ready before the next
-               * scheduled wakeup interval?
-               */
+      /* Then process queued work.  We need to keep interrupts disabled while
+       * we process items in the work list.
+       */
+
+      work_process(&g_work[HPWORK]);
+    }
 
-              remaining = elapsed - work->delay;
-              if (remaining < next)
-                {
-                  /* Yes.. Then schedule to wake up when the work is ready */
+  return OK; /* To keep some compilers happy */
+}
 
-                  next = remaining;
-                }
-              
-              /* Then try the next in the list. */
+#ifdef CONFIG_SCHED_LPWORK
+int work_lpthread(int argc, char *argv[])
+{
+  /* Loop forever */
 
-              work = (FAR struct work_s *)work->dq.flink;
-            }
-        }
+  for (;;)
+    {
+      /* First, perform garbage collection.  This cleans-up memory de-allocations
+       * that were queued because they could not be freed in that execution
+       * context (for example, if the memory was freed from an interrupt handler).
+       * NOTE: If the work thread is disabled, this clean-up is performed by
+       * the IDLE thread (at a very, very lower priority).
+       */
 
-      /* Now calculate the microsecond delay we should wait */
+      sched_garbagecollection();
 
-      usec = next * USEC_PER_TICK;
+      /* Then process queued work.  We need to keep interrupts disabled while
+       * we process items in the work list.
+       */
+
+      work_process(&g_work[LPWORK]);
     }
 
   return OK; /* To keep some compilers happy */
 }
+
+#endif /* CONFIG_SCHED_LPWORK */
+
 #endif /* CONFIG_SCHED_WORKQUEUE */