Lines Matching refs:A
117 { A == 1; B == 2 }
118 A = 3; x = B;
119 B = 4; y = A;
124 STORE A=3, STORE B=4, y=LOAD A->3, x=LOAD B->4
125 STORE A=3, STORE B=4, x=LOAD B->4, y=LOAD A->3
126 STORE A=3, y=LOAD A->3, STORE B=4, x=LOAD B->4
127 STORE A=3, y=LOAD A->3, x=LOAD B->2, STORE B=4
128 STORE A=3, x=LOAD B->2, STORE B=4, y=LOAD A->3
129 STORE A=3, x=LOAD B->2, y=LOAD A->3, STORE B=4
130 STORE B=4, STORE A=3, y=LOAD A->3, x=LOAD B->4
151 { A == 1, B == 2, C = 3, P == &A, Q == &C }
159 (Q == &A) and (D == 1)
173 registers that are accessed through an address port register (A) and a data
177 *A = 5;
182 STORE *A = 5, x = LOAD *D
183 x = LOAD *D, STORE *A = 5
240 X = *A; Y = *B; *D = Z;
244 X = LOAD *A, Y = LOAD *B, STORE *D = Z
245 X = LOAD *A, STORE *D = Z, Y = LOAD *B
246 Y = LOAD *B, X = LOAD *A, STORE *D = Z
247 Y = LOAD *B, STORE *D = Z, X = LOAD *A
248 STORE *D = Z, X = LOAD *A, Y = LOAD *B
249 STORE *D = Z, Y = LOAD *B, X = LOAD *A
254 X = *A; Y = *(A + 4);
258 X = LOAD *A; Y = LOAD *(A + 4);
259 Y = LOAD *(A + 4); X = LOAD *A;
260 {X, Y} = LOAD {*A, *(A + 4) };
264 *A = X; *(A + 4) = Y;
268 STORE *A = X; STORE *(A + 4) = Y;
269 STORE *(A + 4) = Y; STORE *A = X;
270 STORE {*A, *(A + 4) } = {X, Y};
305 NOTE 2: A bit-field and an adjacent non-bit-field member
344 A write memory barrier gives a guarantee that all the STORE operations
349 A write barrier is a partial ordering on stores only; it is not required
352 A CPU can be viewed as committing a sequence of store operations to the
362 A data dependency barrier is a weaker form of read barrier. In the case
369 A data dependency barrier is a partial ordering on interdependent loads
375 considered can then perceive. A data dependency barrier issued by the CPU
398 A read barrier is a data dependency barrier plus a guarantee that all the
403 A read barrier is a partial ordering on loads only; it is not required to
415 A general memory barrier gives a guarantee that all the LOAD and STORE
420 A general memory barrier is a partial ordering over both loads and stores.
520 { A == 1, B == 2, C = 3, P == &A, Q == &C }
528 sequence, Q must be either &A or &B, and that:
530 (Q == &A) implies (D == 1)
547 { A == 1, B == 2, C = 3, P == &A, Q == &C }
595 A load-load control dependency requires a full read memory barrier, not
827 always be paired. A lack of appropriate pairing is almost certainly an error.
832 including of course general barriers. A write barrier pairs with a data
893 STORE A = 1
901 that the rest of the system might perceive as the unordered set of { STORE A,
909 | | : | A=1 | } \/ the rest of the system
932 STORE A = 1
946 | CPU 1 | : | A=1 | \ --->| C->&Y | V
978 STORE A = 1
992 | CPU 1 | : | A=1 | \ --->| C->&Y |
1018 { A = 0, B = 9 }
1019 STORE A=1
1023 LOAD A
1030 | |------>| A=1 |------ --->| A->0 |
1039 | | A->0 |------>| |
1044 ---->| A->1 |
1050 load of A on CPU 2:
1054 { A = 0, B = 9 }
1055 STORE A=1
1060 LOAD A
1067 | |------>| A=1 |------ --->| A->0 |
1080 prior to the storage of B ---->| A->1 |------>| |
1086 contained a load of A either side of the read barrier:
1090 { A = 0, B = 9 }
1091 STORE A=1
1095 LOAD A [first load of A]
1097 LOAD A [second load of A]
1099 Even though the two loads of A both occur after the load of B, they may both
1104 | |------>| A=1 |------ --->| A->0 |
1116 | | A->0 |------>| 1st |
1120 prior to the storage of B ---->| A->1 |------>| 2nd |
1125 But it may be that the update to A from CPU 1 becomes perceptible to CPU 2
1130 | |------>| A=1 |------ --->| A->0 |
1142 ---->| A->1 |------>| 1st |
1146 | A->1 |------>| 2nd |
1151 The guarantee is that the second load will always come up with A == 1 if the
1153 A; that may come up with either A == 0 or A == 1.
1177 LOAD A
1187 The CPU being busy doing a ---> --->| A->0 |~~~~ | |
1189 LOAD of A : : ~ | |
1206 LOAD A
1218 The CPU being busy doing a ---> --->| A->0 |~~~~ | |
1220 LOAD of A : : ~ | |
1240 The CPU being busy doing a ---> --->| A->0 |~~~~ | |
1242 LOAD of A : : ~ | |
1248 The speculation is discarded ---> --->| A->1 |------>| |
1275 CPU A follows a load from the same variable executing on CPU B, then
1276 CPU A's load must either return the same value that CPU B's load did,
1644 copy of b than a[b]. A consensus has not yet been reached about these problems,
1826 *A = a;
1833 ACQUIRE M, STORE *B, STORE *A, RELEASE M
1851 *A = a;
1858 ACQUIRE N, STORE *B, STORE *A, RELEASE M
1888 For example, with the following code, the store to *A will always be
1891 *A = a;
1899 STORE *A, RELEASE, ACQUIRE, smp_mb__after_unlock_lock(), STORE *B
1900 STORE *A, ACQUIRE, RELEASE, smp_mb__after_unlock_lock(), STORE *B
1901 ACQUIRE, STORE *A, RELEASE, smp_mb__after_unlock_lock(), STORE *B
1907 ensures that the store to *A will always be seen as happening before
1920 *A = a;
1931 ACQUIRE, {*F,*A}, *E, {*C,*D}, *B, RELEASE
1933 [+] Note that {*F,*A} indicates a combined access.
1937 {*F,*A}, *B, ACQUIRE, *C, *D, RELEASE, *E
1938 *A, *B, *C, ACQUIRE, *D, RELEASE, *E, *F
1939 *A, *B, ACQUIRE, *C, RELEASE, *D, *E, *F
1940 *B, ACQUIRE, *C, *D, RELEASE, {*F,*A}, *E
1972 A general memory barrier is interpolated automatically by set_current_state()
2012 A write memory barrier is implied by wake_up() and co. if and only if they wake
2119 ACCESS_ONCE(*A) = a; ACCESS_ONCE(*E) = e;
2126 Then there is no guarantee as to what order CPU 3 will see the accesses to *A
2130 *E, ACQUIRE M, ACQUIRE Q, *G, *C, *F, *A, *B, RELEASE Q, *D, *H, RELEASE M
2135 *A, *B or *C following RELEASE M
2144 ACCESS_ONCE(*A) = a;
2159 *E, ACQUIRE M [1], *C, *B, *A, RELEASE M [1],
2165 *A, *B or *C following RELEASE M [1]
2167 *A, *B, *C, *E, *F or *G following RELEASE M [2]
2487 A driver may be interrupted by its own interrupt service routine, and thus the
2528 A similar situation may occur between an interrupt routine and two routines
2625 A CPU may also discard any instruction sequence that winds up having no
2707 has a pair of parallel data caches (CPU 1 has A/B, and CPU 2 has C/D):
2712 +--------+ : +--->| Cache A |<------->| |
2731 (*) an odd-numbered cache line may be in cache A, cache C or it may still be
2758 <A:modify v=2> v is now in cache A exclusively
2782 <A:modify v=2> <C:busy>
2807 <A:modify v=2> <C:busy>
2861 A memory barrier isn't sufficient in such a case, but rather the cache must be
2870 A programmer might take it for granted that the CPU will perform memory
2874 a = ACCESS_ONCE(*A);
2884 LOAD *A, STORE *B, LOAD *C, LOAD *D, STORE *E.
2916 LOAD *A, ..., LOAD {*C,*D}, STORE *E, STORE *B
2925 U = ACCESS_ONCE(*A);
2926 ACCESS_ONCE(*A) = V;
2927 ACCESS_ONCE(*A) = W;
2928 X = ACCESS_ONCE(*A);
2929 ACCESS_ONCE(*A) = Y;
2930 Z = ACCESS_ONCE(*A);
2935 U == the original value of *A
2938 *A == Y
2943 U=LOAD *A, STORE *A=V, STORE *A=W, X=LOAD *A, STORE *A=Y, Z=LOAD *A
2959 *A = V;
2960 *A = W;
2964 *A = W;
2967 assumed that the effect of the storage of V to *A is lost. Similarly:
2969 *A = Y;
2970 Z = *A;
2974 *A = Y;