Changeset 3679f51a in mainline for uspace/lib/c/generic/rcu.c


Ignore:
Timestamp:
2018-06-25T20:41:09Z (6 years ago)
Author:
Jiří Zárevúcky <jiri.zarevucky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
95838f1
Parents:
d73d992
git-author:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-06-25 20:30:35)
git-committer:
Jiří Zárevúcky <jiri.zarevucky@…> (2018-06-25 20:41:09)
Message:

Remove the option of RCU-upgradable futexes for now.
They complicate threading design too much.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/rcu.c

    rd73d992 r3679f51a  
    150150
    151151
    152 static void wait_for_readers(size_t reader_group, blocking_mode_t blocking_mode);
     152static void wait_for_readers(size_t reader_group);
    153153static void force_mb_in_all_threads(void);
    154154static bool is_preexisting_reader(const fibril_rcu_data_t *fib, size_t group);
    155155
    156 static void lock_sync(blocking_mode_t blocking_mode);
     156static void lock_sync(void);
    157157static void unlock_sync(void);
    158 static void sync_sleep(blocking_mode_t blocking_mode);
     158static void sync_sleep(void);
    159159
    160160static bool is_in_group(size_t nesting_cnt, size_t group);
     
    242242
    243243/** Blocks until all preexisting readers exit their critical sections. */
    244 void _rcu_synchronize(blocking_mode_t blocking_mode)
     244void rcu_synchronize(void)
    245245{
    246246        assert(!rcu_read_locked());
     
    252252        size_t gp_in_progress = ACCESS_ONCE(rcu.cur_gp);
    253253
    254         lock_sync(blocking_mode);
     254        lock_sync();
    255255
    256256        /*
     
    300300
    301301        size_t new_reader_group = get_other_group(rcu.reader_group);
    302         wait_for_readers(new_reader_group, blocking_mode);
     302        wait_for_readers(new_reader_group);
    303303
    304304        /* Separates waiting for readers in new_reader_group from group flip. */
     
    312312        memory_barrier();
    313313
    314         wait_for_readers(old_reader_group, blocking_mode);
     314        wait_for_readers(old_reader_group);
    315315
    316316        /* MB_FORCE_U  */
     
    332332
    333333/** Waits for readers of reader_group to exit their readers sections. */
    334 static void wait_for_readers(size_t reader_group, blocking_mode_t blocking_mode)
     334static void wait_for_readers(size_t reader_group)
    335335{
    336336        futex_down(&rcu.list_futex);
     
    346346                        if (is_preexisting_reader(fib, reader_group)) {
    347347                                futex_up(&rcu.list_futex);
    348                                 sync_sleep(blocking_mode);
     348                                sync_sleep();
    349349                                futex_down(&rcu.list_futex);
    350350                                /* Break to while loop. */
     
    361361}
    362362
    363 static void lock_sync(blocking_mode_t blocking_mode)
     363static void lock_sync(void)
    364364{
    365365        futex_down(&rcu.sync_lock.futex);
    366366        if (rcu.sync_lock.locked) {
    367                 if (blocking_mode == BM_BLOCK_FIBRIL) {
    368                         blocked_fibril_t blocked_fib;
    369                         blocked_fib.id = fibril_get_id();
    370 
    371                         list_append(&blocked_fib.link, &rcu.sync_lock.blocked_fibrils);
    372 
    373                         do {
    374                                 blocked_fib.is_ready = false;
    375                                 futex_up(&rcu.sync_lock.futex);
    376                                 fibril_switch(FIBRIL_TO_MANAGER);
    377                                 futex_down(&rcu.sync_lock.futex);
    378                         } while (rcu.sync_lock.locked);
    379 
    380                         list_remove(&blocked_fib.link);
    381                         rcu.sync_lock.locked = true;
    382                 } else {
    383                         assert(blocking_mode == BM_BLOCK_THREAD);
    384                         rcu.sync_lock.blocked_thread_cnt++;
     367                blocked_fibril_t blocked_fib;
     368                blocked_fib.id = fibril_get_id();
     369
     370                list_append(&blocked_fib.link, &rcu.sync_lock.blocked_fibrils);
     371
     372                do {
     373                        blocked_fib.is_ready = false;
    385374                        futex_up(&rcu.sync_lock.futex);
    386                         futex_down(&rcu.sync_lock.futex_blocking_threads);
    387                 }
     375                        fibril_switch(FIBRIL_TO_MANAGER);
     376                        futex_down(&rcu.sync_lock.futex);
     377                } while (rcu.sync_lock.locked);
     378
     379                list_remove(&blocked_fib.link);
     380                rcu.sync_lock.locked = true;
    388381        } else {
    389382                rcu.sync_lock.locked = true;
     
    420413}
    421414
    422 static void sync_sleep(blocking_mode_t blocking_mode)
     415static void sync_sleep(void)
    423416{
    424417        assert(rcu.sync_lock.locked);
     
    428421         */
    429422        futex_up(&rcu.sync_lock.futex);
    430 
    431         if (blocking_mode == BM_BLOCK_FIBRIL) {
    432                 async_usleep(RCU_SLEEP_MS * 1000);
    433         } else {
    434                 thread_usleep(RCU_SLEEP_MS * 1000);
    435         }
    436 
     423        async_usleep(RCU_SLEEP_MS * 1000);
    437424        futex_down(&rcu.sync_lock.futex);
    438425}
Note: See TracChangeset for help on using the changeset viewer.