Lines Matching full:that

4 Read-copy update (RCU) is a synchronization mechanism that is used to
22 The key point here is that only the currently running critical sections
23 are waited for; critical sections that are started **after** the beginning
26 for example, reader-writer locks. It is so much more scalable that
32 "removal" and "reclamation". During removal, we ensure that subsequent
35 the old data. Therefore, critical sections that begin after removal
57 that critical section.
66 Used by a reader to inform the reclaimer that the reader is
70 Used by a reader to inform the reclaimer that the reader is
71 exiting an RCU read-side critical section. Note that RCU
79 Note that it would be valid for another update to come while
80 ``synchronize_rcu`` is running. Because of this, it is better that
101 so that the reclaimer function can fetch the ``struct foo`` address
129 it makes some assumptions on the code that calls it. This allows a
132 ``qatomic_rcu_read`` assumes that whenever a single RCU critical
136 navigate one or more pointers (the pointers that are changed on
150 though it also makes assumptions on the code that calls it in
155 data item that is already accessible to readers. This is the
157 structure; just ensure that initialization of ``*p`` is carried out
177 Note that these APIs are relatively heavyweight, and should **not** be
183 Two macros are provided that automatically release the read lock at the
193 Note that a ``goto`` out of the guarded block will also drop the lock.
206 - ``call_rcu`` is a macro that has an extra argument (the name of the first
222 - the updater does not mean "everything that writes to a data structure",
223 but rather "everything that involves a reclamation step". See the
230 Here are some frequently-used RCU idioms that are worth noting.
252 The RCU read-side critical section ensures that the value of ``p`` remains
254 a reference to ``p`` that is later released when the critical section ends.
304 Note that the same idioms would be possible with reader/writer
336 - ensuring that the old version of the array is available between removal