Instrucciones especiales de máquina en el sistema operativo

Las instrucciones de máquina son programas o comandos de código de máquina. En otras palabras, comandos escritos en el código de máquina de una computadora que puede reconocer y ejecutar posteriormente.

El código de máquina o lenguaje de máquina se refiere a un lenguaje de programación de computadora que consiste en una string de unos y ceros, es decir, código binario. Las computadoras pueden responder directamente al código máquina, es decir, sin ninguna dirección o conversión.

Instrucciones especiales de la máquina:

• Este tipo de instrucciones son normalmente, el acceso a una ubicación de memoria excluye otro acceso a la misma ubicación
• Extensiones: los diseñadores han propuesto instrucciones de máquina que realizan dos instrucciones atómicamente (indivisibles) en la misma ubicación de memoria (por ejemplo, lectura y escritura)
• La ejecución de tal instrucción también es mutuamente excluyente (incluso en Multiprocesadores)
• Se pueden usar para proporcionar exclusión mutua, pero deben complementarse con otros mecanismos para satisfacer los otros requisitos del problema de solución crítica.

Las siguientes técnicas se utilizan para el hardware de la solución crítica del problema:

1. Instrucción de prueba y configuración:

Establezca una ubicación de memoria en 1 y devuelva el valor anterior de la ubicación. Si un valor de retorno es 1, significa que el bloqueo lo adquirió otra persona. Si el valor devuelto es 0, entonces el bloqueo está libre y se establecerá en 1. Pruebe y modifique el contenido de una palabra automáticamente

int test_and_set (int &target) {
int tmp ;
tmp = target ;
target =1 ;     /* True */
return ( tmp )
}

Implementando la exclusión mutua con test y set :

external bool lock (false) ;
do {
while ( test_and_set (lock)) ;      /* Wait for Lock  */
critical_section ( )  ;          
Lock =false ;                 /* release the Lock  */
remainder_section ( ) ;
} while (1) ;

2. Instrucción de intercambio:

• Intercambia atómicamente dos variables
• Otra variación de la prueba y el conjunto es un intercambio atómico de dos variables booleanas

void Swap ( boolean &a , boolean &b ) {
boolean temp = a ;
a= b ;
b = temp ;
}

Implementación:

Shared Data :  boolean lock = false ;
Process Pi :
do {
key = true ;
while ( key == true ) 
        Swap ( lock , key ) ;
< critical section >
lock = false ;
< remainder section >
}

3. Comparar e intercambiar instrucciones:

Compare el valor de una ubicación de memoria con un valor anterior que se pasa a la instrucción. Si los dos valores coinciden, escriba el nuevo valor en la ubicación de la memoria. Con esta instrucción, establecemos una ubicación de memoria en un valor específico siempre que no se carguen los contenidos desde que los leemos. Si lo hicieran, nuestro nuevo valor no se establecerá.

int compare_and_swap (int *x , int old , int new ) {
int save = *x ;           /* current contents of the memory */
if (save == old)     *x = new ;
return save ;          /* tell the caller what was read */
}

Implementación:

while ( compare_and_swap ( &locked , 0 , 1 ) != 0 ) ;    /* spin until locked == 0  */
 /* if we got here lock got set to 1 and we have it  */
<Critical Section>
locked = 0 ;      /* release the lock  */
<remainder section>

4. Instrucción de obtención e incremento:

Esta instrucción incrementa la ubicación de la memoria y devuelve el valor anterior de la ubicación. Tomamos un boleto (búsqueda e incremento) y esperamos hasta que sea nuestro turno. Cuando termine, incrementamos el turno para que el hilo que tomó el siguiente boleto se vaya.

int fetch_and_increment ( int *x ) {
last_value = *x ;
*x = *x +1 ;
return last_value ;
}

el valor de retorno corresponde al número de nuestro boleto mientras que la máquina ahora está lista para generar el siguiente número más alto. 

Implementación:

ticket = 0 ;     turn = 0  ;
. . .
myturn = fetch_and_increment ( & ticket ) ;
while ( turn !=myturn )    /* Busy wait  */
<Criticcal Section>
fetch_and_increment ( &turn ) ; 

El ticket variable representa el número de ticket en la máquina y la variable myturn representa nuestro número de ticket, turn representa el número que se está sirviendo actualmente. Cada vez que alguien toma un boleto a través de fetch_and_increment, el valor del boleto se incrementa. Cada vez que alguien termina con su sección crítica y está listo para que se sirva el siguiente hilo, aumenta el turno.