Changes in kernel/generic/src/synch/workqueue.c [63e27ef:04552324] in mainline

File:

• kernel/generic/src/synch/workqueue.c (modified) (28 diffs)

kernel/generic/src/synch/workqueue.c

@@ -37 +37 @@
  */
 
-#include <assert.h>
 #include <synch/workqueue.h>
 #include <synch/spinlock.h>
@@ -190 +189 @@
         if (workq) {
                 if (workq_init(workq, name)) {
-                        assert(!workq_corrupted(workq));
+                        ASSERT(!workq_corrupted(workq));
                         return workq;
                 }
@@ -203 +202 @@
 void workq_destroy(struct work_queue *workq)
 {
-        assert(!workq_corrupted(workq));
+        ASSERT(!workq_corrupted(workq));
         
         irq_spinlock_lock(&workq->lock, true);
@@ -215 +214 @@
                 workq_stop(workq);
         } else {
-                assert(0 == running_workers);
+                ASSERT(0 == running_workers);
         }
         
@@ -265 +264 @@
 static bool add_worker(struct work_queue *workq)
 {
-        assert(!workq_corrupted(workq));
+        ASSERT(!workq_corrupted(workq));
 
         thread_t *thread = thread_create(worker_thread, workq, TASK, 
@@ -274 +273 @@
                 
                 /* cur_worker_cnt proactively increased in signal_worker_logic() .*/
-                assert(0 < workq->cur_worker_cnt);
+                ASSERT(0 < workq->cur_worker_cnt);
                 --workq->cur_worker_cnt;
                 
@@ -313 +312 @@
                 
                 /* cur_worker_cnt proactively increased in signal_worker() .*/
-                assert(0 < workq->cur_worker_cnt);
+                ASSERT(0 < workq->cur_worker_cnt);
                 --workq->cur_worker_cnt;
         }
@@ -335 +334 @@
 void workq_stop(struct work_queue *workq)
 {
-        assert(!workq_corrupted(workq));
+        ASSERT(!workq_corrupted(workq));
         
         interrupt_workers(workq);
@@ -347 +346 @@
 
         /* workq_stop() may only be called once. */
-        assert(!workq->stopping);
+        ASSERT(!workq->stopping);
         workq->stopping = true;
         
@@ -359 +358 @@
 static void wait_for_workers(struct work_queue *workq)
 {
-        assert(!PREEMPTION_DISABLED);
+        ASSERT(!PREEMPTION_DISABLED);
         
         irq_spinlock_lock(&workq->lock, true);
@@ -376 +375 @@
         }
         
-        assert(list_empty(&workq->workers));
+        ASSERT(list_empty(&workq->workers));
         
         /* Wait for deferred add_worker_op(), signal_worker_op() to finish. */
@@ -474 +473 @@
         work_func_t func, bool can_block)
 {
-        assert(!workq_corrupted(workq));
+        ASSERT(!workq_corrupted(workq));
         
         bool success = true;
@@ -522 +521 @@
 static size_t active_workers_now(struct work_queue *workq)
 {
-        assert(irq_spinlock_locked(&workq->lock));
+        ASSERT(irq_spinlock_locked(&workq->lock));
         
         /* Workers blocked are sleeping in the work function (ie not idle). */
-        assert(workq->blocked_worker_cnt <= workq->cur_worker_cnt);
+        ASSERT(workq->blocked_worker_cnt <= workq->cur_worker_cnt);
         /* Idle workers are waiting for more work to arrive in condvar_wait. */
-        assert(workq->idle_worker_cnt <= workq->cur_worker_cnt);
+        ASSERT(workq->idle_worker_cnt <= workq->cur_worker_cnt);
         
         /* Idle + blocked workers == sleeping worker threads. */
         size_t sleeping_workers = workq->blocked_worker_cnt + workq->idle_worker_cnt;
         
-        assert(sleeping_workers <= workq->cur_worker_cnt);
+        ASSERT(sleeping_workers <= workq->cur_worker_cnt);
         /* Workers pending activation are idle workers not yet given a time slice. */
-        assert(workq->activate_pending <= workq->idle_worker_cnt);
+        ASSERT(workq->activate_pending <= workq->idle_worker_cnt);
         
         /* 
@@ -551 +550 @@
 static size_t active_workers(struct work_queue *workq)
 {
-        assert(irq_spinlock_locked(&workq->lock));
+        ASSERT(irq_spinlock_locked(&workq->lock));
         
         /* 
@@ -574 +573 @@
 static void signal_worker_op(struct work_queue *workq)
 {
-        assert(!workq_corrupted(workq));
+        ASSERT(!workq_corrupted(workq));
 
         condvar_signal(&workq->activate_worker);
         
         irq_spinlock_lock(&workq->lock, true);
-        assert(0 < workq->pending_op_cnt);
+        ASSERT(0 < workq->pending_op_cnt);
         --workq->pending_op_cnt;
         irq_spinlock_unlock(&workq->lock, true);
@@ -594 +593 @@
 static signal_op_t signal_worker_logic(struct work_queue *workq, bool can_block)
 {
-        assert(!workq_corrupted(workq));
-        assert(irq_spinlock_locked(&workq->lock));
+        ASSERT(!workq_corrupted(workq));
+        ASSERT(irq_spinlock_locked(&workq->lock));
         
         /* Only signal workers if really necessary. */
@@ -646 +645 @@
                          */
                         if (need_worker && !can_block && 0 == active) {
-                                assert(0 == workq->idle_worker_cnt);
+                                ASSERT(0 == workq->idle_worker_cnt);
                                 
                                 irq_spinlock_lock(&nonblock_adder.lock, true);
@@ -682 +681 @@
         }
         
-        assert(arg != NULL);
+        ASSERT(arg != NULL);
         
         struct work_queue *workq = arg;
@@ -698 +697 @@
 static bool dequeue_work(struct work_queue *workq, work_t **pwork_item)
 {
-        assert(!workq_corrupted(workq));
+        ASSERT(!workq_corrupted(workq));
         
         irq_spinlock_lock(&workq->lock, true);
@@ -705 +704 @@
         if (!workq->stopping && worker_unnecessary(workq)) {
                 /* There are too many workers for this load. Exit. */
-                assert(0 < workq->cur_worker_cnt);
+                ASSERT(0 < workq->cur_worker_cnt);
                 --workq->cur_worker_cnt;
                 list_remove(&THREAD->workq_link);
@@ -730 +729 @@
                 
 #ifdef CONFIG_DEBUG
-                assert(!work_item_corrupted(*pwork_item));
+                ASSERT(!work_item_corrupted(*pwork_item));
                 (*pwork_item)->cookie = 0;
 #endif
@@ -739 +738 @@
         } else {
                 /* Requested to stop and no more work queued. */
-                assert(workq->stopping);
+                ASSERT(workq->stopping);
                 --workq->cur_worker_cnt;
                 stop = true;
@@ -752 +751 @@
 static bool worker_unnecessary(struct work_queue *workq)
 {
-        assert(irq_spinlock_locked(&workq->lock));
+        ASSERT(irq_spinlock_locked(&workq->lock));
         
         /* No work is pending. We don't need too many idle threads. */
@@ -776 +775 @@
         
         /* Ignore lock ordering just here. */
-        assert(irq_spinlock_locked(&workq->lock));
+        ASSERT(irq_spinlock_locked(&workq->lock));
         
         _condvar_wait_timeout_irq_spinlock(&workq->activate_worker,
                 &workq->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
 
-        assert(!workq_corrupted(workq));
-        assert(irq_spinlock_locked(&workq->lock));
+        ASSERT(!workq_corrupted(workq));
+        ASSERT(irq_spinlock_locked(&workq->lock));
         
         THREAD->workq_idling = false;
@@ -792 +791 @@
 void workq_before_thread_is_ready(thread_t *thread)
 {
-        assert(thread);
-        assert(irq_spinlock_locked(&thread->lock));
+        ASSERT(thread);
+        ASSERT(irq_spinlock_locked(&thread->lock));
 
         /* Worker's work func() is about to wake up from sleeping. */
         if (thread->workq && thread->workq_blocked) {
                 /* Must be blocked in user work func() and not be waiting for work. */
-                assert(!thread->workq_idling);
-                assert(thread->state == Sleeping);
-                assert(THREAD != thread);
-                assert(!workq_corrupted(thread->workq));
+                ASSERT(!thread->workq_idling);
+                ASSERT(thread->state == Sleeping);
+                ASSERT(THREAD != thread);
+                ASSERT(!workq_corrupted(thread->workq));
                 
                 /* Protected by thread->lock */
@@ -815 +814 @@
 void workq_after_thread_ran(void)
 {
-        assert(THREAD);
-        assert(irq_spinlock_locked(&THREAD->lock));
+        ASSERT(THREAD);
+        ASSERT(irq_spinlock_locked(&THREAD->lock));
 
         /* Worker's work func() is about to sleep/block. */
         if (THREAD->workq && THREAD->state == Sleeping && !THREAD->workq_idling) {
-                assert(!THREAD->workq_blocked);
-                assert(!workq_corrupted(THREAD->workq));
+                ASSERT(!THREAD->workq_blocked);
+                ASSERT(!workq_corrupted(THREAD->workq));
                 
                 THREAD->workq_blocked = true;
@@ -835 +834 @@
                 
                 if (op) {
-                        assert(add_worker_noblock_op == op || signal_worker_op == op);
+                        ASSERT(add_worker_noblock_op == op || signal_worker_op == op);
                         op(THREAD->workq);
                 }
@@ -904 +903 @@
                         struct work_queue, nb_link);
 
-                assert(!workq_corrupted(*pworkq));
+                ASSERT(!workq_corrupted(*pworkq));
                 
                 list_remove(&(*pworkq)->nb_link);