Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r82719589 r63e27ef  
    123123 *
    124124 */
    125  
     125
     126#include <assert.h>
    126127#include <synch/rcu.h>
    127128#include <synch/condvar.h>
    … …  
    404405        /* Stop and wait for reclaimers. */
    405406        for (unsigned int cpu_id = 0; cpu_id < config.cpu_active; ++cpu_id) {
    406                 ASSERT(cpus[cpu_id].rcu.reclaimer_thr != NULL);
     407                assert(cpus[cpu_id].rcu.reclaimer_thr != NULL);
    407408       
    408409                if (cpus[cpu_id].rcu.reclaimer_thr) {
    … …  
    487488static void read_unlock_impl(size_t *pnesting_cnt)
    488489{
    489         ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
     490        assert(PREEMPTION_DISABLED || interrupts_disabled());
    490491       
    491492        if (0 == --(*pnesting_cnt)) {
    … …  
    509510void _rcu_signal_read_unlock(void)
    510511{
    511         ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
     512        assert(PREEMPTION_DISABLED || interrupts_disabled());
    512513       
    513514        /*
    … …  
    531532         */
    532533        if (THREAD && local_atomic_exchange(&THREAD->rcu.was_preempted, false)) {
    533                 ASSERT(link_used(&THREAD->rcu.preempt_link));
     534                assert(link_used(&THREAD->rcu.preempt_link));
    534535
    535536                rm_preempted_reader();
    … …  
    563564{
    564565        /* Calling from a reader section will deadlock. */
    565         ASSERT(!rcu_read_locked());
     566        assert(!rcu_read_locked());
    566567       
    567568        synch_item_t completion;
    … …  
    576577{
    577578        synch_item_t *completion = member_to_inst(rcu_item, synch_item_t, rcu_item);
    578         ASSERT(completion);
     579        assert(completion);
    579580        waitq_wakeup(&completion->wq, WAKEUP_FIRST);
    580581}
    … …  
    615616static void add_barrier_cb(void *arg)
    616617{
    617         ASSERT(interrupts_disabled() || PREEMPTION_DISABLED);
     618        assert(interrupts_disabled() || PREEMPTION_DISABLED);
    618619        atomic_inc(&rcu.barrier_wait_cnt);
    619620        rcu_call(&CPU->rcu.barrier_item, barrier_complete);
    … …  
    657658        rcu_func_t func)
    658659{
    659         ASSERT(rcu_item);
     660        assert(rcu_item);
    660661       
    661662        rcu_item->func = func;
    … …  
    689690static bool cur_cbs_empty(void)
    690691{
    691         ASSERT(THREAD && THREAD->wired);
     692        assert(THREAD && THREAD->wired);
    692693        return NULL == CPU->rcu.cur_cbs;
    693694}
    … …  
    695696static bool next_cbs_empty(void)
    696697{
    697         ASSERT(THREAD && THREAD->wired);
     698        assert(THREAD && THREAD->wired);
    698699        return NULL == CPU->rcu.next_cbs;
    699700}
    … …  
    702703static bool arriving_cbs_empty(void)
    703704{
    704         ASSERT(THREAD && THREAD->wired);
     705        assert(THREAD && THREAD->wired);
    705706        /*
    706707         * Accessing with interrupts enabled may at worst lead to
    … …  
    719720static void reclaimer(void *arg)
    720721{
    721         ASSERT(THREAD && THREAD->wired);
    722         ASSERT(THREAD == CPU->rcu.reclaimer_thr);
     722        assert(THREAD && THREAD->wired);
     723        assert(THREAD == CPU->rcu.reclaimer_thr);
    723724
    724725        rcu_gp_t last_compl_gp = 0;
    … …  
    726727       
    727728        while (ok && wait_for_pending_cbs()) {
    728                 ASSERT(CPU->rcu.reclaimer_thr == THREAD);
     729                assert(CPU->rcu.reclaimer_thr == THREAD);
    729730               
    730731                exec_completed_cbs(last_compl_gp);
    … …  
    765766        /* Both next_cbs and cur_cbs GP elapsed. */
    766767        if (CPU->rcu.next_cbs_gp <= last_completed_gp) {
    767                 ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
     768                assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
    768769               
    769770                size_t exec_cnt = CPU->rcu.cur_cbs_cnt + CPU->rcu.next_cbs_cnt;
    … …  
    864865         */
    865866        if (CPU->rcu.next_cbs) {
    866                 ASSERT(CPU->rcu.parriving_cbs_tail != &CPU->rcu.arriving_cbs);
     867                assert(CPU->rcu.parriving_cbs_tail != &CPU->rcu.arriving_cbs);
    867868               
    868869                CPU->rcu.arriving_cbs = NULL;
    … …  
    913914        }
    914915       
    915         ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
     916        assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
    916917       
    917918        return expedite;       
    … …  
    933934        spinlock_lock(&rcu.gp_lock);
    934935
    935         ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
    936         ASSERT(CPU->rcu.cur_cbs_gp <= _rcu_cur_gp + 1);
     936        assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
     937        assert(CPU->rcu.cur_cbs_gp <= _rcu_cur_gp + 1);
    937938       
    938939        while (rcu.completed_gp < CPU->rcu.cur_cbs_gp) {
    … …  
    10291030static void sample_local_cpu(void *arg)
    10301031{
    1031         ASSERT(interrupts_disabled());
     1032        assert(interrupts_disabled());
    10321033        cpu_mask_t *reader_cpus = (cpu_mask_t *)arg;
    10331034       
    … …  
    10541055void rcu_after_thread_ran(void)
    10551056{
    1056         ASSERT(interrupts_disabled());
     1057        assert(interrupts_disabled());
    10571058
    10581059        /*
    … …  
    11161117void rcu_before_thread_runs(void)
    11171118{
    1118         ASSERT(!rcu_read_locked());
     1119        assert(!rcu_read_locked());
    11191120       
    11201121        /* Load the thread's saved nesting count from before it was preempted. */
    … …  
    11291130void rcu_thread_exiting(void)
    11301131{
    1131         ASSERT(THE->rcu_nesting == 0);
     1132        assert(THE->rcu_nesting == 0);
    11321133       
    11331134        /*
    … …  
    11571158void _rcu_preempted_unlock(void)
    11581159{
    1159         ASSERT(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
     1160        assert(0 == THE->rcu_nesting || RCU_WAS_PREEMPTED == THE->rcu_nesting);
    11601161       
    11611162        size_t prev = local_atomic_exchange(&THE->rcu_nesting, 0);
    … …  
    12201221        }
    12211222       
    1222         ASSERT(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
    1223         ASSERT(_rcu_cur_gp <= CPU->rcu.cur_cbs_gp);
     1223        assert(CPU->rcu.cur_cbs_gp <= CPU->rcu.next_cbs_gp);
     1224        assert(_rcu_cur_gp <= CPU->rcu.cur_cbs_gp);
    12241225       
    12251226        /*
    … …  
    12621263static bool cv_wait_for_gp(rcu_gp_t wait_on_gp)
    12631264{
    1264         ASSERT(spinlock_locked(&rcu.gp_lock));
     1265        assert(spinlock_locked(&rcu.gp_lock));
    12651266       
    12661267        bool interrupted = false;
    … …  
    12841285
    12851286                if (detector_idle) {
    1286                         ASSERT(_rcu_cur_gp == rcu.completed_gp);
     1287                        assert(_rcu_cur_gp == rcu.completed_gp);
    12871288                        condvar_signal(&rcu.req_gp_changed);
    12881289                }
    … …  
    13231324static bool wait_for_detect_req(void)
    13241325{
    1325         ASSERT(spinlock_locked(&rcu.gp_lock));
     1326        assert(spinlock_locked(&rcu.gp_lock));
    13261327       
    13271328        bool interrupted = false;
    … …  
    13401341static void end_cur_gp(void)
    13411342{
    1342         ASSERT(spinlock_locked(&rcu.gp_lock));
     1343        assert(spinlock_locked(&rcu.gp_lock));
    13431344       
    13441345        rcu.completed_gp = _rcu_cur_gp;
    … …  
    14231424static void sample_local_cpu(void *arg)
    14241425{
    1425         ASSERT(interrupts_disabled());
    1426         ASSERT(!CPU->rcu.is_delaying_gp);
     1426        assert(interrupts_disabled());
     1427        assert(!CPU->rcu.is_delaying_gp);
    14271428       
    14281429        /* Cpu did not pass a quiescent state yet. */
    … …  
    14301431                /* Interrupted a reader in a reader critical section. */
    14311432                if (0 < CPU->rcu.nesting_cnt) {
    1432                         ASSERT(!CPU->idle);
     1433                        assert(!CPU->idle);
    14331434                        /*
    14341435                         * Note to notify the detector from rcu_read_unlock().
    … …  
    14921493void rcu_after_thread_ran(void)
    14931494{
    1494         ASSERT(interrupts_disabled());
     1495        assert(interrupts_disabled());
    14951496
    14961497        /*
    … …  
    15591560void rcu_before_thread_runs(void)
    15601561{
    1561         ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
    1562         ASSERT(0 == CPU->rcu.nesting_cnt);
     1562        assert(PREEMPTION_DISABLED || interrupts_disabled());
     1563        assert(0 == CPU->rcu.nesting_cnt);
    15631564       
    15641565        /* Load the thread's saved nesting count from before it was preempted. */
    … …  
    15901591void rcu_thread_exiting(void)
    15911592{
    1592         ASSERT(THREAD != NULL);
    1593         ASSERT(THREAD->state == Exiting);
    1594         ASSERT(PREEMPTION_DISABLED || interrupts_disabled());
     1593        assert(THREAD != NULL);
     1594        assert(THREAD->state == Exiting);
     1595        assert(PREEMPTION_DISABLED || interrupts_disabled());
    15951596       
    15961597        /*
    … …  
    16151616static void start_new_gp(void)
    16161617{
    1617         ASSERT(spinlock_locked(&rcu.gp_lock));
     1618        assert(spinlock_locked(&rcu.gp_lock));
    16181619       
    16191620        irq_spinlock_lock(&rcu.preempt_lock, true);
    … …  
    17341735static void upd_missed_gp_in_wait(rcu_gp_t completed_gp)
    17351736{
    1736         ASSERT(CPU->rcu.cur_cbs_gp <= completed_gp);
     1737        assert(CPU->rcu.cur_cbs_gp <= completed_gp);
    17371738       
    17381739        size_t delta = (size_t)(completed_gp - CPU->rcu.cur_cbs_gp);
    … …  
    17641765        irq_spinlock_lock(&rcu.preempt_lock, true);
    17651766       
    1766         ASSERT(link_used(&THREAD->rcu.preempt_link));
     1767        assert(link_used(&THREAD->rcu.preempt_link));
    17671768
    17681769        bool prev_empty = list_empty(&rcu.cur_preempted);
Note: See TracChangeset for help on using the changeset viewer.