Red de conocimiento de divisas - conocimientos contables - Escribir la tarea del sistema operativo en lenguaje C o C: Algoritmo bancario

Escribir la tarea del sistema operativo en lenguaje C o C: Algoritmo bancario

Algoritmo sin punto muerto.

Para explicar el Algoritmo Bancario, primero debemos explicar los estados seguros e inseguros del sistema operativo.

Estado seguro: Si existe una secuencia segura P1,...,Pn compuesta por todos los procesos del sistema, el sistema está en un estado seguro. El estado seguro no debe ser un punto muerto.

Estado inseguro: La secuencia segura no existe. Un estado inseguro no conduce necesariamente a un punto muerto.

Entonces, ¿qué es una secuencia de seguridad?

Secuencia segura: La secuencia del proceso es segura. Si para cada proceso Pi (1≤i≤n), la cantidad de recursos que aún necesita en el futuro no excede los recursos restantes actuales del sistema y todos los procesos PJ (j

Algoritmo bancario:

Podemos pensar en el sistema operativo como un banquero. Los recursos administrados por el sistema operativo son equivalentes a los fondos administrados por el banquero. La solicitud del proceso para asignar recursos al sistema operativo es equivalente al préstamo del usuario. al banquero Asignar recursos. Cuando un proceso solicita por primera vez un recurso, debe probar la demanda máxima del recurso. Si los recursos existentes del sistema pueden satisfacer su demanda máxima, el recurso debe asignarse de acuerdo con la cantidad de solicitud actual. de lo contrario, la asignación se pospondrá. Cuando un proceso continúa solicitando recursos durante la ejecución, primero prueba si la suma de los recursos ocupados por el proceso y los recursos solicitados en este tiempo excede la demanda máxima de recursos del proceso. , se negará a asignar recursos; si no lo hace, se negará a asignar recursos. Pruebe si los recursos existentes en el sistema pueden cumplir con la cantidad máxima de recursos que aún se necesitan en el proceso. al volumen de aplicaciones actual; de lo contrario, se pospondrá.

Algoritmo:

n: El número total de procesos en el sistema

m: El total. número de clases de recursos

Disponible: entero en matriz [1..m];

Máx.: ARRAY[ 1..n, 1..m] entero;

Asignar: matriz [1..n, 1..m] entero;

Requiere: matriz [1..n, 1..m];

Solicitud: Entero de matriz [1..n, 1..m];

Descripción del símbolo:

Recursos restantes disponibles

Máxima demanda máxima

Asignar recursos asignados

Necesitar recursos de demanda

Solicitar recursos de solicitud

Cuando el proceso pi solicita recursos, el sistema realiza las siguientes operaciones

Pasos: ("=" es el símbolo de asignación, "==" es el signo igual)

Si se solicita, realice el paso (1)

Paso (2) si. requerido

Paso (3) Supongamos que el sistema asigna recursos, con:

Disponible = solicitud-disponible

Asignación = solicitud de asignación

;

Requerido = Solicitud requerida

Si el nuevo estado del sistema es seguro, se completa la asignación.

Si el nuevo estado del sistema no es seguro, el estado original. se restaura y el proceso espera.

Para controles de seguridad, defina la estructura de datos:

Trabajo: matriz[1.. m];

Completo: matriz. [1..Boolean n];

Pasos de verificación de seguridad:

Paso (1):

Trabajo = disponible;

Terminar = false

Paso (2) búscame:

a.Finish = = false

b.Requires lt=work;

Si no existe, vaya al paso (4)

Paso 3

Trabajo=asignación de trabajo

Finalizar = verdadero

Vaya al paso (2)

Paso (4) Si finalizar = verdadero para todas las I, el sistema está en un estado seguro; de lo contrario, es una condición insegura.

/*Algoritmo bancario, concepto de sistema operativo versión 6.

Reeditado por Johnny hagen de SCAU, ejecutándose en vc6.0

*/

#Contiene "malloc.h"

#Incluir "stdio.h"

#Incluir "stdlib.h"

#definir tamaño alloclen(asignación de estructura)

#definir tamaño maxlen(estructura max )

#Definir tamaño avalen (estructura disponible)

#Definir tamaño de aguja (estructura requerida)

#Definir tamaño finilen (final de estructura)

#define pathlen sizeof(ruta de la estructura)

Asignación de estructura

{

int value;

Asignación de estructura* siguiente

};

Estructura máxima

{

int valor;

estructura max * siguiente

};

Estructura disponible/*Número de recursos disponibles*/

{

valor int;

Estructura disponible*/ siguiente

};

Requisitos estructurales/*Cantidad de recursos requeridos*/

{

valor int;

estructura requiere * siguiente

};

ruta de estructura

{

valor int;

Ruta de la estructura * siguiente

};

Finalización de la estructura

{

int stat

terminación de la estructura * siguiente

};

int main()

{

int fila, columna, estado=0, I, j, t, temp, processtest

Asignación de estructura *allochead, *alloc1, *alloc2, * alloctemp

struct max *maxhead, *maxium1, *maxium2, *maxtemp

estructura disponible *avahead, *disponible1, *disponible2, *workhead, *work1, *work2, *worktemp, *work temp 1;

struct need *needhead, *need1, *need2, * needtemp

p>

estructura terminar *finihead, *finish1, *finish2, * Finishtemp

Ruta de la estructura *cabecera de ruta, *ruta1, *ruta2;

printf( " \ nIngrese el número de tipos de recursos del sistema: ");

scanf("d ", ampcolum

Printf("Ingrese el número de procesos en la memoria actual). : ");

scanf("d", amp row);

Printf("Ingrese la matriz de recursos asignados:\n");

for(I = 0; i lt fila; i )

{

for(j = 0; j ltcolumj )

{

Printf( "Ingrese el recurso del sistema c asignado para procesar pd:", I, 'A' j);

>if (estado == 0)

{

allochead = alloc 1 = alloc 2 =(asignación de estructura *)malloc(alloclen);

alloc1- >siguiente = alloc 2- gt; siguiente = NULL

scanf("d ", ampallochead- gt; valor);

estado;

} p>

Otro

{

alloc 2 =(asignación de estructura *)malloc(alloclen);

scanf("d, d " , ampalloc2 ->valor);

if(status==1)

{

allochead- gt; next = alloc2

estado;

}

alloc1->siguiente = alloc2

alloc 1 = alloc 2;

}

}

}

alloc2->next = NULL

Estado = 0;

Printf("Ingrese la matriz de demanda máxima :\n ");

for(I = 0; i lt fila; i )

{

for(j = 0; j ltcolumj )

{

Printf("Ingrese el requisito máximo de recursos del sistema del proceso pd categoría c: ", I, ' A ' j);

If (status == 0)

{

maxhead = maxium 1 = maxium 2 =(struct max *)malloc(maxlen);

maxium 1->; = maxium 2- gt ;siguiente = NULL

scanf("d ", ampmaxium 1->; valor);

status ;

}

Otros

{

maxium 2 =(struct max *)malloc(maxlen

scanf("d, d ", ampmaxium 2); ->; valor) ;

if(status==1)

{

maxhead- gt siguiente = maxium2

estado; ;

}

máximo 1->; siguiente = máximo2

máximo 1 = máximo 2;

}

}

}

maxium 2->; next = NULL

Estado = 0;

Printf("Por favor, ingrese el Matriz de recursos restantes del sistema actual :\n ");

for(j = 0; j ltcolumj )

{

Printf("Recursos restantes del sistema de categoría c: ",' A ' j);

If (status == 0)

{

ava head = disponible 1 = disponible 2 = (estructura disponible *)malloc( avalen);

cabeza de trabajo

= trabajo 1 = trabajo 2 =(struct disponible *)malloc(avalen);

disponible 1->; siguiente = disponible 2- gt; siguiente = NULL

trabajo 1-> ; siguiente = trabajo 2- gt; siguiente = NULL

scanf("d ", ampavailable 1->; valor

trabajo 1->; ; valor;

estado

}

Otro

{

disponible 2 =(estructura disponible * )malloc(avalen);

trabajo 2 =(estructura disponible *)malloc(avalen);

scanf("d, d", amp disponible 2->valor);

trabajo 2->valor = disponible 2- gt;valor;

if(status==1)

{

ava head - gt; siguiente = disponible2

cabezal de trabajo->; siguiente = trabajo2

estado;

}

disponible 1-> ; siguiente = disponible2

disponible 1 = disponible 2;

trabajo 1->;siguiente = trabajo2

trabajo 1 = trabajo 2;

}

}

Disponible 2->siguiente = NULL

Trabajando 2->siguiente = NULL

Estado = 0 ;

alloctemp = allochead

maxtemp = maxhead

for(I = 0; I lt fila; i)

for(j = 0 ; j ltcolumj )

{

if (estado == 0)

{

necesidad cabeza = necesidad 1 = necesidad 2 = (struct need *)malloc(needlen);

necesidad 1->; siguiente = necesidad 2- gt; siguiente = NULL

necesidad 1->; valor-allocatemp- gt; valor;

estado;

}

Otro

{

necesita 2 =(struct need *)malloc(needlen);

necesita valor =(maxtemp- gt; valor)-(alloct EMP- gt; valor);

if (estado==1)

{

necesidad- gt; siguiente = necesidad2

estado;

}

necesidad 1->; siguiente = necesidad2

necesidad 1 = necesidad 2;

}

temperatura máxima = temperatura máxima-gt;<

/p>

alloctemp = alloctemp- gt; siguiente;

}

necesita 2->; siguiente = NULL

estado = 0;

for(I = 0; i lt fila; i )

{

if (estado == 0)

{

fini head = finalizar 1 = finalizar 2 =(struct finalizar *)malloc(finilen);

finalizar 1->; siguiente = finalizar 2- gt; siguiente = NULL

finalizar 1->;stat = 0;

estado;

}

Otro

{

finalizar 2 =(estructura finalizar *)malloc(finilen);

Completar 2->stat = 0;

if(status==1)

{

fini head- gt; siguiente = finalizar2

status;

}

finalizar 1->; p>

finalizar 1 = finalizar 2;

}

}

Finalizar 2->siguiente = NULL/*Inicialización completada*/

estado = 0;

prueba de proceso = 0;

for(temp = 0;temp lt fila;temp)

{

alloctemp = allochead

needtemp = needhead

finishtemp = finihead

worktemp = workhead

for(I = 0; i lt fila; i )

{

Temperatura de funcionamiento 1 = temperatura de funcionamiento

if(finish temp- gt; stat==0)

{

for(j = 0; j ltcolumj, necesita temperatura = necesita temp- gt; siguiente, temperatura de funcionamiento = temperatura de funcionamiento- gt; siguiente)

if( necesita temp- gt valor lt=temperatura de funcionamiento- gt; valor)

prueba de proceso;

if(prueba de proceso==colum)

{

for(j = 0; j ltcolumj )

{

worktemp1->valor = asignar valor EMP-gt

temperatura de funcionamiento 1; = temperatura de funcionamiento 1->; siguiente;

alloctemp = alloctemp- gt;

}

if (estado == 0 )

{

camino de ruta = ruta 1 = ruta 2 =(ruta de estructura *)malloc(ruta len);

ruta 1->; siguiente = ruta 2- gt; siguiente = NULL

ruta 1->; valor = I;

estado;

}

Otros

{

ruta 2 =(estructura ruta *)malloc(ruta len);

ruta2->valor = I ;

if(estado==1)

{

cabecera de ruta->; siguiente = ruta2

estado;

}

ruta 1->; siguiente = ruta2

ruta 1 = ruta 2;

}

finalizar temp - gt; estadística = 1;

}

Otro

{

for(t = 0; t ltcolumt )

alloctemp = alloctemp- gt; siguiente;

finalizar temp- gt;

}

}

< p; >Otro

for(t = 0; t ltcolumt )

{

necesita temp = necesita temp- gt siguiente;

alloctemp = alloctemp- gt; siguiente;

}

prueba de proceso = 0;

worktemp = cabezal de trabajo

finalizar temperatura = finalizar temperatura - gt; siguiente;

}

}

ruta2->siguiente = NULL

finishtemp = finihead

for(temp = 0; temp lt fila; temp)

{

if(finish temp- gt; stat==0)

{

printf("\n¡El sistema está en un estado inseguro!\n");

Salir(0);

}

finalizar temp = terminar temp- gt; Siguiente;

}

printf("\nEl sistema está en un estado seguro.\n");

printf( "\nLa secuencia segura es:\n");

Hacer

{

printf("pd", ruta head-gt; valor);

}

while(encabezado de ruta = encabezado de ruta- gt; siguiente);

printf(" \ n ");

Return 0 ;

}

Además, existen productos de compra grupal en el grupo de webmasters, que son económicos y garantizados.

上篇: Hotel Wang Hongbo 下篇:
Artículos populares