Lines Matching refs:loads
79 for the loads, the model will predict whether it is possible for the
80 code to run in such a way that the loads will indeed obtain the
142 shared memory locations and another CPU loads from those locations in
154 A memory model will predict what values P1 might obtain for its loads
197 Since r1 = 1, P0 must store 1 to flag before P1 loads 1 from
198 it, as loads can obtain values only from earlier stores.
200 P1 loads from flag before loading from buf, since CPUs execute
223 each CPU stores to its own shared location and then loads from the
272 X: P1 loads 1 from flag executes before
273 Y: P1 loads 0 from buf executes before
278 and a certain outcome for the loads in a piece of code can happen only
293 Read events correspond to loads from shared memory, such as
557 Usage of the rf relation implicitly assumes that loads will always
649 loads, then either they read from the same store or else the
716 (As a minor curiosity, if this code had used normal loads instead of
786 only internal operations. However, loads, stores, and fences involve
812 to satisfy one of the CPU's loads until it has been processed. On
837 smp_rmb() forces the CPU to execute all po-earlier loads
838 before any po-later loads;
950 inserting the loads from that location into this ordering, by placing
952 store. This leaves the relative positions of loads that read from the
986 CPU 0 loads x obtaining 13;
987 CPU 1 loads x obtaining 13;
1062 X and Y are both loads and an smp_rmb() fence occurs between
1072 X and Y are both loads, X ->addr Y (i.e., there is an address
1092 we consider address dependencies to loads.
1095 loads in program order if there is an address dependency between them.
1099 that looks as if the loads were executed out of order (see the next
1101 problem when the loads come from READ_ONCE(), and therefore the LKMM
1102 includes address dependencies to loads in the ppo relation.
1105 two loads. This happens when there is a dependency from a load to a
1158 not appear to respect address dependencies to loads. This means that
1198 final effect is that even though the two loads really are executed in
1206 between P1's two loads when the kernel is compiled for the Alpha
1231 instructions (or po-later loads in the case of smp_rmb()) until all
1307 An equally simple case involves two loads of the same location that
1358 similar to the previous examples: The value P1 loads from buf gets
1371 But what if we put an smp_rmb() fence between P1's loads? The fence
1372 would force the two loads to be executed in program order, and it
1845 This requires P0 and P2 to execute their loads and stores out of
1911 memory location and a value). These loads and stores are annotated as
1928 the LKMM will treat A and B as loads from s yielding values saved in
2444 therefore any loads among those instructions will execute
2463 This distinction is needed because some fences affect only loads
2471 allowed to put plain loads of the same location into the object code.
2496 a concurrent load from that location. Two concurrent loads don't