memory-model/Documentation/simple.txt

2 memory-ordering lives simple, as is necessary for those whose domain
3 is complex.  After all, there are bugs other than memory-ordering bugs,
4 and the time spent gaining memory-ordering knowledge is not available
5 for gaining domain knowledge.  Furthermore Linux-kernel memory model
15 of MMIO-based device drivers will often need to use mb(), rmb(), and
22 Single-threaded code
25 In single-threaded code, there is no reordering, at least assuming
29 CPUs at the same time.  One important exception is a function that makes
38 this lock at a given time, your code will be executed single-threaded.
56 surprisingly hard to correctly code production-quality lock acquisition
57 and release functions.  After all, even simple non-production-quality
61 Despite the scalability limitations of single-threaded code, RCU
62 takes this approach for much of its grace-period processing and also
63 for early-boot operation.  The reason RCU is able to scale despite
64 single-threaded grace-period processing is use of batching, where all
66 next one.  In other words, slowing down grace-period processing makes
75 being completely single-threaded, it is often possible to use library
89 With code locking, we use single-threaded code execution to guarantee
100 concurrently.  This works because the buckets do not overlap with each
110 Per-CPU processing
114 a single-threaded approach while providing excellent performance and
122 generic/library variants of commonly used per-cpu constructs available.
125 RCU uses DEFINE_PER_CPU*() declaration to create a number of per-CPU
126 data sets.  For example, each CPU does private quiescent-state processing
127 within its instance of the per-CPU rcu_data structure, and then uses data
128 locking to report quiescent states up the grace-period combining tree.
135 lock-based programming, but there are a few lockless design patterns that
141 The basic keep-things-simple rule for sequence locking is "do not write
142 in read-side code".  Yes, you can do writes from within sequence-locking
149 currently necessary to open-code it in your litmus tests.)
158 keep-things-simple rules for RCU are "do not write in read-side code"
173 1.	Initialization and read-out, such as atomic_set() and atomic_read().
180 	value-returning operations provide full ordering only conditionally.
192 Documentation/core-api/refcount-vs-atomic.rst
200 When using locking, there often comes a time when it is necessary
204 If you want to keep things simple, use the initialization and read-out
211 Please note that per-CPU functions are not atomic operations and
226 One example use for these primitives is statistics, such as per-CPU
227 counters exemplified by the rt_cache_stat structure's routing-cache
240 It can be quite tempting to use plain C-language accesses for lockless
250 Therefore, if you really need to use C-language assignments instead of
259 Concurrency bugs should fear the big bad data-race detector (part 1)
261 Concurrency bugs should fear the big bad data-race detector (part 2)
269 recipes.txt file to peel off the next layer of the memory-ordering