¿Qué es un bloqueo de memoria?

Históricamente, todos los programas de computadora se escribieron de una manera completamente secuencial. Esto es fácil de leer, escribir y entender. También es simple de ejecutar para una computadora y requiere un hardware relativamente simple. Con este paradigma de diseño, las dos únicas formas de aumentar el rendimiento del sistema son escribir un código más eficiente y aumentar la velocidad de la CPU. Puede ser posible aumentar la eficiencia del código, pero generalmente es un proceso complejo con resultados a menudo limitados.

Durante décadas, el rendimiento podía verse reducido por la espera de CPU nuevas y más eficientes. Tal como lo describe la ley de Moore, las CPU duplican aproximadamente su rendimiento cada dos o tres años. Desafortunadamente, la mayoría de estas mejoras de rendimiento provinieron del uso de nodos de fabricación cada vez más pequeños. La tecnología moderna ha estado luchando para reducir el tamaño de los nodos al ritmo histórico, gracias a las dificultades materiales que trabajan a escala de nanómetros.

Para evitar esto, los arquitectos de CPU modernos han optado por agregar múltiples núcleos de procesador a las CPU. Cada núcleo del procesador puede actuar de forma independiente en una tarea diferente. Si bien no pueden combinar el mismo problema, pueden trabajar en dos problemas simultáneamente. Este cambio arquitectónico fundamental proporciona mucho rendimiento adicional, pero no beneficia directamente a los procesos individuales, aunque reduce la contención por el tiempo del procesador.

Para aprovechar las CPU multinúcleo, el código debe escribirse en forma de subprocesos múltiples. Luego, cada subproceso se puede ejecutar simultáneamente, escalando el beneficio de rendimiento según la cantidad de subprocesos y núcleos de CPU disponibles. Sin embargo, hacer esto se enfrenta a un nuevo desafío, la "condición de carrera".

Nota: Algunas tareas no pueden ser multiproceso, mientras que otras pueden ser masivamente multiproceso. Los posibles beneficios de rendimiento dependen del trabajo realizado.

Condiciones de carrera

El software de subprocesos múltiples puede aprovechar múltiples núcleos. Los peligros acechan en esas aguas, listos para atrapar al programador inexperto. Una condición de carrera puede ocurrir cuando dos subprocesos diferentes interactúan con el mismo bit de memoria.

Un ejemplo simple podría ser dos subprocesos que intentan verificar e incrementar una variable simultáneamente. Digamos que a=0 . Luego, dos subprocesos diferentes realizan sus funciones y, en algún momento, verifican e incrementan en uno. En general, esperaría que el resultado de dos subprocesos sumando uno a cero sea dos. La mayoría de las veces, este debería ser el caso. Puede obtener un resultado diferente si ambos subprocesos pasan por esa funcionalidad específica precisamente en el momento adecuado.

En este caso, el primer subproceso lee el valor de un archivo . Antes de que el primer subproceso pueda incrementar el valor de un pensamiento, el segundo subproceso lo lee. Ahora el primer subproceso suma uno a cero, pero el segundo subproceso ya cree que el valor es cero, sumando uno a cero. El resultado de esto es que el valor final de a es 1, no 2.

Carrera hacia el peor de los casos

Si bien el ejemplo anterior puede no sonar particularmente mal, puede tener efectos dramáticos. ¿Qué pasa si el valor de a selecciona el modo de operación de una máquina? ¿Qué pasa si los modos específicos de operación de esa máquina pueden ser peligrosos o incluso potencialmente mortales?

Las condiciones de carrera tampoco necesitan ser tan simples. Por ejemplo, puede ser posible que un subproceso lea una sección de memoria al mismo tiempo que otro subproceso está escribiendo en él. En este caso, el hilo de lectura puede obtener una combinación extraña de datos tanto anteriores como posteriores. Digamos que la verificación es una simple verificación de verdadero/falso.

Si la variable decía verdadero al comienzo de la lectura pero estaba en proceso de sobrescribirse con la palabra falso, el resultado de la operación de lectura podría ser algo así como "trlse". Esto no es "verdadero" o "falso". Si no se incluye ninguna de las dos opciones en una opción binaria, es casi seguro que la aplicación se bloquee. Esta corrupción de la memoria puede generar muchos problemas de seguridad, como la denegación de servicio y la escalada de privilegios.

Bloqueo de la carrera

Saber qué bits de memoria en un programa se comparten entre diferentes subprocesos es esencial para evitar una condición de carrera. No es necesario hacer nada si una variable solo se controla y se puede acceder a ella mediante un solo subproceso. Si dos o más subprocesos pueden acceder a una variable, debe asegurarse de que todas las operaciones en esa pieza de memoria se completen de forma independiente.

Esta independencia se consigue gracias a un candado. En el código de un programa, debe colocar un candado al escribir una función que opera en una parte de memoria compartida. Este bloqueo impide que otros subprocesos accedan a esa parte de la memoria hasta que se libera el bloqueo.

La cerradura no es la más elegante de las soluciones. Por un lado, tiene sobrecarga de memoria. También puede obligar a que un hilo se cuelgue, esperando que se libere un bloqueo. Según la situación, es posible que el bloqueo no se libere durante mucho tiempo o que no se libere en absoluto. En el peor de los casos, desbloquear un bloqueo podría depender de que suceda algo en otro subproceso bloqueado, lo que lleva a un punto muerto.

Es fundamental optimizar el uso de las cerraduras. Puede controlar qué tan granular es el bloqueo. Por ejemplo, si está editando datos en una tabla, puede bloquear toda la tabla o bloquear solo la fila editada. Bloquear toda la tabla sería un bloqueo de granularidad gruesa. Minimiza la sobrecarga de implementar demasiados bloqueos, pero aumenta la posibilidad de que el bloqueo bloquee otro subproceso. Bloquear solo la fila sería un bloqueo de granularidad fino. Es mucho menos probable que esto interfiera con otros subprocesos, pero significa que se necesitarán bloqueos rotos, lo que aumenta la sobrecarga total.

Conclusión

Un bloqueo de memoria es una herramienta de código que se utiliza para garantizar la atomicidad de las operaciones en memoria en un entorno de subprocesos múltiples. Al bloquear una parte de la memoria antes de operar en ella, puede estar seguro de que no se producirá un comportamiento inesperado debido a una condición de carrera. Los bloqueos de memoria vienen con una sobrecarga de memoria, pero también pueden causar bloqueos.

El bloqueo es cuando otro subproceso intenta operar en una memoria bloqueada. El hilo permanece allí, bloqueado hasta que se libera el bloqueo. Esto puede causar problemas si liberar el bloqueo requiere que otro subproceso haga algo, ya que puede bloquearse antes de que pueda completar el requisito previo para liberar el bloqueo que lo bloquea. Los bloqueos de memoria se pueden evitar escribiendo códigos que no sean de bloqueo. Sin embargo, hacerlo puede ser complejo y menos eficaz que utilizar bloqueos. No olvides dejar tus comentarios a continuación.