mirrors/bird
mirrors/bird
0
0
Fork 0
mirror of https://gitlab.nic.cz/labs/bird.git synced 2024-11-08 20:28:43 +00:00
Code Releases Activity
whatever-test
bird/lib/rcu.h

56 lines
1.3 KiB
C
Raw Permalink Normal View History

Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
/*
* BIRD Library -- Read-Copy-Update Basic Operations
*
* (c) 2021 Maria Matejka <mq@jmq.cz>
* (c) 2021 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
* Note: all the relevant patents shall be expired.
*/
#ifndef _BIRD_RCU_H_
#define _BIRD_RCU_H_
#include "lib/birdlib.h"
#include "lib/lists.h"
#include <stdatomic.h>
#define RCU_GP_PHASE 0x100000
#define RCU_NEST_MASK 0x0fffff
#define RCU_NEST_CNT 0x000001
extern _Atomic uint rcu_gp_ctl;
Decoupling loops from threads to allow fixed thread count On large configurations, too many threads would spawn with one thread per loop. Therefore, threads may now run multiple loops at once. The thread count is configurable and may be changed during run. All threads are spawned on startup. This change helps with memory bloating. BIRD filters need large temporary memory blocks to store their stack and also memory management keeps its hot page storage per-thread. Known bugs: * Thread autobalancing is not yet implemented. * Low latency loops are executed together with standard loops.
2023-01-19 09:49:47 +00:00
struct rcu_thread {
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
node n;
_Atomic uint ctl;
};
Decoupling loops from threads to allow fixed thread count On large configurations, too many threads would spawn with one thread per loop. Therefore, threads may now run multiple loops at once. The thread count is configurable and may be changed during run. All threads are spawned on startup. This change helps with memory bloating. BIRD filters need large temporary memory blocks to store their stack and also memory management keeps its hot page storage per-thread. Known bugs: * Thread autobalancing is not yet implemented. * Low latency loops are executed together with standard loops.
2023-01-19 09:49:47 +00:00
extern _Thread_local struct rcu_thread *this_rcu_thread;
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
static inline void rcu_read_lock(void)
{
Decoupling loops from threads to allow fixed thread count On large configurations, too many threads would spawn with one thread per loop. Therefore, threads may now run multiple loops at once. The thread count is configurable and may be changed during run. All threads are spawned on startup. This change helps with memory bloating. BIRD filters need large temporary memory blocks to store their stack and also memory management keeps its hot page storage per-thread. Known bugs: * Thread autobalancing is not yet implemented. * Low latency loops are executed together with standard loops.
2023-01-19 09:49:47 +00:00
uint cmp = atomic_load_explicit(&this_rcu_thread->ctl, memory_order_acquire);
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
if (cmp & RCU_NEST_MASK)
Decoupling loops from threads to allow fixed thread count On large configurations, too many threads would spawn with one thread per loop. Therefore, threads may now run multiple loops at once. The thread count is configurable and may be changed during run. All threads are spawned on startup. This change helps with memory bloating. BIRD filters need large temporary memory blocks to store their stack and also memory management keeps its hot page storage per-thread. Known bugs: * Thread autobalancing is not yet implemented. * Low latency loops are executed together with standard loops.
2023-01-19 09:49:47 +00:00
atomic_store_explicit(&this_rcu_thread->ctl, cmp + RCU_NEST_CNT, memory_order_relaxed);
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
else
Decoupling loops from threads to allow fixed thread count On large configurations, too many threads would spawn with one thread per loop. Therefore, threads may now run multiple loops at once. The thread count is configurable and may be changed during run. All threads are spawned on startup. This change helps with memory bloating. BIRD filters need large temporary memory blocks to store their stack and also memory management keeps its hot page storage per-thread. Known bugs: * Thread autobalancing is not yet implemented. * Low latency loops are executed together with standard loops.
2023-01-19 09:49:47 +00:00
atomic_store(&this_rcu_thread->ctl, atomic_load_explicit(&rcu_gp_ctl, memory_order_acquire));
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
}
static inline void rcu_read_unlock(void)
{
Decoupling loops from threads to allow fixed thread count On large configurations, too many threads would spawn with one thread per loop. Therefore, threads may now run multiple loops at once. The thread count is configurable and may be changed during run. All threads are spawned on startup. This change helps with memory bloating. BIRD filters need large temporary memory blocks to store their stack and also memory management keeps its hot page storage per-thread. Known bugs: * Thread autobalancing is not yet implemented. * Low latency loops are executed together with standard loops.
2023-01-19 09:49:47 +00:00
atomic_fetch_sub(&this_rcu_thread->ctl, RCU_NEST_CNT);
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
}
void synchronize_rcu(void);
/* Registering and unregistering a birdloop. To be called from birdloop implementation */
Decoupling loops from threads to allow fixed thread count On large configurations, too many threads would spawn with one thread per loop. Therefore, threads may now run multiple loops at once. The thread count is configurable and may be changed during run. All threads are spawned on startup. This change helps with memory bloating. BIRD filters need large temporary memory blocks to store their stack and also memory management keeps its hot page storage per-thread. Known bugs: * Thread autobalancing is not yet implemented. * Low latency loops are executed together with standard loops.
2023-01-19 09:49:47 +00:00
void rcu_thread_start(struct rcu_thread *);
void rcu_thread_stop(struct rcu_thread *);
Introducing basic RCU primitives for lock-less shared data structures
2021-11-12 21:58:40 +00:00
/* Run this from resource init */
void rcu_init(void);
#endif
Copy Permalink