Lines Matching refs:B
181 { A == 1; B == 2 }
182 A = 3; x = B;
183 B = 4; y = A;
188 STORE A=3, STORE B=4, y=LOAD A->3, x=LOAD B->4
189 STORE A=3, STORE B=4, x=LOAD B->4, y=LOAD A->3
190 STORE A=3, y=LOAD A->3, STORE B=4, x=LOAD B->4
191 STORE A=3, y=LOAD A->3, x=LOAD B->2, STORE B=4
192 STORE A=3, x=LOAD B->2, STORE B=4, y=LOAD A->3
193 STORE A=3, x=LOAD B->2, y=LOAD A->3, STORE B=4
194 STORE B=4, STORE A=3, y=LOAD A->3, x=LOAD B->4
195 STORE B=4, ...
215 { A == 1, B == 2, C == 3, P == &A, Q == &C }
216 B = 4; Q = P;
217 P = &B D = *Q;
224 (Q == &B) and (D == 2)
225 (Q == &B) and (D == 4)
304 X = *A; Y = *B; *D = Z;
308 X = LOAD *A, Y = LOAD *B, STORE *D = Z
309 X = LOAD *A, STORE *D = Z, Y = LOAD *B
310 Y = LOAD *B, X = LOAD *A, STORE *D = Z
311 Y = LOAD *B, STORE *D = Z, X = LOAD *A
312 STORE *D = Z, X = LOAD *A, Y = LOAD *B
313 STORE *D = Z, Y = LOAD *B, X = LOAD *A
589 { A == 1, B == 2, C == 3, P == &A, Q == &C }
590 B = 4;
592 WRITE_ONCE(P, &B)
596 여기엔 분명한 데이터 의존성이 존재하므로, 이 시퀀스가 끝났을 때 Q 는 &A 또는 &B
600 (Q == &B) 는 (D == 4) 를 의미합니다.
602 하지만! CPU 2 는 B 의 업데이트를 인식하기 전에 P 의 업데이트를 인식할 수 있고,
605 (Q == &B) and (D == 2) ????
616 { A == 1, B == 2, C == 3, P == &A, Q == &C }
617 B = 4;
619 WRITE_ONCE(P, &B);
631 P 는 짝수 번호 캐시 라인에 저장되어 있고, 변수 B 는 홀수 번호 캐시 라인에
634 중이라면 포인터 P (&B) 의 새로운 값과 변수 B 의 기존 값 (2) 를 볼 수 있습니다.
646 { A == 1, B == 2, C = 3, P == &A, Q == &C }
647 B = 4;
649 WRITE_ONCE(P, &B);
657 (Q == &B) && (B == 4)
994 STORE B = 2
1001 { STORE A, STORE B, STORE C } 가 역시 원소끼리의 순서가 존재하지 않는 집합
1011 | CPU 1 | : | B=2 | }
1031 { B = 7; X = 9; Y = 8; C = &Y }
1033 STORE B = 2
1035 STORE C = &B LOAD X
1036 STORE D = 4 LOAD C (gets &B)
1037 LOAD *C (reads B)
1044 | |------>| B=2 |----- --->| Y->8 | | 업데이트 이벤트
1050 | | : | C=&B |--- | : : +-------+
1052 | |------>| D=4 | ----------->| C->&B |------>| |
1058 분명히 잘못된 ---> | | B->7 |------>| |
1059 B 의 값 인지 (!) | +-------+ | |
1062 X 의 로드가 B 의 ---> \ | X->9 |------>| |
1064 지연시킴 ----->| B->2 | +-------+
1069 앞의 예에서, CPU 2 는 (B 의 값이 될) *C 의 값 읽기가 C 의 LOAD 뒤에 이어짐에도
1070 B 가 7 이라는 결과를 얻습니다.
1072 하지만, 만약 데이터 의존성 배리어가 C 의 로드와 *C (즉, B) 의 로드 사이에
1077 { B = 7; X = 9; Y = 8; C = &Y }
1079 STORE B = 2
1081 STORE C = &B LOAD X
1082 STORE D = 4 LOAD C (gets &B)
1084 LOAD *C (reads B)
1090 | |------>| B=2 |----- --->| Y->8 |
1096 | | : | C=&B |--- | : : +-------+
1098 | |------>| D=4 | ----------->| C->&B |------>| |
1108 뒤의 로드에게 ----->| B->2 |------>| |
1118 { A = 0, B = 9 }
1121 STORE B=2
1122 LOAD B
1132 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1134 | |------>| B=2 |--- | : :
1137 ---------->| B->2 |------>| |
1149 하지만, 만약 읽기 배리어가 B 의 로드와 A 의 로드 사이에 존재한다면:
1153 { A = 0, B = 9 }
1156 STORE B=2
1157 LOAD B
1167 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1169 | |------>| B=2 |--- | : :
1172 ---------->| B->2 |------>| |
1177 B 로의 스토어 전의 \ +-------+ | |
1188 { A = 0, B = 9 }
1191 STORE B=2
1192 LOAD B
1197 A 의 로드 두개가 모두 B 의 로드 뒤에 있지만, 서로 다른 값을 얻어올 수
1204 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1206 | |------>| B=2 |--- | : :
1209 ---------->| B->2 |------>| |
1217 B 로의 스토어 전의 \ +-------+ | |
1230 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1232 | |------>| B=2 |--- | : :
1235 ---------->| B->2 |------>| |
1249 여기서 보장되는 건, 만약 B 의 로드가 B == 2 라는 결과를 봤다면, A 에의 두번째
1271 LOAD B
1280 --->| B->2 |------>| |
1298 LOAD B
1310 --->| B->2 |------>| |
1332 --->| B->2 |------>| |
1379 원자성으로부터 나옵니다: CPU B 에서 수행된 로드가 CPU A 의 같은 변수로부터의
1381 하지 않았다면) multicopy 원자성을 제공하는 시스템에서는, CPU B 의 로드가 CPU A
1991 *B = b;
1995 ACQUIRE M, STORE *B, STORE *A, RELEASE M
2011 *B = b;
2015 ACQUIRE N, STORE *B, STORE *A, RELEASE M
2053 *B = b;
2063 ACQUIRE, {*F,*A}, *E, {*C,*D}, *B, RELEASE
2069 {*F,*A}, *B, ACQUIRE, *C, *D, RELEASE, *E
2070 *A, *B, *C, ACQUIRE, *D, RELEASE, *E, *F
2071 *A, *B, ACQUIRE, *C, RELEASE, *D, *E, *F
2072 *B, ACQUIRE, *C, *D, RELEASE, {*F,*A}, *E
2262 WRITE_ONCE(*B, b); WRITE_ONCE(*F, f);
2272 *E, ACQUIRE M, ACQUIRE Q, *G, *C, *F, *A, *B, RELEASE Q, *D, *H, RELEASE M
2276 *B, *C or *D preceding ACQUIRE M
2277 *A, *B or *C following RELEASE M
2719 WRITE_ONCE(*B, b);
2728 LOAD *A, STORE *B, LOAD *C, LOAD *D, STORE *E.
2759 LOAD *A, ..., LOAD {*C,*D}, STORE *E, STORE *B