Changeset 63e27ef in mainline for kernel/generic/src/synch

Timestamp:

2017-06-19T21:47:42Z (8 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

deacc58d

Parents:

7354b5e

Message:

ASSERT → assert

Location:

kernel/generic/src/synch

Files:

• futex.c (modified) (4 diffs)
• mutex.c (modified) (2 diffs)
• rcu.c (modified) (36 diffs)
• waitq.c (modified) (5 diffs)
• workqueue.c (modified) (28 diffs)

kernel/generic/src/synch/futex.c

@@ -61 +61 @@
  */
 
+#include <assert.h>
 #include <synch/futex.h>
 #include <synch/mutex.h>
@@ -241 +242 @@
 static void futex_add_ref(futex_t *futex)
 {
-        ASSERT(spinlock_locked(&futex_ht_lock));
-        ASSERT(0 < futex->refcount);
+        assert(spinlock_locked(&futex_ht_lock));
+        assert(0 < futex->refcount);
         ++futex->refcount;
 }
@@ -249 +250 @@
 static void futex_release_ref(futex_t *futex)
 {
-        ASSERT(spinlock_locked(&futex_ht_lock));
-        ASSERT(0 < futex->refcount);
+        assert(spinlock_locked(&futex_ht_lock));
+        assert(0 < futex->refcount);
         
         --futex->refcount;
@@ -459 +460 @@
         futex_t *futex;
 
-        ASSERT(keys == 1);
+        assert(keys == 1);
 
         futex = hash_table_get_instance(item, futex_t, ht_link);

kernel/generic/src/synch/mutex.c

@@ -36 +36 @@
  */
 
+#include <assert.h>
 #include <synch/mutex.h>
 #include <synch/semaphore.h>
-#include <debug.h>
 #include <arch.h>
 #include <stacktrace.h>
@@ -88 +88 @@
                 rc = _semaphore_down_timeout(&mtx->sem, usec, flags);
         } else {
-                ASSERT((mtx->type == MUTEX_ACTIVE) || (!THREAD));
-                ASSERT(usec == SYNCH_NO_TIMEOUT);
-                ASSERT(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
+                assert((mtx->type == MUTEX_ACTIVE) || (!THREAD));
+                assert(usec == SYNCH_NO_TIMEOUT);
+                assert(!(flags & SYNCH_FLAGS_INTERRUPTIBLE));
                 
                 unsigned int cnt = 0;

kernel/generic/src/synch/rcu.c

@@ -123 +123 @@
  * 
  */
- 
+
+#include <assert.h>
 #include <synch/rcu.h>
 #include <synch/condvar.h>
@@ -404 +405 @@
         /* Stop and wait for reclaimers. */
         for (unsigned int cpu_id = 0; cpu_id < config.cpu_active; ++cpu_id) {
-                ASSERT(cpus[cpu_id].rcu.reclaimer_thr != NULL);
+                assert(cpus[cpu_id].rcu.reclaimer_thr != NULL);
         
                 if (cpus[cpu_id].rcu.reclaimer_thr) {
@@ -487 +488 @@
 static void read_unlock_impl(size_t *pnesting_cnt)
 {
-        ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+        assert(PREEMPTION_DISABLED || interrupts_disabled());
         
         if (0 == --(*pnesting_cnt)) {
@@ -509 +510 @@
 void _rcu_signal_read_unlock(void)
 {
-        ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+        assert(PREEMPTION_DISABLED || interrupts_disabled());
         
         /*
@@ -531 +532 @@
          */
         if (THREAD && local_atomic_exchange(&THREAD->rcu.was_preempted, false)) {
-                ASSERT(link_used(&THREAD->rcu.preempt_link));
+                assert(link_used(&THREAD->rcu.preempt_link));
 
                 rm_preempted_reader();
@@ -563 +564 @@
 {
         /* Calling from a reader section will deadlock. */
-        ASSERT(!rcu_read_locked());
+        assert(!rcu_read_locked());
         
         synch_item_t completion; 
@@ -576 +577 @@
 {
         synch_item_t *completion = member_to_inst(rcu_item, synch_item_t, rcu_item);
-        ASSERT(completion);
+        assert(completion);
         waitq_wakeup(&completion->wq, WAKEUP_FIRST);
 }
@@ -615 +616 @@
 static void add_barrier_cb(void *arg)
 {
-        ASSERT(interrupts_disabled() || PREEMPTION_DISABLED);
+        assert(interrupts_disabled() || PREEMPTION_DISABLED);
         atomic_inc(&rcu.barrier_wait_cnt);
         rcu_call(&CPU->rcu.barrier_item, barrier_complete);
@@ -657 +658 @@
         rcu_func_t func)
 {
-        ASSERT(rcu_item);
+        assert(rcu_item);
         
         rcu_item->func = func;
@@ -689 +690 @@
 static bool cur_cbs_empty(void)
 {
-        ASSERT(THREAD && THREAD->wired);
+        assert(THREAD && THREAD->wired);
         return NULL == CPU->rcu.cur_cbs;
 }
@@ -695 +696 @@
 static bool next_cbs_empty(void)
 {
-        ASSERT(THREAD && THREAD->wired);
+        assert(THREAD && THREAD->wired);
         return NULL == CPU->rcu.next_cbs;
 }
@@ -702 +703 @@
 static bool arriving_cbs_empty(void)
 {
-        ASSERT(THREAD && THREAD->wired);
+        assert(THREAD && THREAD->wired);
         /* 
          * Accessing with interrupts enabled may at worst lead to 
@@ -719 +720 @@
 static void reclaimer(void *arg)
 {
-        ASSERT(THREAD && THREAD->wired);
-        ASSERT(THREAD == CPU->rcu.reclaimer_thr);
+        assert(THREAD && THREAD->wired);
+        assert(THREAD == CPU->rcu.reclaimer_thr);
 
         rcu_gp_t last_compl_gp = 0;
@@ -726 +727 @@
         
         while (ok && wait_for_pending_cbs()) {
-                ASSERT(CPU->rcu.reclaimer_thr == THREAD);
+                assert(CPU->rcu.reclaimer_thr == THREAD);
                 
                 exec_completed_cbs(last_compl_gp);
@@ -765 +766 @@
         /* Both next_cbs and cur_cbs GP elapsed. */
         if (CPU->rcu.next_cbs_gp <= last_completed_gp) {
-                ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+                assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
                 
                 size_t exec_cnt = CPU->rcu.cur_cbs_cnt + CPU->rcu.next_cbs_cnt;
@@ -864 +865 @@
          */
         if (CPU->rcu.next_cbs) {
-                ASSERT(CPU->rcu.parriving_cbs_tail != &CPU->rcu.arriving_cbs);
+                assert(CPU->rcu.parriving_cbs_tail != &CPU->rcu.arriving_cbs);
                 
                 CPU->rcu.arriving_cbs = NULL;
@@ -913 +914 @@
         }
         
-        ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+        assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
         
         return expedite;        
@@ -933 +934 @@
         spinlock_lock(&rcu.gp_lock);
 
-        ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
-        ASSERT(CPU->rcu.cur_cbs_gp <= _rcu_cur_gp + 1);
+        assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+        assert(CPU->rcu.cur_cbs_gp <= _rcu_cur_gp + 1);
         
         while (rcu.completed_gp < CPU->rcu.cur_cbs_gp) {
@@ -1029 +1030 @@
 static void sample_local_cpu(void *arg)
 {
-        ASSERT(interrupts_disabled());
+        assert(interrupts_disabled());
         cpu_mask_t *reader_cpus = (cpu_mask_t *)arg;
         
@@ -1054 +1055 @@
 void rcu_after_thread_ran(void)
 {
-        ASSERT(interrupts_disabled());
+        assert(interrupts_disabled());
 
         /* 
@@ -1116 +1117 @@
 void rcu_before_thread_runs(void)
 {
-        ASSERT(!rcu_read_locked());
+        assert(!rcu_read_locked());
         
         /* Load the thread's saved nesting count from before it was preempted. */
@@ -1129 +1130 @@
 void rcu_thread_exiting(void)
 {
-        ASSERT(THE->rcu_nesting == 0);
+        assert(THE->rcu_nesting == 0);
         
         /* 
@@ -1157 +1158 @@
 void _rcu_preempted_unlock(void)
 {
-        ASSERT(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
+        assert(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
         
         size_t prev = local_atomic_exchange(&THE->rcu_nesting, 0);
@@ -1220 +1221 @@
         }
         
-        ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
-        ASSERT(_rcu_cur_gp <= CPU->rcu.cur_cbs_gp);
+        assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
+        assert(_rcu_cur_gp <= CPU->rcu.cur_cbs_gp);
         
         /* 
@@ -1262 +1263 @@
 static bool cv_wait_for_gp(rcu_gp_t wait_on_gp)
 {
-        ASSERT(spinlock_locked(&rcu.gp_lock));
+        assert(spinlock_locked(&rcu.gp_lock));
         
         bool interrupted = false;
@@ -1284 +1285 @@
 
                 if (detector_idle) {
-                        ASSERT(_rcu_cur_gp == rcu.completed_gp);
+                        assert(_rcu_cur_gp == rcu.completed_gp);
                         condvar_signal(&rcu.req_gp_changed);
                 }
@@ -1323 +1324 @@
 static bool wait_for_detect_req(void)
 {
-        ASSERT(spinlock_locked(&rcu.gp_lock));
+        assert(spinlock_locked(&rcu.gp_lock));
         
         bool interrupted = false;
@@ -1340 +1341 @@
 static void end_cur_gp(void)
 {
-        ASSERT(spinlock_locked(&rcu.gp_lock));
+        assert(spinlock_locked(&rcu.gp_lock));
         
         rcu.completed_gp = _rcu_cur_gp;
@@ -1423 +1424 @@
 static void sample_local_cpu(void *arg)
 {
-        ASSERT(interrupts_disabled());
-        ASSERT(!CPU->rcu.is_delaying_gp);
+        assert(interrupts_disabled());
+        assert(!CPU->rcu.is_delaying_gp);
         
         /* Cpu did not pass a quiescent state yet. */
@@ -1430 +1431 @@
                 /* Interrupted a reader in a reader critical section. */
                 if (0 < CPU->rcu.nesting_cnt) {
-                        ASSERT(!CPU->idle);
+                        assert(!CPU->idle);
                         /* 
                          * Note to notify the detector from rcu_read_unlock(). 
@@ -1492 +1493 @@
 void rcu_after_thread_ran(void)
 {
-        ASSERT(interrupts_disabled());
+        assert(interrupts_disabled());
 
         /* 
@@ -1559 +1560 @@
 void rcu_before_thread_runs(void)
 {
-        ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
-        ASSERT(0 == CPU->rcu.nesting_cnt);
+        assert(PREEMPTION_DISABLED || interrupts_disabled());
+        assert(0 == CPU->rcu.nesting_cnt);
         
         /* Load the thread's saved nesting count from before it was preempted. */
@@ -1590 +1591 @@
 void rcu_thread_exiting(void)
 {
-        ASSERT(THREAD != NULL);
-        ASSERT(THREAD->state == Exiting);
-        ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
+        assert(THREAD != NULL);
+        assert(THREAD->state == Exiting);
+        assert(PREEMPTION_DISABLED || interrupts_disabled());
         
         /* 
@@ -1615 +1616 @@
 static void start_new_gp(void)
 {
-        ASSERT(spinlock_locked(&rcu.gp_lock));
+        assert(spinlock_locked(&rcu.gp_lock));
         
         irq_spinlock_lock(&rcu.preempt_lock, true);
@@ -1734 +1735 @@
 static void upd_missed_gp_in_wait(rcu_gp_t completed_gp)
 {
-        ASSERT(CPU->rcu.cur_cbs_gp <= completed_gp);
+        assert(CPU->rcu.cur_cbs_gp <= completed_gp);
         
         size_t delta = (size_t)(completed_gp - CPU->rcu.cur_cbs_gp);
@@ -1764 +1765 @@
         irq_spinlock_lock(&rcu.preempt_lock, true);
         
-        ASSERT(link_used(&THREAD->rcu.preempt_link));
+        assert(link_used(&THREAD->rcu.preempt_link));
 
         bool prev_empty = list_empty(&rcu.cur_preempted);

kernel/generic/src/synch/waitq.c

@@ -44 +44 @@
  */
 
+#include <assert.h>
 #include <synch/waitq.h>
 #include <synch/spinlock.h>
@@ -203 +204 @@
                 irq_spinlock_lock(&thread->lock, false);
                 
-                ASSERT(thread->sleep_interruptible);
+                assert(thread->sleep_interruptible);
                 
                 if ((thread->timeout_pending) &&
@@ -264 +265 @@
 int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, unsigned int flags)
 {
-        ASSERT((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
+        assert((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
         
         ipl_t ipl = waitq_sleep_prepare(wq);
@@ -496 +497 @@
 static void waitq_complete_wakeup(waitq_t *wq)
 {
-        ASSERT(interrupts_disabled());
+        assert(interrupts_disabled());
         
         irq_spinlock_lock(&wq->lock, false);
@@ -520 +521 @@
         size_t count = 0;
 
-        ASSERT(interrupts_disabled());
-        ASSERT(irq_spinlock_locked(&wq->lock));
+        assert(interrupts_disabled());
+        assert(irq_spinlock_locked(&wq->lock));
         
 loop:

kernel/generic/src/synch/workqueue.c

@@ -37 +37 @@
  */
 
+#include <assert.h>
 #include <synch/workqueue.h>
 #include <synch/spinlock.h>
@@ -189 +190 @@
         if (workq) {
                 if (workq_init(workq, name)) {
-                        ASSERT(!workq_corrupted(workq));
+                        assert(!workq_corrupted(workq));
                         return workq;
                 }
@@ -202 +203 @@
 void workq_destroy(struct work_queue *workq)
 {
-        ASSERT(!workq_corrupted(workq));
+        assert(!workq_corrupted(workq));
         
         irq_spinlock_lock(&workq->lock, true);
@@ -214 +215 @@
                 workq_stop(workq);
         } else {
-                ASSERT(0 == running_workers);
+                assert(0 == running_workers);
         }
         
@@ -264 +265 @@
 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, 
@@ -273 +274 @@
                 
                 /* 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;
                 
@@ -312 +313 @@
                 
                 /* cur_worker_cnt proactively increased in signal_worker() .*/
-                ASSERT(0 < workq->cur_worker_cnt);
+                assert(0 < workq->cur_worker_cnt);
                 --workq->cur_worker_cnt;
         }
@@ -334 +335 @@
 void workq_stop(struct work_queue *workq)
 {
-        ASSERT(!workq_corrupted(workq));
+        assert(!workq_corrupted(workq));
         
         interrupt_workers(workq);
@@ -346 +347 @@
 
         /* workq_stop() may only be called once. */
-        ASSERT(!workq->stopping);
+        assert(!workq->stopping);
         workq->stopping = true;
         
@@ -358 +359 @@
 static void wait_for_workers(struct work_queue *workq)
 {
-        ASSERT(!PREEMPTION_DISABLED);
+        assert(!PREEMPTION_DISABLED);
         
         irq_spinlock_lock(&workq->lock, true);
@@ -375 +376 @@
         }
         
-        ASSERT(list_empty(&workq->workers));
+        assert(list_empty(&workq->workers));
         
         /* Wait for deferred add_worker_op(), signal_worker_op() to finish. */
@@ -473 +474 @@
         work_func_t func, bool can_block)
 {
-        ASSERT(!workq_corrupted(workq));
+        assert(!workq_corrupted(workq));
         
         bool success = true;
@@ -521 +522 @@
 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);
         
         /* 
@@ -550 +551 @@
 static size_t active_workers(struct work_queue *workq)
 {
-        ASSERT(irq_spinlock_locked(&workq->lock));
+        assert(irq_spinlock_locked(&workq->lock));
         
         /* 
@@ -573 +574 @@
 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);
@@ -593 +594 @@
 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. */
@@ -645 +646 @@
                          */
                         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);
@@ -681 +682 @@
         }
         
-        ASSERT(arg != NULL);
+        assert(arg != NULL);
         
         struct work_queue *workq = arg;
@@ -697 +698 @@
 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);
@@ -704 +705 @@
         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);
@@ -729 +730 @@
                 
 #ifdef CONFIG_DEBUG
-                ASSERT(!work_item_corrupted(*pwork_item));
+                assert(!work_item_corrupted(*pwork_item));
                 (*pwork_item)->cookie = 0;
 #endif
@@ -738 +739 @@
         } else {
                 /* Requested to stop and no more work queued. */
-                ASSERT(workq->stopping);
+                assert(workq->stopping);
                 --workq->cur_worker_cnt;
                 stop = true;
@@ -751 +752 @@
 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. */
@@ -775 +776 @@
         
         /* 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;
@@ -791 +792 @@
 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 */
@@ -814 +815 @@
 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;
@@ -834 +835 @@
                 
                 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);
                 }
@@ -903 +904 @@
                         struct work_queue, nb_link);
 
-                ASSERT(!workq_corrupted(*pworkq));
+                assert(!workq_corrupted(*pworkq));
                 
                 list_remove(&(*pworkq)->nb_link);