Lines Matching +full:x +full:- +full:tal
2 This is a version of Documentation/memory-barriers.txt translated into
35 consistencia de memoria formal y documentación en tools/memory-model/. Sin
53 Tenga en cuenta también que es posible que una barrera no valga (sea no-op)
63 - Operaciones del dispositivo.
64 - Garantías.
68 - Variedades de barrera de memoria.
69 - ¿Qué no se puede asumir sobre las barreras de memoria?
70 - Barreras de dirección-dependencia (históricas).
71 - Dependencias de control.
72 - Emparejamiento de barreras smp.
73 - Ejemplos de secuencias de barrera de memoria.
74 - Barreras de memoria de lectura frente a especulación de carga.
75 - Atomicidad multicopia.
79 - Barrera del compilador.
80 - Barreras de memoria de la CPU.
84 - Funciones de adquisición de cerrojo.
85 - Funciones de desactivación de interrupciones.
86 - Funciones de dormir y despertar.
87 - Funciones varias.
89 (*) Efectos de barrera adquiriendo intra-CPU.
91 - Adquisición vs accesos a memoria.
95 - Interacción entre procesadores.
96 - Operaciones atómicas.
97 - Acceso a dispositivos.
98 - Interrupciones.
106 - Coherencia de caché.
107 - Coherencia de caché frente a DMA.
108 - Coherencia de caché frente a MMIO.
112 - Y luego está el Alfa.
113 - Guests de máquinas virtuales.
117 - Buffers circulares.
131 +-------+ : +--------+ : +-------+
134 | CPU 1 |<----->| Memoria|<----->| CPU 2 |
137 +-------+ : +--------+ : +-------+
142 | : +--------+ : |
145 +---------->| tivo |<----------+
148 : +--------+ :
169 A = 3; x = B;
176 STORE A=3, STORE B=4, y=LOAD A->3, x=LOAD B->4
177 STORE A=3, STORE B=4, x=LOAD B->4, y=LOAD A->3
178 STORE A=3, y=LOAD A->3, STORE B=4, x=LOAD B->4
179 STORE A=3, y=LOAD A->3, x=LOAD B->2, STORE B=4
180 STORE A=3, x=LOAD B->2, STORE B=4, y=LOAD A->3
181 STORE A=3, x=LOAD B->2, y=LOAD A->3, STORE B=4
182 STORE B=4, STORE A=3, y=LOAD A->3, x=LOAD B->4
189 x == 2, y == 1
190 x == 2, y == 3
191 x == 4, y == 1
192 x == 4, y == 3
218 ---------------------------
228 x = *D;
232 STORE *A = 5, x = LOAD *D
233 x = LOAD *D, STORE *A = 5
240 ---------
266 a = READ_ONCE(*X); WRITE_ONCE(*X, b);
271 a = LOAD *X, STORE *X = b
275 WRITE_ONCE(*X, c); d = READ_ONCE(*X);
279 STORE *X = c, d = LOAD *X
295 X = *A; Y = *B; *D = Z;
299 X = LOAD *A, Y = LOAD *B, STORE *D = Z
300 X = LOAD *A, STORE *D = Z, Y = LOAD *B
301 Y = LOAD *B, X = LOAD *A, STORE *D = Z
302 Y = LOAD *B, STORE *D = Z, X = LOAD *A
303 STORE *D = Z, X = LOAD *A, Y = LOAD *B
304 STORE *D = Z, Y = LOAD *B, X = LOAD *A
309 X = *A; Y = *(A + 4);
313 X = LOAD *A; Y = LOAD *(A + 4);
314 Y = LOAD *(A + 4); X = LOAD *A;
315 {X, Y} = LOAD {*A, *(A + 4) };
319 *A = X; *(A + 4) = Y;
323 STORE *A = X; STORE *(A + 4) = Y;
324 STORE *(A + 4) = Y; STORE *A = X;
325 STORE {*A, *(A + 4) } = {X, Y};
327 Y hay anti-garantías:
331 secuencias de lectura-modificación-escritura no atómica. No intente
338 secuencias de lectura-modificación-escritura no atómicas del lock
380 problema para la interacción CPU-CPU y para la E/S ("I/O"). Lo que se
388 Tal cumplimiento es importante porque las CPUs y otros dispositivos en un
398 ---------------------------------
419 combinarse con read o barreras de address-dependency barriers
454 dependencia es a través de un condicional en lugar de -en realidad-
553 garantizar que no habrá tal interacción en ninguna pieza de código en
563 ---------------------------------------------------------
594 Documentation/driver-api/pci/pci.rst
595 Documentation/core-api/dma-api-howto.rst
596 Documentation/core-api/dma-api.rst
600 -----------------------------------------------
698 del orden de dependencia es -prevenir- escrituras en la estructura de
720 -----------------------
726 Una dependencia de control load-load (de carga a carga) requiere una
750 Sin embargo, los stores no se especulan. Esto significa que ordenar -es-
751 provisto para dependencias de control de load-store, como en el siguiente
796 /* WRITE_ONCE(b, 1); -- movido arriba, BUG!!! */
799 /* WRITE_ONCE(b, 1); -- movido arriba, BUG!!! */
861 asegurarse de que MAX sea mayor que uno, tal vez de la siguiente manera:
913 pseudo-ensamblador:
948 smp_store_release() para realizar el store. Tenga en cuenta que -no-
985 ------------------------------
987 Cuando se trata de interacciones CPU-CPU, ciertos tipos de barrera de
1007 WRITE_ONCE(b, 2); x = READ_ONCE(b);
1017 WRITE_ONCE(b, &a); x = READ_ONCE(b);
1019 y = *x;
1027 WRITE_ONCE(x, 1); if (r2 = READ_ONCE(x)) {
1043 WRITE_ONCE(a, 1); }---- --->{ v = READ_ONCE(c);
1046 WRITE_ONCE(c, 3); } / \ { x = READ_ONCE(a);
1047 WRITE_ONCE(d, 4); }---- --->{ y = READ_ONCE(b);
1051 --------------------------------------------
1071 +-------+ : :
1072 | | +------+
1073 | |------>| C=3 | } /\
1074 | | : +------+ }----- \ -----> Eventos perceptibles para
1076 | | : +------+ }
1078 | | +------+ }
1079 | | wwwwwwwwwwwwwwww } <--- En este momento la barrera de
1080 | | +------+ } escritura requiere que todos los
1082 | | : +------+ } sean confirmados antes de que otros
1083 | |------>| D=4 | } store puedan suceder
1084 | | +------+
1085 +-------+ : :
1097 { B = 7; X = 9; Y = 8; C = &Y }
1101 STORE C = &B LOAD X
1109 +-------+ : : : :
1110 | | +------+ +-------+ | Secuencia de
1111 | |------>| B=2 |----- --->| Y->8 | | actualizado de
1112 | | : +------+ \ +-------+ | percepción en CPU 2
1113 | CPU 1 | : | A=1 | \ --->| C->&Y | V
1114 | | +------+ | +-------+
1116 | | +------+ | : :
1117 | | : | C=&B |--- | : : +-------+
1118 | | : +------+ \ | +-------+ | |
1119 | |------>| D=4 | ----------->| C->&B |------>| |
1120 | | +------+ | +-------+ | |
1121 +-------+ : : | : : | |
1124 | +-------+ | |
1125 Percepción de B ---> | | B->7 |------>| |
1126 aparentemente incorrecta! | +-------+ | |
1128 | +-------+ | |
1129 La carga de X frena ---> \ | X->9 |------>| |
1130 el mantenimiento de \ +-------+ | |
1131 la coherencia de B ----->| B->2 | +-------+
1132 +-------+
1144 { B = 7; X = 9; Y = 8; C = &Y }
1148 STORE C = &B LOAD X
1155 +-------+ : : : :
1156 | | +------+ +-------+
1157 | |------>| B=2 |----- --->| Y->8 |
1158 | | : +------+ \ +-------+
1159 | CPU 1 | : | A=1 | \ --->| C->&Y |
1160 | | +------+ | +-------+
1162 | | +------+ | : :
1163 | | : | C=&B |--- | : : +-------+
1164 | | : +------+ \ | +-------+ | |
1165 | |------>| D=4 | ----------->| C->&B |------>| |
1166 | | +------+ | +-------+ | |
1167 +-------+ : : | : : | |
1170 | +-------+ | |
1171 | | X->9 |------>| |
1172 | +-------+ | |
1173 Se asegura de que ---> \ aaaaaaaaaaaaaaaaa | |
1174 los efectos anteriores al \ +-------+ | |
1175 store de C sean percibidos ----->| B->2 |------>| |
1176 por los siguientes loads +-------+ | |
1177 : : +-------+
1196 +-------+ : : : :
1197 | | +------+ +-------+
1198 | |------>| A=1 |------ --->| A->0 |
1199 | | +------+ \ +-------+
1200 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1201 | | +------+ | +-------+
1202 | |------>| B=2 |--- | : :
1203 | | +------+ \ | : : +-------+
1204 +-------+ : : \ | +-------+ | |
1205 ---------->| B->2 |------>| |
1206 | +-------+ | CPU 2 |
1207 | | A->0 |------>| |
1208 | +-------+ | |
1209 | : : +-------+
1211 \ +-------+
1212 ---->| A->1 |
1213 +-------+
1232 +-------+ : : : :
1233 | | +------+ +-------+
1234 | |------>| A=1 |------ --->| A->0 |
1235 | | +------+ \ +-------+
1236 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1237 | | +------+ | +-------+
1238 | |------>| B=2 |--- | : :
1239 | | +------+ \ | : : +-------+
1240 +-------+ : : \ | +-------+ | |
1241 ---------->| B->2 |------>| |
1242 | +-------+ | CPU 2 |
1245 En este punto la barrera ----> \ rrrrrrrrrrrrrrrrr | |
1246 de lectura consigue que \ +-------+ | |
1247 todos los efectos anteriores ---->| A->1 |------>| |
1248 al almacenamiento de B sean +-------+ | |
1249 perceptibles por la CPU 2 : : +-------+
1269 +-------+ : : : :
1270 | | +------+ +-------+
1271 | |------>| A=1 |------ --->| A->0 |
1272 | | +------+ \ +-------+
1273 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1274 | | +------+ | +-------+
1275 | |------>| B=2 |--- | : :
1276 | | +------+ \ | : : +-------+
1277 +-------+ : : \ | +-------+ | |
1278 ---------->| B->2 |------>| |
1279 | +-------+ | CPU 2 |
1282 | +-------+ | |
1283 | | A->0 |------>| 1st |
1284 | +-------+ | |
1285 En este punto la barrera ----> \ rrrrrrrrrrrrrrrrr | |
1286 de lectura consigue que \ +-------+ | |
1287 todos los efectos anteriores ---->| A->1 |------>| |
1288 al almacenamiento de B sean +-------+ | |
1289 perceptibles por la CPU 2 : : +-------+
1295 +-------+ : : : :
1296 | | +------+ +-------+
1297 | |------>| A=1 |------ --->| A->0 |
1298 | | +------+ \ +-------+
1299 | CPU 1 | wwwwwwwwwwwwwwww \ --->| B->9 |
1300 | | +------+ | +-------+
1301 | |------>| B=2 |--- | : :
1302 | | +------+ \ | : : +-------+
1303 +-------+ : : \ | +-------+ | |
1304 ---------->| B->2 |------>| |
1305 | +-------+ | CPU 2 |
1308 \ +-------+ | |
1309 ---->| A->1 |------>| 1st |
1310 +-------+ | |
1312 +-------+ | |
1313 | A->1 |------>| 2nd |
1314 +-------+ | |
1315 : : +-------+
1318 la carga de B resultó en B == 2. No existe tal garantía para la primera
1323 -------------------------------------------------------------
1333 Puede resultar que la CPU en realidad no necesitara el valor, tal vez
1348 : : +-------+
1349 +-------+ | |
1350 --->| B->2 |------>| |
1351 +-------+ | CPU 2 |
1353 +-------+ | |
1354 La CPU ocupada con la división ---> --->| A->0 |~~~~ | |
1355 especula sobre el LOAD de A +-------+ ~ | |
1359 Una vez completadas las divisiones --> : : ~-->| |
1361 LOAD con efecto inmediato : : +-------+
1382 : : +-------+
1383 +-------+ | |
1384 --->| B->2 |------>| |
1385 +-------+ | CPU 2 |
1387 +-------+ | |
1388 La CPU ocupada con la división ---> --->| A->0 |~~~~ | |
1389 especula sobre el LOAD de A +-------+ ~ | |
1396 : : ~-->| |
1398 : : +-------+
1404 : : +-------+
1405 +-------+ | |
1406 --->| B->2 |------>| |
1407 +-------+ | CPU 2 |
1409 +-------+ | |
1410 La CPU ocupada con la división ---> --->| A->0 |~~~~ | |
1411 especula sobre el LOAD de A +-------+ ~ | |
1417 +-------+ | |
1418 La especulación es descartada ---> --->| A->1 |------>| |
1419 y un valor actualizado +-------+ | |
1420 es conseguido : : +-------+
1423 ---------------------
1433 al mismo tiempo en todas las -otras- CPUs. El resto de este documento
1441 { X = 0, Y = 0 }
1442 STORE X=1 r1=LOAD X (reads 1) LOAD Y (reads 1)
1444 STORE Y=r1 LOAD X
1446 Suponga que la carga de la CPU 2 desde X devuelve 1, que luego almacena en
1448 la CPU 1 a X precede a la carga de la CPU 2 desde X y el store de esa CPU 2
1451 CPU 3 carga desde Y antes de cargar desde X. La pregunta entonces es
1452 "¿Puede la carga de la CPU 3 desde X devolver 0?"
1454 Debido a que la carga de la CPU 3 desde X en cierto sentido viene después
1456 X deba devolver 1. Esta expectativa se deriva de la atomicidad multicopia:
1466 CPU 2 de X devuelve 1 y la carga de la CPU 3 de Y devuelve 1, entonces la
1467 carga de la CPU 3 desde X debe de hecho también devolver 1.
1477 { X = 0, Y = 0 }
1478 STORE X=1 r1=LOAD X (escribe 1) LOAD Y (lee 1)
1480 STORE Y=r1 LOAD X (lee 0)
1483 este ejemplo, es perfectamente legal que la carga de la CPU 2 desde X
1484 devuelva 1, la carga de la CPU 3 desde Y devuelva 1, y su carga desde X
1497 que -todas- las CPU percibirán el mismo orden de -todas- las operaciones.
1498 Por el contrario, una cadena de parejas de liberación-adquisición no
1504 int u, v, x, y, z;
1508 r0 = smp_load_acquire(&x);
1524 smp_store_release(&x, 1);
1540 Además, debido a la relación liberación-adquisición entre cpu0() y cpu1(),
1547 liberación-adquisición es local a las CPU que participan en esa cadena y no
1558 en orden, las CPU que no participan en la cadena de liberación-adquisición
1563 Esto significa que cpu3() puede ver el store de cpu0() suceder -después- de
1568 particular, simplemente lee de su argumento en orden. Es decir, -no-
1594 -----------------------
1603 lectura-lectura o escritura-escritura. Sin embargo, READ_ONCE() y
1612 interrupt-handler (encargo de gestionar interrupciones) y el código
1622 algunos ejemplos de tal tipo de optimizaciones:
1629 a[0] = x;
1630 a[1] = x;
1632 Podría resultar en un valor más antiguo de x almacenado en a[1] que en
1636 a[0] = READ_ONCE(x);
1637 a[1] = READ_ONCE(x);
1643 variable. Tal fusión puede hacer que el compilador "optimice" el
1909 -----------------------------
1938 auto-consistente, y ordenará correctamente los accesos superpuestos
1981 obj->dead = 1;
1983 atomic_dec(&obj->ref_count);
2006 if (desc->status != DEVICE_OWN) {
2011 read_data = desc->data;
2012 desc->data = write_data;
2018 desc->status = DEVICE_OWN;
2036 Documentation/core-api/dma-api.rst para más información sobre memoria
2079 -----------------------------------
2168 Sin embargo, esto no puede suceder porque si tal punto muerto amenazara
2174 Un punto clave es que solo estamos hablando de la CPU re-haciendo el
2176 desarrollador) cambió las operaciones, un deadlock -podría- ocurrir.
2188 Pero, ¿y si el cerrojo es un cerrojo que duerme ("sleeplock")? En tal
2192 haber una carrera de desbloqueo del sueño ("sleep-unlock race"), pero la
2198 contar con tal situación para lograr realmente nada en absoluto,
2202 Consulte también la sección "Efectos de barrera adquiriendo intra-CPU".
2232 --------------------------------------------
2237 barreras en tal situación, deben ser provistas por algún otro medio.
2241 -------------------------------
2268 STORE current->state
2313 STORE current->state ...
2315 LOAD evento_indicado if ((LOAD task->state) & TASK_NORMAL)
2316 STORE task->state
2323 no existe tal garantía. Para entender esto, considere la siguiente
2324 secuencia de eventos, donde X e Y son ambos cero inicialmente:
2328 X = 1; Y = 1;
2330 LOAD Y LOAD X
2380 el durmiente de manera que venga después del cambio a my_data. En tal
2399 ----------------
2407 EFECTOS DE BARRERA ADQUIRIENDO INTRA-CPU
2417 --------------------------------
2448 Bajo operación normal, el re-ordenamiento de una operación de memoria
2465 ------------------------------
2508 LOAD waiter->list.next;
2509 LOAD waiter->task;
2510 STORE waiter->task;
2535 LOAD waiter->task;
2536 STORE waiter->task;
2544 LOAD waiter->list.next;
2545 --- OOPS ---
2553 LOAD waiter->list.next;
2554 LOAD waiter->task;
2556 STORE waiter->task;
2574 --------------------
2585 ---------------------
2624 interrupción - y viceversa - a menos que se utilicenn barreras implícita o
2634 rutinas ejecutándose en separadas CPU que se comunican entre sí. Si tal
2711 delay() (es decir, los puntos 2-5 arriba) pero todavía se garantiza que
2758 little-endian y, por lo tanto, realizará operaciones de intercambio de
2759 bytes en arquitecturas big-endian.
2773 instrucciones en el orden que se quiera - o incluso en paralelo - siempre
2780 código de condición, cambio de registros o cambio de memoria - y
2809 <--- CPU ---> : <----------- Memoria ----------->
2811 +--------+ +--------+ : +--------+ +-----------+
2812 | Core | | Cola | : | Cache | | | +---------+
2814 | |--->| acceso |----->| |<-->| | | |
2815 | | | a | : | | | |--->| Memoria |
2817 +--------+ +--------+ : +--------+ | Mecanismo | | |
2818 : | de | +---------+
2820 : | de la | +--------+
2821 +--------+ +--------+ : +--------+ | cache | | |
2823 | CPU | | de | : | CPU | | |--->| Dispos |
2824 | |--->| acceso |----->| |<-->| | | itivo |
2826 | | | memoria| : | | | | +--------+
2827 +--------+ +--------+ : +--------+ +-----------+
2863 ---------------------------------
2871 cada CPU (y tal vez también invalidarlos).
2882 Consulte Documentation/core-api/cachetlb.rst para obtener más información
2887 ---------------------------------
2898 anteriormente. Una barrera de memoria no es suficiente en tal caso, sino
2948 haya accedido al caché- no hay garantía de que la gestión de la
2966 X = READ_ONCE(*A);
2974 X == W
2981 U=LOAD *A, STORE *A=V, STORE *A=W, X=LOAD *A, STORE *A=Y, Z=LOAD *A
2986 que READ_ONCE() y WRITE_ONCE() -no- son opcionales en el ejemplo anterior,
3022 --------------------
3039 -----------------------------
3064 ------------------
3070 Documentation/core-api/circular-buffers.rst
3087 Capítulo 7.1: Memory-Access Ordering
3090 ARM Architecture Reference Manual (ARMv8, for ARMv8-A architecture profile)
3093 IA-32 Intel Architecture Software Developer's Manual, Volumen 3:
3108 Capítulo 15: Sparc-V9 Memory Models
3124 Solaris Internals, Core Kernel Architecture, p63-68: