Changeset 63e27ef in mainline for kernel/generic/src/synch/workqueue.c


Ignore:
Timestamp:
2017-06-19T21:47:42Z (7 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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/synch/workqueue.c

    r7354b5e r63e27ef  
    3737 */
    3838
     39#include <assert.h>
    3940#include <synch/workqueue.h>
    4041#include <synch/spinlock.h>
    … …  
    189190        if (workq) {
    190191                if (workq_init(workq, name)) {
    191                         ASSERT(!workq_corrupted(workq));
     192                        assert(!workq_corrupted(workq));
    192193                        return workq;
    193194                }
    … …  
    202203void workq_destroy(struct work_queue *workq)
    203204{
    204         ASSERT(!workq_corrupted(workq));
     205        assert(!workq_corrupted(workq));
    205206       
    206207        irq_spinlock_lock(&workq->lock, true);
    … …  
    214215                workq_stop(workq);
    215216        } else {
    216                 ASSERT(0 == running_workers);
     217                assert(0 == running_workers);
    217218        }
    218219       
    … …  
    264265static bool add_worker(struct work_queue *workq)
    265266{
    266         ASSERT(!workq_corrupted(workq));
     267        assert(!workq_corrupted(workq));
    267268
    268269        thread_t *thread = thread_create(worker_thread, workq, TASK,
    … …  
    273274               
    274275                /* cur_worker_cnt proactively increased in signal_worker_logic() .*/
    275                 ASSERT(0 < workq->cur_worker_cnt);
     276                assert(0 < workq->cur_worker_cnt);
    276277                --workq->cur_worker_cnt;
    277278               
    … …  
    312313               
    313314                /* cur_worker_cnt proactively increased in signal_worker() .*/
    314                 ASSERT(0 < workq->cur_worker_cnt);
     315                assert(0 < workq->cur_worker_cnt);
    315316                --workq->cur_worker_cnt;
    316317        }
    … …  
    334335void workq_stop(struct work_queue *workq)
    335336{
    336         ASSERT(!workq_corrupted(workq));
     337        assert(!workq_corrupted(workq));
    337338       
    338339        interrupt_workers(workq);
    … …  
    346347
    347348        /* workq_stop() may only be called once. */
    348         ASSERT(!workq->stopping);
     349        assert(!workq->stopping);
    349350        workq->stopping = true;
    350351       
    … …  
    358359static void wait_for_workers(struct work_queue *workq)
    359360{
    360         ASSERT(!PREEMPTION_DISABLED);
     361        assert(!PREEMPTION_DISABLED);
    361362       
    362363        irq_spinlock_lock(&workq->lock, true);
    … …  
    375376        }
    376377       
    377         ASSERT(list_empty(&workq->workers));
     378        assert(list_empty(&workq->workers));
    378379       
    379380        /* Wait for deferred add_worker_op(), signal_worker_op() to finish. */
    … …  
    473474        work_func_t func, bool can_block)
    474475{
    475         ASSERT(!workq_corrupted(workq));
     476        assert(!workq_corrupted(workq));
    476477       
    477478        bool success = true;
    … …  
    521522static size_t active_workers_now(struct work_queue *workq)
    522523{
    523         ASSERT(irq_spinlock_locked(&workq->lock));
     524        assert(irq_spinlock_locked(&workq->lock));
    524525       
    525526        /* Workers blocked are sleeping in the work function (ie not idle). */
    526         ASSERT(workq->blocked_worker_cnt <= workq->cur_worker_cnt);
     527        assert(workq->blocked_worker_cnt <= workq->cur_worker_cnt);
    527528        /* Idle workers are waiting for more work to arrive in condvar_wait. */
    528         ASSERT(workq->idle_worker_cnt <= workq->cur_worker_cnt);
     529        assert(workq->idle_worker_cnt <= workq->cur_worker_cnt);
    529530       
    530531        /* Idle + blocked workers == sleeping worker threads. */
    531532        size_t sleeping_workers = workq->blocked_worker_cnt + workq->idle_worker_cnt;
    532533       
    533         ASSERT(sleeping_workers <= workq->cur_worker_cnt);
     534        assert(sleeping_workers <= workq->cur_worker_cnt);
    534535        /* Workers pending activation are idle workers not yet given a time slice. */
    535         ASSERT(workq->activate_pending <= workq->idle_worker_cnt);
     536        assert(workq->activate_pending <= workq->idle_worker_cnt);
    536537       
    537538        /*
    … …  
    550551static size_t active_workers(struct work_queue *workq)
    551552{
    552         ASSERT(irq_spinlock_locked(&workq->lock));
     553        assert(irq_spinlock_locked(&workq->lock));
    553554       
    554555        /*
    … …  
    573574static void signal_worker_op(struct work_queue *workq)
    574575{
    575         ASSERT(!workq_corrupted(workq));
     576        assert(!workq_corrupted(workq));
    576577
    577578        condvar_signal(&workq->activate_worker);
    578579       
    579580        irq_spinlock_lock(&workq->lock, true);
    580         ASSERT(0 < workq->pending_op_cnt);
     581        assert(0 < workq->pending_op_cnt);
    581582        --workq->pending_op_cnt;
    582583        irq_spinlock_unlock(&workq->lock, true);
    … …  
    593594static signal_op_t signal_worker_logic(struct work_queue *workq, bool can_block)
    594595{
    595         ASSERT(!workq_corrupted(workq));
    596         ASSERT(irq_spinlock_locked(&workq->lock));
     596        assert(!workq_corrupted(workq));
     597        assert(irq_spinlock_locked(&workq->lock));
    597598       
    598599        /* Only signal workers if really necessary. */
    … …  
    645646                         */
    646647                        if (need_worker && !can_block && 0 == active) {
    647                                 ASSERT(0 == workq->idle_worker_cnt);
     648                                assert(0 == workq->idle_worker_cnt);
    648649                               
    649650                                irq_spinlock_lock(&nonblock_adder.lock, true);
    … …  
    681682        }
    682683       
    683         ASSERT(arg != NULL);
     684        assert(arg != NULL);
    684685       
    685686        struct work_queue *workq = arg;
    … …  
    697698static bool dequeue_work(struct work_queue *workq, work_t **pwork_item)
    698699{
    699         ASSERT(!workq_corrupted(workq));
     700        assert(!workq_corrupted(workq));
    700701       
    701702        irq_spinlock_lock(&workq->lock, true);
    … …  
    704705        if (!workq->stopping && worker_unnecessary(workq)) {
    705706                /* There are too many workers for this load. Exit. */
    706                 ASSERT(0 < workq->cur_worker_cnt);
     707                assert(0 < workq->cur_worker_cnt);
    707708                --workq->cur_worker_cnt;
    708709                list_remove(&THREAD->workq_link);
    … …  
    729730               
    730731#ifdef CONFIG_DEBUG
    731                 ASSERT(!work_item_corrupted(*pwork_item));
     732                assert(!work_item_corrupted(*pwork_item));
    732733                (*pwork_item)->cookie = 0;
    733734#endif
    … …  
    738739        } else {
    739740                /* Requested to stop and no more work queued. */
    740                 ASSERT(workq->stopping);
     741                assert(workq->stopping);
    741742                --workq->cur_worker_cnt;
    742743                stop = true;
    … …  
    751752static bool worker_unnecessary(struct work_queue *workq)
    752753{
    753         ASSERT(irq_spinlock_locked(&workq->lock));
     754        assert(irq_spinlock_locked(&workq->lock));
    754755       
    755756        /* No work is pending. We don't need too many idle threads. */
    … …  
    775776       
    776777        /* Ignore lock ordering just here. */
    777         ASSERT(irq_spinlock_locked(&workq->lock));
     778        assert(irq_spinlock_locked(&workq->lock));
    778779       
    779780        _condvar_wait_timeout_irq_spinlock(&workq->activate_worker,
    780781                &workq->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_NONE);
    781782
    782         ASSERT(!workq_corrupted(workq));
    783         ASSERT(irq_spinlock_locked(&workq->lock));
     783        assert(!workq_corrupted(workq));
     784        assert(irq_spinlock_locked(&workq->lock));
    784785       
    785786        THREAD->workq_idling = false;
    … …  
    791792void workq_before_thread_is_ready(thread_t *thread)
    792793{
    793         ASSERT(thread);
    794         ASSERT(irq_spinlock_locked(&thread->lock));
     794        assert(thread);
     795        assert(irq_spinlock_locked(&thread->lock));
    795796
    796797        /* Worker's work func() is about to wake up from sleeping. */
    797798        if (thread->workq && thread->workq_blocked) {
    798799                /* Must be blocked in user work func() and not be waiting for work. */
    799                 ASSERT(!thread->workq_idling);
    800                 ASSERT(thread->state == Sleeping);
    801                 ASSERT(THREAD != thread);
    802                 ASSERT(!workq_corrupted(thread->workq));
     800                assert(!thread->workq_idling);
     801                assert(thread->state == Sleeping);
     802                assert(THREAD != thread);
     803                assert(!workq_corrupted(thread->workq));
    803804               
    804805                /* Protected by thread->lock */
    … …  
    814815void workq_after_thread_ran(void)
    815816{
    816         ASSERT(THREAD);
    817         ASSERT(irq_spinlock_locked(&THREAD->lock));
     817        assert(THREAD);
     818        assert(irq_spinlock_locked(&THREAD->lock));
    818819
    819820        /* Worker's work func() is about to sleep/block. */
    820821        if (THREAD->workq && THREAD->state == Sleeping && !THREAD->workq_idling) {
    821                 ASSERT(!THREAD->workq_blocked);
    822                 ASSERT(!workq_corrupted(THREAD->workq));
     822                assert(!THREAD->workq_blocked);
     823                assert(!workq_corrupted(THREAD->workq));
    823824               
    824825                THREAD->workq_blocked = true;
    … …  
    834835               
    835836                if (op) {
    836                         ASSERT(add_worker_noblock_op == op || signal_worker_op == op);
     837                        assert(add_worker_noblock_op == op || signal_worker_op == op);
    837838                        op(THREAD->workq);
    838839                }
    … …  
    903904                        struct work_queue, nb_link);
    904905
    905                 ASSERT(!workq_corrupted(*pworkq));
     906                assert(!workq_corrupted(*pworkq));
    906907               
    907908                list_remove(&(*pworkq)->nb_link);
Note: See TracChangeset for help on using the changeset viewer.