Si el mismo BCP aparece referenciado dos veces en la cola de preparados, el proceso en cuestión será tratado dos veces en una rueda de turnos, con lo que tenderá a disfrutar del doble de tiempo de CPU respecto a los demás procesos. Por tanto, el proceso que aparece por duplicado tiene más prioridad de uso de CPU que el resto.
Un efecto idéntico puede lograrse insertando el BCP del proceso no al final de la cola de preparados, sino en medio de ella: así se le volverá a atender antes.
La solución es
const W:integer = ...;
acumulado: shared integer = 0;...trabaja con el fichero ...procedure Accede_fichero ( int peso: integer );
begin
region acumulado when acumulado + peso < W do
acumulado := acumulado + peso;
region acumulado do acumulado := acumulado - peso;
end;Para trabajar con el fichero, el proceso pi haría:
Accede_fichero (wi);
El vector de interrupciones jamás podría ser seleccionado como víctima, ya que en él aparecen todos los punteros a las rutinas gestoras de interrupción. Si se escogiera como víctima, se perderían estos punteros y no se podría atender ninguna interrupción o excepción, incluida la de gestión de fallos de página.
Realmente es correcta la afirmación. Si se distribuye el espacio de intercambio entre dos discos, se puede optimizar el trasiego de páginas, de manera que mientras el sistema está transfiriendo una página entre un disco y la memoria, puede tramitar una transferencia de otra página en el otro disco duro. Es decir, se pueden solapar las actividades de E/S de ambos discos. De esta manera, si hay que enviar al swap a un proceso completo, la mitad de las páginas se pueden transferir a un disco, y la otra mitad al otro, operando en paralelo. El tiempo total de estas operaciones es mucho menor que si sólo trabajáramos con un disco.
SI ( error de apertura ) ENTONCES retornar error1;
Obtener tamaño del fichero;
Leer en BLOQ los primeros 512 bytes del fichero;
SI (( BLOQ[0] = "M" ) Y (BLOQ[1] = "Z") ) ENTONCES /* Programa tipo EXE */
Calcular tamaño de los segmentos;
Obtener memoria; /* f(MINALLOC,MAXALLOC) */
SI (memoria insuficiente) ENTONCES retornar error2;
Construir ambiente del proceso hijo;
Construir PSP del procesos hijo;
Inicializar registros ES, DS a la dirección de comienzo del PSP;
SI NO /* Se trata de un programa COM */
Asignar toda la memoria disponible;
Construir ambiente del proceso hijo;
Construir PSP del procesos hijo;
Cargar programa;
Inicializar registros CS, DS, ES, SS a la dirección de comienzo del PSP;
Inicializar SP al valor más alto permitido;
FIN SI
Ceder control al proceso hijo;
(*) Sustituir A0 también sería válido.
(**) Sustituir 90 o 80 también sería válido.
(***) Sustituir E5 o 90 también sería válido.
Una posible solución es:
/* Vector auxiliar utilizado en la función de detección */
intTrabajo[NUM_RECU];/* Vector auxiliar utilizado en la función de detección */
intFin[NUM_PROC];
int deteccion( )
/* Retona HAY_INTERBLOQ si existe un estado de interbloqueo */
/* Retorna NO_HAY_INTERBLOQ si no existe inerbloqueo */
{
int i, j;
/* Inicializamos vectores auxiliares */
for (i=0; i<NUM_REC; i++) {
Trabajo[i] = Disponible[i];
}
for (i=0; i<NUM_PROC; i++) {
Fin[i] = VERDADERO;
for (j=0; j<NUM_REC; j++)
if ( Asignado[i][j] ) {
FIN[i] = FALSO;
break;
}
}
/* Búsqueda de ciclos que impliquen interbloqueo */
nuevo = FALSO;
do {
for (i=0; i<NUM_PROC; i++) {
if ( Fin[i] == FALSO ) {
if ( Solicita[i] != -1 )
if ( !Trabajo[Solicita[i]] ) continue;
FIN[i] = VERDADERO;
for (j=0; j<NUM_REC; j++)
Trabajo[j] += Asignado[i][j];
nuevo=VERDADERO;
break;
}
}
}While ( nuevo == VERDADERO );
/* Preguntamos si todos los procesos están marcados; si no entonces interbloqueo */
for (i=0; i<NUM_PROC; i++)if ( Fin[i] == FALSO ) return( HAY_INTERBLOQUEO);
return(NO_HAY_INTERBLOQEO);
}/* Final de la función */
Pregunta |
Opción correcta |
1 |
a |
2 |
d |
3 |
b |
4 |
b |
5 |
a |
6 |
a |
7 |
c |
8 |
c |
9 |
d |
10 |
a |