Escribir la tarea del sistema operativo en lenguaje C o C: Algoritmo bancario
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; >Otrofor(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.