P. 1
SISTEMAS_OPERATIVOS

SISTEMAS_OPERATIVOS

|Views: 186|Likes:
Publicado porFernando Acuña

More info:

Published by: Fernando Acuña on Dec 10, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

06/13/2013

pdf

text

original

UNIVERSIDAD PERUANA LOS ANDES

FACULTAD DE INGENIERÍA

SISTEMAS OPERATIVOS

MG. ABRAHAM ESTEBAN GAMARRA MORENO

CONTENIDO
CONTENIDO ..........................................................................................................................................2 PRESENTACION ...................................................................................................................................7 UNIDAD ACADEMICA 1 ......................................................................................................................9 INTRODUCCION A LOS SISTEMAS OPERATIVOS ......................................................................9 1.1. ¿QUÉ ES UN SISTEMA OPERATIVO? ...............................................................................9 1.2. HISTORIA DE LOS SISTEMAS OPERATIVOS: GENERACIONES ...............................12 1.2.1. Generación Cero (década de 1940): ...............................................................................12 1.2.2. Primera generación (1945-1955): bulbos y conexiones ..................................................13 1.2.3. Segunda generación (1955-1965): transistores y sistemas de procesamiento por lotes (batch) 13 1.2.4. Tercera generación (1965-1980): circuitos integrados y multiprogramación ................13 1.2.5. Cuarta generación (1980-1990): computadoras personales:..........................................14 1.3. CONCEPTOS DE LOS SISTEMAS OPERATIVOS ...........................................................15 1.3.1. Procesos...........................................................................................................................15 1.3.2. Archivos:..........................................................................................................................16 1.3.3. Llamadas al sistema: .......................................................................................................16 1.4. ESTRUCTURA DE LOS SISTEMAS OPERATIVOS ........................................................16 1.4.1. Sistemas monolíticos: ......................................................................................................17 1.4.2. Sistemas con capas: .........................................................................................................18 1.4.3. Máquinas virtuales: .........................................................................................................20 1.4.4. Modelo cliente - servidor.................................................................................................21 1.5. MÁS ESTRUCTURAS DE SISTEMAS OPERATIVOS.....................................................22 1.5.1. El sistema operativos DOS ..............................................................................................23 1.5.2. El sistema operativo UNIX ..............................................................................................23 1.6. EL SISTEMA OPERATIVO OS/2 .......................................................................................24 1.6.1. Arquitectura de Windows NT...........................................................................................25 RESUMEN ............................................................................................................................................27 INDICADORES DE LOGRO ......................................................................................................................27 BIBLIOGRAFÍA RECOMENDADA ...........................................................................................................27 NEXO ...................................................................................................................................................28 ACTIVIDAD ..........................................................................................................................................28 AUTO EVALUACIÓN FORMATIVA..........................................................................................................28 UNIDAD ACADEMICA 2 ....................................................................................................................29 PLANIFICACION DE PROCESOS....................................................................................................29 2.1. CONCEPTOS DE PLANIFICACIÓN .................................................................................29 2.1.1. COLAS DE PLANIFICACIÓN ........................................................................................31 2.1.2. Planificadores..................................................................................................................33 2.2. PLANIFICACIÓN DE LA UCP...........................................................................................35 2.2.1. Ciclo de ráfagas de UCP y de E/S ...................................................................................35 2.2.2. Planificador de la ucp......................................................................................................37 2.2.3. Estructura de planificación .............................................................................................37 2.2.4. Cambio de contexto .........................................................................................................38 2.2.5. Despachador....................................................................................................................39 2.3. ALGORITMOS DE PLANIFICACIÓN...............................................................................39 2.3.1. Planificación “servicio por orden de llegada” ...............................................................41 2.3.2. Planificación “Primero el trabajo más breve” ...............................................................42 2.3.3. Planificación por prioridades..........................................................................................46
2 SISTEMAS OPERATIVOS

2.3.4. Planificación circular...................................................................................................... 48 2.3.5. Planificación de colas de múltiples niveles ..................................................................... 52 2.3.6. Planificación de colas de múltiples niveles con realimentación ..................................... 53 2.4. PLANIFICACIÓN DE PROCESADORES MÚLTIPLES................................................... 55 RESUMEN ............................................................................................................................................ 56 INDICADORES DE LOGRO ..................................................................................................................... 56 BIBLIOGRAFÍA RECOMENDADA ........................................................................................................... 56 NEXO................................................................................................................................................... 57 ACTIVIDAD .......................................................................................................................................... 57 AUTO EVALUACIÓN FORMATIVA ......................................................................................................... 57 UNIDAD ACADEMICA 3.................................................................................................................... 61 PROCESAMIENTO CONCURRENTE – PARTE 1......................................................................... 61 3.1. CONCEPTOS DE PROCESOS............................................................................................ 61 3.1.1. Definiciones de proceso................................................................................................... 61 3.1.2. Estados de un proceso ..................................................................................................... 62 3.1.3. Transiciones de estado de los procesos........................................................................... 62 3.1.4. El bloque de control de procesos..................................................................................... 63 3.1.5. Operaciones sobre procesos............................................................................................ 64 3.1.6. Suspensión y reanudación ............................................................................................... 65 3.1.7. El núcleo del sistema operativo ....................................................................................... 66 3.1.8. Resumen de funciones del núcleo. ................................................................................... 67 3.2. PROCESOS CONCURRENTES ASINCRÓNICOS. .......................................................... 68 3.2.1. Procesamiento en paralelo .............................................................................................. 68 3.2.2. Una estructura para indicar el paralelismo: cobegin/coend........................................... 69 3.2.3. Exclusión mutua .............................................................................................................. 70 3.2.4. Secciones críticas ............................................................................................................ 72 3.2.5. Primitivas de exclusión mutua......................................................................................... 73 3.2.6. Implementación de las primitivas de exclusion mutua .................................................... 74 3.2.7. Algoritmos de exclusión mutua: desarrollo intuitivo....................................................... 75 3.2.8. Algoritmo de Dekker........................................................................................................ 80 RESUMEN ............................................................................................................................................ 85 INDICADORES DE LOGRO ..................................................................................................................... 85 BIBLIOGRAFÍA RECOMENDADA ........................................................................................................... 85 NEXO................................................................................................................................................... 85 ACTIVIDAD .......................................................................................................................................... 85 AUTO EVALUACIÓN FORMATIVA ......................................................................................................... 86 UNIDAD ACADEMICA 4.................................................................................................................... 89 PROCESAMIENTO CONCURRENTE – PARTE 2......................................................................... 89 4.1. EXCLUSION MUTUA DE N-PROCESOS......................................................................... 89 4.1.1. Algoritmo de dijkstra. ...................................................................................................... 89 4.1.2. Algoritmo de Lamport ..................................................................................................... 91 4.2. SEMÁFOROS ...................................................................................................................... 93 4.2.1. Sincronización de procesos con semáforos ..................................................................... 94 4.2.2. Bloqueos mutuos y bloqueos indefinidos ......................................................................... 96 4.2.3. La relación productor - consumidor................................................................................ 98 4.2.4. Semáforos contadores.................................................................................................... 101 4.3. PROGRAMACIÓN CONCURRENTE ............................................................................. 101 4.4. PROBLEMAS CLÁSICOS. ............................................................................................... 102 4.4.1. El problema de los filósofos comelones......................................................................... 102 4.4.2. El barbero dormilón ...................................................................................................... 106 RESUMEN .......................................................................................................................................... 109 INDICADORES DE LOGRO ................................................................................................................... 110 BIBLIOGRAFÍA RECOMENDADA ......................................................................................................... 110
Mg. Abraham Gamarra Moreno 3

NEXO .................................................................................................................................................110 ACTIVIDAD ........................................................................................................................................110 AUTO EVALUACIÓN FORMATIVA........................................................................................................110 UNIDAD ACADEMICA 5 ..................................................................................................................113 ADMINISTRACIÓN DE LA MEMORIA: ALMACENAMIENTO REAL..................................113 5.1. INTRODUCCIÓN AL ALMACENAMIENTO REAL......................................................113 5.2. JERARQUÍA DE ALMACENAMIENTO .........................................................................114 5.3. ESTRATEGIAS DE ADMINISTRACIÓN DEL ALMACENAMIENTO.........................115 5.4. ASIGNACIÓN CONTIGUA DE ALMACENAMIENTO VERSUS NO CONTIGUA.....116 5.5. ASIGNACIÓN CONTIGUA DE ALMACENAMIENTO DE UN SOLO USUARIO.......116 5.6. MULTIPROGRAMACIÓN DE PARTICIÓN FIJA ..........................................................117 5.6.1. Multiprogramación de Partición Fija: Traducción y Carga Absolutas ........................117 5.6.2. Multiprogramación de Partición Fija: Traducción y Carga Relocalizables.................118 5.6.3. Protección en los Sistemas de Multiprogramación .......................................................119 5.6.4. Fragmentación en la Multiprogramación de Partición Fija .........................................120 5.7. MULTIPROGRAMACIÓN DE PARTICIÓN VARIABLE ..............................................121 5.7.1. Combinación de agujeros (áreas libres)........................................................................122 5.7.2. Compresión o Compactación de Almacenamiento ........................................................122 5.7.3. Estrategias de Colocación del Almacenamiento............................................................123 RESUMEN ..........................................................................................................................................127 INDICADORES DE LOGRO ....................................................................................................................127 BIBLIOGRAFÍA RECOMENDADA .........................................................................................................127 NEXO .................................................................................................................................................128 ACTIVIDAD ........................................................................................................................................128 AUTO EVALUACIÓN FORMATIVA........................................................................................................128 UNIDAD ACADEMICA 6 ..................................................................................................................131 ADMINISTRACIÓN DE LA MEMORIA: ALMACENAMIENTO VIRTUAL...........................131 6.1. INTRODUCCIÓN A LA ORGANIZACIÓN DEL ALMACENAMIENTO VIRTUAL ...131 6.2. CONCEPTOS BÁSICOS DE ALMACENAMIENTO VIRTUAL ....................................132 6.3. ORGANIZACIÓN DEL ALMACENAMIENTO DE NIVELES MÚLTIPLES ................134 6.4. TRANSFORMACIÓN DE BLOQUES ..............................................................................134 6.5. CONCEPTOS BÁSICOS DE PAGINACIÓN....................................................................137 6.5.1. Traducción de Direcciones de Paginación por Transformación Directa......................138 6.5.2. Traducción de Direcciones de Paginación por Transformación Asociativa .................141 6.5.3. Traducción de Direcciones de Paginación por Combinación de Transformación Asociativa / Directa .....................................................................................................................142 6.5.4. Compartimiento de Recursos en un Sistema de Paginación..........................................144 6.6. SEGMENTACIÓN.............................................................................................................145 6.6.1. Control de Acceso en Sistemas de Segmentación ..........................................................148 6.6.2. Traducción de Direcciones de Segmentación por Transformación Directa..................149 6.6.3. Compartimiento en un Sistema de Segmentación ..........................................................151 6.7. SISTEMAS DE PAGINACIÓN / SEGMENTACIÓN .......................................................151 6.7.1. Traducción Dinámica de Direcciones en Sistemas de Paginación / Segmentación ......152 6.7.2. Compartimiento en un Sistema de Paginación/Segmentación.......................................154 6.8. ADMINISTRACION DEL ALMACENAMIENTO VIRTUAL ........................................156 6.8.1. Estrategias de Administración del Almacenamiento Virtual .........................................156 6.8.2. Estrategias de Reposición (reemplazo) de Página ........................................................157 RESUMEN ..........................................................................................................................................163 INDICADORES DE LOGRO ....................................................................................................................164 BIBLIOGRAFÍA RECOMENDADA .........................................................................................................164 NEXO .................................................................................................................................................164 ACTIVIDAD ........................................................................................................................................164
4 SISTEMAS OPERATIVOS

.............2........................................................PARTE 1 ..................................... 164 UNIDAD ACADEMICA 7............................... ADMINISTRACIÓN DEL ESPACIO EN DISCO ......... 194 8............... Manejo de un bloque defectuoso: .....................................................................................................................2...................................... Dominios de Protección ...3.........2....................................2............................... Implantación de Archivos................................. 173 7............................2...................................................................................................................................................5.......1... 188 RESUMEN ............................. EL SISTEMA DE ARCHIVOS ............... 202 8............................... Virus ............................................4..................................................5...................... 169 7......................... Acceso a un Archivo ....... 167 7...................................... 205 8................................................................................................. Sistemas Jerárquicos de Directorios ..........................4.................................................................... 191 SISTEMA DE ARCHIVOS ...................4..........................................................................................................................1...........................................................................4.............................................3................. 196 8...............................................5...................................................................... FUNCIONES DEL SISTEMA DE ARCHIVOS ..................................................................................................................................2...... Tamaño del bloque: .................................................................................... 191 8........................5................ Registro de los bloques libres: .......................................PARTE 2 ..................2......................... 210 RESUMEN ... Consistencia del sistema de archivos: .......................................... 187 7.3...........2....3........................................ ARCHIVOS .....................2........................... 191 8.................................3........................ 199 8..........................5........ CONFIABILIDAD DEL SISTEMA DE ARCHIVOS ................................ Listas Para Control de Acceso ......1...................................3.....................................4.......................... 205 8................................................. 189 BIBLIOGRAFÍA RECOMENDADA ............... 170 7...........6.........................3..... 180 7.7. Nombre de las Rutas de Acceso.............7.......... 207 8........ 172 7................................ Disk quotas ....... INTRODUCCIÓN......................................... Operaciones con Directorios.... IMPLANTACIÓN DEL SISTEMA DE ARCHIVOS Y SUS RELACIONES CON LA ASIGNACIÓN Y LIBERACIÓN DE ESPACIO ...........................AUTO EVALUACIÓN FORMATIVA ...1...... Operaciones con Archivos......... 170 7.........................5. El Ambiente de Seguridad ............................................ Tipos de Archivos .......................................... Abraham Gamarra Moreno 5 ..................................................................................................... ARCHIVOS COMPARTIDOS ..................... Archivos Mapeados a Memoria........ 197 8....... 167 SISTEMA DE ARCHIVOS .........................1.......... 175 7.............................................................................. 211 ACTIVIDAD . 208 8.............................. Estructura de un Archivo....................... 197 8................................................4.................................... 174 7............. 190 UNIDAD ACADEMICA 8........ 168 7.. 167 7.2.............................................. 172 7........................1..............4..................... 211 AUTO EVALUACIÓN FORMATIVA .........6.............. Respaldos (copias de seguridad o de backup):....................................5........................................................4................ 190 AUTO EVALUACIÓN FORMATIVA .................................. DESEMPEÑO DEL SISTEMA DE ARCHIVOS ....1........2............. MECANISMOS DE PROTECCIÓN .............................................. 175 7....................................... 207 8...6............ Principios del Diseño Para la Seguridad ............. 189 NEXO..........................................7................3............................................ 178 7................................................................................................... 211 Mg.............1...........6........................ Nombre de los Archivos........................................................................................... 208 8............................................................................................... 198 8.............5..................... 170 7...............................................6.................................... 211 INDICADORES DE LOGRO .................................................3.........................................................................1...............................4............................. 195 8... 189 ACTIVIDAD ......................................................................................6...................................................... 189 INDICADORES DE LOGRO ...... DIRECTORIOS ............... Directorios en MS-DOS........................................................................................3...............................................................................................1.............................................4............................................................................................. IMPLANTACIÓN DE DIRECTORIOS ......................................................... 180 7............ Atributos de Archivo...............................................................................5............................. 194 8....................................................................................................................... SEGURIDAD....................................................... 179 7................................................................................................................. 211 BIBLIOGRAFÍA RECOMENDADA ................................................................................................ 176 7...........................

6 SISTEMAS OPERATIVOS .

el cuál nos permite realizar y modificar la implementación de los Sistemas Operativos. Este libro que se pone a disposición de los estudiantes sigue el segundo punto de vista. este sistema explota los recursos del hardware. El autor. el primero muestra al sistema operativo como una máquina virtual. Existen dos puntos de vista para conocer el funcionamiento de los Sistemas Operativos. ofrece un conjunto de servicios a los usuarios del sistema. Abraham Gamarra Moreno 7 . El segundo punto de vista es conocer a los Sistemas Operativos a través del analisis de sus algoritmos de implementación. donde se realiza un análisis de cómo se implementan los Sistemas Operativos en la administración de procesos.PRESENTACION Todos los computadores ejecutan sus programas sobre un Sistema Operativo. sobre todo los de código liberado. de uno o más procesadores. Mg. administración de la memoria y la administración de los sistemas de archivos. gestiona la memoria secundaria y los dispositivos de E/S. donde el usuario utiliza el Sistema Operativo para administrar todos los recursos que existen en el sistema de cómputo.

8 SISTEMAS OPERATIVOS .

1. En este contexto. O. protege y libera a los programadores de la complejidad del hardware. O.UNIDAD ACADEMICA 1 INTRODUCCION A LOS SISTEMAS OPERATIVOS 1. O. colocándose un nivel de software por sobre el hardware para: • Controlar todas las partes del sistema. Programas de aplicación: Resuelven problemas para los usuarios. en el conjunto del software para computadoras. podemos clasificar a este de la siguiente manera: • • Programas de sistema: Controlan la operación de la computadora en sí. ¿QUÉ ES UN SISTEMA OPERATIVO? Una de las definiciones más comúnmente aceptadas expresa: “Un Sistema Operativo (S. el Sistema Operativo es el programa fundamental de todos los programas de sistema. El S. A los efectos de situar a los S. 9 Mg. El objetivo primario de un Sistema Operativo es optimizar todos los recursos del sistema para soportar los requerimientos.) es un grupo de programas de proceso con las rutinas de control necesarias para mantener continuamente operativos dichos programas”. Abraham Gamarra Moreno .

• • • Respecto del lenguaje de máquina es preciso señalar que: • Generalmente posee entre 50 y 300 instrucciones. El conjunto de instrucciones que interpreta define al lenguaje de máquina. editores. Busca las instrucciones de lenguaje de máquina para ejecutarlas como una serie de pequeños pasos. O. microprogramación y los dispositivos físicos. 10 SISTEMAS OPERATIVOS . • Una de las principales funciones del S. El S. con máxima prioridad y generalmente con protección por hardware. dispuestos ya sea en el software o en la memoria fija (microcódigo). hacer operaciones aritméticas y comparar valores. reservaciones en una línea aérea. etc. juegos. intérpretes de comandos y el Sistema Operativo. editores y demás programas se ejecutan en modo usuario. O. El S. Programas de sistema: Compiladores. es ocultar toda esta complejidad y brindar al programador un conjunto más conveniente de instrucciones para trabajar. Los compiladores.• Presentar al usuario una interfaz o máquina virtual. En ciertas máquinas se implanta en el hardware y no es en realidad una capa distinta. que hacen al hardware utilizable. El esquema típico de un sistema de cómputos incluye: • Programas de aplicación: Sistema bancario. • • Las principales características del microprograma son: • Se trata de software que generalmente se localiza en la memoria de solo lectura. se ejecuta en modo central o modo de supervisión. es la serie de programas. O. Los dispositivos de e / s (entrada / salida) se controlan al cargar valores en registros del dispositivo especiales. Hardware: Lenguaje de máquina. sirviendo la mayoría para desplazar datos.

Figura 1. Mg. Permitir a los usuarios compartir los datos entre ellos. O. siendo el recurso primario el hardware del sistema (ver Figura 1.O. Los S. son: • • • • • Definir la “Interfaz del Usuario”. Deitel M. ponen el “poder computacional básico” del hardware convenientemente a disposición del usuario.1. pero consumen parte de ese poder computacional para funcionar. administradores de recursos. Las principales características de los S. Planificar recursos entre usuarios. O. España: Addison Wesley Iberoamericana. Facilitar la entrada / salida. Recursos administrados por el S. Abraham Gamarra Moreno 1 11 . 1998. Introducción a los Sistemas Operativos.Según Deitel1 los S. Segunda Edición. son. en primer lugar.1). O. Compartir el hardware entre usuarios.

son: • • • • Procesadores. Hardware. Dispositivos de e / s.• Recuperarse de los errores. son una interfaz con: • • • • • • Operadores. Los S.1. Usuarios. HISTORIA DE GENERACIONES LOS SISTEMAS OPERATIVOS: Los S. El S. han estado relacionados históricamente con la arquitectura de las computadoras en las cuales se ejecutan. O. debe presentar al usuario el equivalente de una máquina extendida o máquina virtual que sea más fácil de programar que el hardware subyacente.2. O.). O. Programas. Programadores de aplicaciones. 1. Almacenamiento. Los principales recursos administrados por los S.2. 1. GENERACIÓN CERO (DÉCADA DE 1940): • • Carencia total de S. O. 12 SISTEMAS OPERATIVOS . O. Datos. O. Completo acceso al lenguaje de máquina. razón por la cual su historia puede analizarse según las generaciones y sus principales características1. Programadores de sistemas (administradores del S.

1. PRIMERA GENERACIÓN CONEXIONES • • Carencia de S.2.4. Aparición de técnicas de spooling: o Simultaneous Peripheral Operation On Line: operación simultánea y en línea de periféricos. 1. O.2. o Aprovechamiento del tiempo de espera consecuencia de operaciones de e / s. Abraham Gamarra Moreno 13 .2. • • Protección por hardware del contenido de cada partición de memoria.2. TERCERA GENERACIÓN (1965-1980): CIRCUITOS INTEGRADOS Y MULTIPROGRAMACIÓN • Difusión de la multiprogramación: o Partición de la memoria en porciones. O. con trabajos distintos en cada una de ellas. Mg. para utilizar la CPU para otros procesos. SEGUNDA GENERACIÓN (1955-1965): TRANSISTORES Y SISTEMAS DE PROCESAMIENTO POR LOTES (BATCH) • En los años sesenta aparecen los S. o Multiprocesamiento: varios procesadores se utilizan en un mismo sistema para incrementar el poder de procesamiento. (1945-1955): BULBOS Y En los años cincuenta comienzan como transición entre trabajos.3. cambiando el procesador rápidamente de un trabajo a otro. o El S. 1. para sistemas compartidos con: o Multiprogramación: varios programas de usuarios se encuentran al mismo tiempo en el almacenamiento principal. O. asigna los dispositivos correspondientes según los requerimientos y las disponibilidades. • Posteriormente aparece la independencia de dispositivo: o El programa del usuario especifica las características de los dispositivos que requieren los archivos. haciendo la misma más simple.

O. Interponen una capa de software entre el usuario y el hardware. es decir que deben soportar sistemas de propósitos generales. que requieren tiempos de respuesta muy exigentes. aún cuando de soporte a varios procesadores.5. O. o Cada máquina ejecuta su propio S. Soportan timesharing (tiempo compartido). destinado a usuarios no profesionales y con una interfase gráfica muy desarrollada. o Son similares a los S. Aparecen los lenguajes de control de trabajos. variante de la multiprogramación con usuarios conectados mediante terminales en línea. • • • • • 1. • • 14 SISTEMAS OPERATIVOS . para disminuir el impacto de los periféricos más lentos. necesarios para especificar el trabajo y los recursos requeridos. permitiendo la operación en modo interactivo o conversacional. Desarrollo de sistemas operativos de red y sistemas operativos distribuidos. de un solo procesador pero con el agregado de controlador de interfaz de la red. • Sistemas operativos distribuidos: o Aparece ante los usuarios como un S. • Son sistemas de modos múltiples. son grandes y complejos pero muy poderosos.2. local. Aparecen los sistemas de tiempo real. CUARTA GENERACIÓN (1980-1990): COMPUTADORAS PERSONALES: • Aparición de software amigable con el usuario. especialmente para usos industriales o militares. Sistemas operativos de red: o Los usuarios están conscientes de la existencia de varias computadoras conectadas. O. su software de bajo nivel y el software para conexión y acceso a archivos remotos. etc. Se difunden las computadoras de rango medio. de un solo procesador.o Almacenamiento de trabajos de entrada y de salida en dispositivos transitorios rápidos (discos).

Segunda Edición. Gran énfasis en la seguridad. O. accesibles mediante redes de comunicación.3. • 2 • Un proceso (suspendido) consta de: Tanenbaum A.1. Consta del programa ejecutable. o Deben permitir que un programa se ejecute mediante varios procesadores a la vez. O. Sistemas Operativos Modernos. crea un ambiente de trabajo según el concepto de máquina virtual. O. maximizando el paralelismo. automáticamente. O. O. o Posee un arreglo de estructuras. y los programas del usuario se define como el conjunto de “instrucciones ampliadas” que proporciona el S. eliminan y utilizan objetos del software controlados por el S. El S. • • • 1.: Los más importantes son procesos y archivos. en especial por el desarrollo de los sistemas de comunicaciones de datos. PROCESOS • • • Es el concepto central de todos los S. Abraham Gamarra Moreno 15 . La información de control relacionada con los procesos se almacena en la tabla de procesos: o Es administrada por el S. una por cada proceso existente en ese momento. O. Es básicamente un programa en ejecución. Proliferación de sistemas de bases de datos. y son las “llamadas al sistema”:2 • Crean. Mexico: Pearson Educación. además de la información necesaria para ejecutar el programa. contador y otros registros. O. que lo aísla del funcionamiento interno de la máquina. CONCEPTOS DE LOS SISTEMAS OPERATIVOS La interfaz entre el S. Mg. 2003. sus datos y pila. • Aparición de emuladores de terminal para el acceso a equipos remotos desde computadoras personales (PC). 1.3. ya que lo debe administrar el S.o Los usuarios no son conscientes del lugar donde se ejecutan sus programas o donde se encuentran sus archivos.

coloca un código de estado en un registro indicando si tuvo éxito o fracaso y ejecuta una instrucción del tipo “return from trap” para regresar el control al procedimiento. y conforme a ella se los clasifica de la siguiente manera. 1. O. recupera el control . ARCHIVOS: • Una de las funciones principales del S. Muchos S. o Luego de terminar. examina los parámetros y si son válidos ejecuta el trabajo solicitado.3. A cada llamada le corresponde un procedimiento: o Pone los parámetros de la llamada en un lugar especí…co para luego ejecutar una instrucción tipo “trap” de llamada a procedimiento protegido para iniciar el S. O.o Un espacio de dirección. O. ESTRUCTURA DE LOS SISTEMAS OPERATIVOS Se considera la organización interna de los S. O. O. o El procedimiento regresa al programa llamador con un código de estado como un valor de función. por lo que a cada archivo le corresponde una ruta de acceso. Los directorios se estructuran jerárquicamente. • Un proceso puede crear procesos hijo y estos nuevos procesos hijo. dentro de los parámetros pueden regresar valores adicionales.3. O. • • • 1. conformando un árbol de procesos. destacándose sus principales características: 16 SISTEMAS OPERATIVOS . Existen distintos esquemas de seguridad de archivos en los distintos S.4. O. o Luego de “trap” el S. 1. soportan el concepto de directorio como una forma de agrupar archivos. el S. O. LLAMADAS AL SISTEMA: • • Permiten a los programas comunicarse con el S.2. o Los datos pertinentes de la tabla de procesos. y solicitarle servicios.3. es brindar independencia de dispositivo.

1.2. El S. Figura 1. (llamadas al sistema)2: (ver Figura 1. • Cada procedimiento tiene una interfaz bien definida en términos de parámetros y resultados.3.3).1. o Se solicitan colocando los parámetros en lugares bien definidos (registros o pilas). SISTEMAS MONOLÍTICOS: • • Es muy común: no existe estructura propiamente dicha o es mínima. O. es una colección de procedimientos que se pueden llamar entre sí (ver Figura 1. Mg.4. Abraham Gamarra Moreno 17 . Modelo de estructura simple para un sistema monolítico. Forma de llamada al sistema en un sistema monolítico.22). Figura 1. • Para ejecutar los servicios del S. O.

• Capa 0: o Trabaja con la asignación del procesador. o El S. o El S. como una jerarquía de capas. analiza una tabla que contiene en la entrada “k” un apuntador al procedimiento que realiza la “k-ésima” llamada al sistema: o Identifica al procedimiento de servicio llamado. Consiste en organizar el s. O. • El primer sistema con este esquema fue el “THE” (Holanda .1). o La instrucción cambia la máquina del modo usuario al modo núcleo (o modo supervisor)2. • • Proporciona la multiprogramación básica. O. examina los parámetros de la llamada para determinar cuál de ellas se desea realizar. o Asegura que las páginas (porciones de memoria) requeridas de los procesos lleguen a memoria cuando fueran necesarias. Capa 1: o Administra la memoria. o La llamada al sistema termina y el control regresa al programa del usuario.4. o. o Se transfiere el control al S. 18 SISTEMAS OPERATIVOS . cada una construida sobre la inmediata inferior. o Alterna entre los procesos cuando ocurren las interrupciones o expiran los cronómetros.o Se ejecuta una instrucción especial de trampa: llamada al núcleo o llamada al supervisor.Dijkstra -1968)2: (ver Tabla 1.2. SISTEMAS CON CAPAS: • Es una generalización del modelo de estructura simple para un sistema monolítico. “THE”: Technische Hogeschool Eindhoven. 1. O.

O.Operador 4 . o Los programas. memoria.Proceso 1 . del usuario no tienen que preocuparse por el proceso.Salida 2 . • Capa 5: o Localiza el proceso operador del sistema. • Capa 4: o Aloja los programas del usuario. o Por sobre la capa 3 cada proceso puede trabajar con dispositivos abstractos de e / s en vez de con dispositivos reales. Abraham Gamarra Moreno . Bell Labs y General Electric): • “Multics”: multiplexed information and computing service.1. • Capa 3: o Controla los dispositivos de e / s y almacena en buffers los flujos de información entre ellos. cada proceso tiene su propia consola de operador.Control de Entrada .Programas del Usuario 3 . en capas “THE” 5 . 19 Mg.Asignación del Procesador y Multiprogramación • Capa 2: o Administra la comunicación entre cada proceso y la consola del operador. Estructura del S.Comunicaciones Operador . Una generalización mas avanzada del concepto de capas se presento con “Multics” (MIT.Tabla 1.Administración de la Memoria y del Disco 0 . consola o control de e / s. o Por sobre esta capa.

Un ejemplo de S. se muestra en la Figura 1.4. para llamar a un procedimiento de un anillo interior. La estructura de VM-370 con CMS. interrupciones y todo lo demás que posee una máquina real. Pueden ejecutar cualquier S. MÁQUINAS VIRTUALES: Se separan totalmente las funciones de multiprogramación y de máquina extendida. Figura 1.• Presenta una estructura en anillos concéntricos. y en general así lo hacen. Proporciona varias máquinas virtuales a la capa superior. que se ejecute en forma directa sobre el hardware. Un procedimiento de un anillo exterior. Existe un elemento central llamado monitor de la máquina virtual que: • • • Se ejecuta en el hardware. O. e / s. con su modo núcleo / usuario. • 1. debe hacer el equivalente a una llamada al sistema. O. O. Soportan periféricos virtuales. Las distintas máquinas virtuales pueden ejecutar distintos S. Realiza la multiprogramación. Las máquinas virtuales instrumentan copias “exactas” del hardware simple. siendo los interiores los privilegiados. representativo de esta estructura (“VM/370” de IBM2).4.3. 20 SISTEMAS OPERATIVOS .4.

O. a memoria. La Figura 1.4. “CMS” proporciona las instrucciones de e / s en hardware para la lectura del disco virtual o lo necesario para efectuar la llamada. MODELO CLIENTE . O. de manera similar al “VM/370”. no pasa directamente al “VM/370”. cada parte pequeña y más fácilmente controlable. Cuando un programa “CMS” ejecuta una llamada al sistema: • La llamada es atrapada por el S. en los procesos del usuario.servidor2.SERVIDOR Una tendencia en los S. a procesos. Abraham Gamarra Moreno 21 . a terminales.: lectura de un bloque de cierto archivo) según el modelo cliente . en partes. “CMS”: Conversational Monitor System. El proceso del usuario (proceso cliente) envía la solicitud a un proceso servidor: • • Realiza el trabajo y regresa la respuesta. el S.. Los servidores se ejecutan como procesos en modo usuario: • • No tienen acceso directo al hardware. Implantar la mayoría de las funciones del S. O. en su propia máquina virtual. etc. O. • • 1.5 muestra la solicitud de un servicio (por ej. cada una controlando una faceta: servicio a archivos.4. Mg. Se fracciona el S.Las VM generalmente utilizaran. O. El núcleo controla la comunicación entre los clientes y los servidores. “VM/370” atrapa estas instrucciones de e / s y las ejecuta sobre el hardware verdadero. Se aíslan y acotan más fácilmente los problemas. entre otros. modernos es la de explotar la idea de mover el código a capas superiores y mantener un núcleo mínimo.

Si un cliente se comunica con un servidor mediante mensajes: • No necesita saber si el mensaje se atiende localmente o mediante un servidor remoto. Se adapta para su uso en los sistemas distribuidos: (ver Figura 1.5.. MÁS ESTRUCTURAS DE SISTEMAS OPERATIVOS El sistema operativo se divide lógicamente en pequeños módulos y se crea una interfase bien definida para estos módulos.5. por ejemplo el cargado de comandos en los registros físicos del dispositivo de e / s. presentan problemas especiales y distintas soluciones: • Ejecución en modo núcleo.Figura 1. • 1. O.6. Envía una solicitud y obtiene una respuesta. • Algunas funciones del S.6). Figura 1. situado en otra máquina conectada. Construcción de un mínimo de mecanismos dentro del núcleo manteniendo las decisiones de política relativas a los usuarios dentro del espacio del usuario. El modelo cliente – servidor. El modelo cliente – servidor en un sistema distribuido. con acceso total al hardware y comunicación con los demás procesos mediante el mecanismo normal de mensajes. Cada uno de estos módulos o 22 SISTEMAS OPERATIVOS .

5. Abraham Gamarra Moreno 23 . por ello el sistema es vulnerable a estos programas los que pueden provocar el crash del sistema.2.1. 1. Lamentablemente este kernel combina demasiada funcionalidad en un solo nivel. La estructura de este sistema puede verse en la Figura 1. El kernel se encuentra divido en drivers de dispositivos y en las interfases (ver Figura 1. sus inputs y outputs cuidadosamente definidos. EL SISTEMA OPERATIVO UNIX Otro ejemplo de un sistema operativo que no fue bien construido lo constituye el UNIX. Este sistema se encuentra divido en dos partes una de ellas comprende los programas del sistema y la otra el kernel. Ambas definen el contexto al cual el kernel debe dar soporte.piezas deben tener su función. Las llamadas al sistema definen la interfase del programador al UNIX.7. El conjunto de programas de sistema usualmente disponibles definen la interfase del usuario.8). Mg. Estructura del sistema operativo DOS.5. Figura 1. EL SISTEMA OPERATIVOS DOS El sistema operativos DOS no cuenta con una buena división de estos módulos ya que no se encuentra bien particionado permitiendo el acceso directo de los programas de aplicación a rutinas básicas de E/S para grabar directamente en el display o en los discos.7. 1.

Figura 1. 1.8. no permiten el acceso directo del usuario a facilidades de bajo nivel lo que otorga un mayor control al sistema operativo sobre el hardware y un mayor conocimiento de qué recursos está utilizando cada programa de usuario.Otras mejoras posteriores al UNIX han separado el kernel en más módulos. El MACH de Carnegie-Mellon redujo el kernel a un conjunto pequeño de funciones básicas trasladando todo lo no esencial a los niveles del sistema o incluso al del usuario. por ejemplo en el sistema operativo AIX de IBM se lo dividió en dos partes. En la Figura 1. 24 SISTEMAS OPERATIVOS . El OS/2 provee multitasking y operación en modo dual como así también otras nuevas mejoras.6.9 podemos ver la estructura en capas del sistema operativo OS/2. Estructura del UNIX. EL SISTEMA OPERATIVO OS/2 El OS/2 un descendiente directo del MS-DOS fue creado para superar las limitaciones de este último. En contraposición a la estructura del MS-DOS la estructura del OS/2 se encuentra diseñada en capas que por ejemplo.

Antes sus sistemas operativos estaban basados en un modelo de 32-bits.9.Figura 1. Modo núcleo: Tiene acceso total a la memoria del sistema y los dispositivos externos. A partir de Windows XP. Todos tienen multitarea apropiativa y son sistemas operativos reentrantes que han sido diseñados para trabajar tanto con ordenadores con un sólo procesador como ordenadores de multiprocesamiento simétrico que en inglés es el Symmetrical Multi Processor o SMP. 25 • Mg. Una Capa de Abstracción de Hardware (HAL). Los núcleos de los sistemas operativos de esta línea son todos conocidos como núcleos híbridos. Windows Server 2003.1. ARQUITECTURA DE WINDOWS NT La familia de los sistemas operativos Windows NT de Microsoft está constituida por versiones como Windows Vista. 1. I/O) acude a una dirección de paquetes de E/S que utiliza peticiones (IRPs) y E/S asíncrona. Para procesar las peticiones de entrada/salida (en inglés Input/Output.10): • Modo usuario: Cuyos programas y subsistemas están limitados a los recursos del sistema a los que tienen acceso. Microsoft comenzó a desarrollar sistemas operativos que soportaban 64-bits. La arquitectura de Windows NT es altamente modular y se basa en dos capas principales (Figura 1. Abraham Gamarra Moreno .6. Windows XP. aunque hay que aclarar que este término está en discusión ya que este núcleo es esencialmente un núcleo monolítico que está estructurado al estilo de un micronúcleo. La arquitectura dentro del modo núcleo se compone de lo siguiente: • • Un núcleo híbrido. Estructura de capas del OS/2. Windows 2000 y Windows NT.

y el subsistema Integral (maneja funciones específicas de sistema de parte del subsistema de Entorno). Figura 1. El modo núcleo de la línea de Windows NT está compuesto por subsistemas capaces de pasar peticiones de E/S a los drivers apropiados usando el gestor de E/S. La arquitectura de Windows NT. Dos subsistemas crean la capa del modo usuario de Windows 2000: el subsistema de Entorno (ejecuta aplicaciones escritas para distintos tipos de sistemas operativos). El modo núcleo 26 SISTEMAS OPERATIVOS . Executive: Sobre el cual son implementados todos los servicios de alto nivel.10. El modo núcleo en Windows 2000 tiene acceso total al hardware y a los recursos del sistema del ordenador.• • Drivers.

Sistemas Operativos Modernos. Tanenbaum A. España: Addison Wesley Iberoamericana. Segunda Edición. El objetivo primario de un Sistema Operativo es optimizar todos los recursos del sistema para soportar los requerimientos. y envío de excepciones. El núcleo también es responsable de la inicialización de los drivers de dispositivos al arrancar. 1998. Indicadores de logro El lector explica los fundamentos de los Sistemas Operativos. O. El núcleo se sitúa entre la Capa de Abstracción de Hardware y el Executive para proporcionar sincronización multiprocesador. Segunda Edición. • Mg.) es un grupo de programas de proceso con las rutinas de control necesarias para mantener continuamente operativos dichos programas.impide a los servicios del modo usuario y las aplicaciones acceder a áreas críticas del sistema operativo a las que no deberían tener acceso. drivers intermedios y drivers de bajo nivel. WDM) se encuentra en la capa intermedia y fue diseñado principalmente para mantener la compatibilidad en binario y en código fuente entre Windows 98 y Windows 2000. El Executive se relaciona con todos los subsistemas del modo usuario. 2003. Mexico: Pearson Educación. Introducción a los Sistemas Operativos. Bibliografía Recomendada • Deitel M. la seguridad y la gestión de procesos. Los drivers de más bajo nivel también son un legado de los drivers de dispositivos de Windows NT que controlan directamente un dispositivo o puede ser un bus hardware PnP. Hay tres niveles de drivers en el modo núcleo: drivers de alto nivel. Se ocupa de la entrada/salida. El Modelo de Drivers de Windows (en inglés Windows Driver Model. hilos y programación y envío de interrupciones. la gestión de objetos. Resumen Un Sistema Operativo (S. Abraham Gamarra Moreno 27 .

Investigue sobre la arquitectura o estructura del sistema operativo LINUX. justifique su respuesta. 28 SISTEMAS OPERATIVOS . Actividad • • Amplie la información sobre la arquitectura de Windows NT. ¿cuál sería la arquitectura que usted recomendaría?. Auto evaluación formativa Supongamos que usted a sido designado para implementar un sistema operativo.Nexo La siguiente unidad académica analiza la planificación de procesos.

UNIDAD ACADEMICA 2
PLANIFICACION DE PROCESOS3
Un proceso es un programa que se está ejecutando y hoy en día los sistemas operativos tienen varios procesos en ejecución; por lo que se requiere realizar la planificación de la ejcución de estos procesos.

2.1. CONCEPTOS DE PLANIFICACIÓN
El objetivo de la multiprogramación es que en todo momento se ejecute un proceso para maximizar la utilización de la UCP (Unidad Central de Proceso). En un sistema monoprocesador nunca habrá más de un proceso en ejecución. Si hay más procesos, tendrán que esperar a que la UCP esté libre y pueda volver a planificarse. El concepto de multiprogramación es bastante sencillo: un proceso se ejecuta hasta que tenga que esperar, generalmente a que termine una solicitud de E/S. En un sistema de computación sencillo, la UCP permanecería inactiva; todo este tiempo de espera se desperdicia sin efectuar ninguna actividad útil. Con la multiprogramación tratamos de emplear productivamente este tiempo. Varios procesos se conservan en memoria a la vez, y cuando uno de ellos tiene que esperar, el sistema operativo le quita la UCP al proceso y se la da a otro; este modelo continúa. Cada vez que un proceso tiene que esperar, otro puede utilizar la UCP. Los beneficios de la multiprogramación son un aumento de la utilización de la UCP y una mayor productividad. La productividad es la cantidad de trabajo
3

Silberschatz A, Peterson J, Galvin P. Sistemas Operativos. USA: Editorial Addison Wesley Iberoamericana, 3ra Edición; 1994. Mg. Abraham Gamarra Moreno

29

desarrollada en un intervalo de tiempo (por ejemplo, 17 procesos por hora). Como ejemplo extremo, supongamos que tenemos dos procesos, P0 y P1 por ejecutar (Figura 2.1). Cada proceso se ejecuta durante un segundo, y luego espera otro segundo; este modelo se repite 60 veces. Si primero ejecutamos el proceso P0 y después el P1 uno tras otro, costaría cuatro minutos ejecutar ambos procesos (Figura 2.2); el proceso P0 tarda dos minutos en ejecutarse y el proceso P1 otros dos minutos, pero en realidad sólo se efectúan cálculos durante dos minutos, mientras que los otros dos representan tiempo inactivo. Así, nuestra utilización de la UCP es sólo del 50%.

Figura 2.1. Dos procesos, P0 y P1, listos para su ejecución. Si multiprogramamos los procesos P0 y P1 podemos mejorar en gran medida el rendimiento del sistema (

Figura 2.3). Comenzamos con el proceso P0 que se ejecuta durante un segundo; luego, mientras el proceso P0 espera durante otro segundo, ejecutamos el proceso P1. Mientras el proceso P1 espera, el P0 está listo para la ejecución. Ahora el tiempo transcurrido para la ejecución de ambos procesos es sólo dos minutos, y no hay tiempo inactivo de la UCP de manera que hemos mejorado su utilización del 50 al 100%, incrementando también la productividad. Observe que el proceso P0 no termina antes, pero ahora el proceso P1 finaliza en dos minutos.

30

SISTEMAS OPERATIVOS

Figura 2.2. Ejecución de procesos sin multiprogramación

Figura 2.3. Ejecución de procesos con multiprogramación.

Este ejemplo es un caso extremo y es poco probable que ocurra en la práctica, pero ilustra el concepto de la multiprogramación.

2.1.1. COLAS DE PLANIFICACIÓN
Conforme los procesos entran en el sistema, se colocan en una cola de trabajos formada por todos los procesos que residen en almacenamiento secundario esperando la asignación de la memoria principal. Los procesos que residen en la memoria principal y que están listos y esperando su ejecución se mantienen en una lista llamada cola de procesos listos; esta lista es generalmente una lista ligada. Un encabezado de la cola de procesos listos contendrá apuntadores al primer y último PCB de la lista. Cada PCB tiene un campo apuntador que indica el siguiente proceso en la cola de procesos listos.
También hay otras colas en el sistema. Cuando la UCP se asigna a un proceso, se ejecuta durante un tiempo y después termina o espera a que ocurra un suceso determinado, como la conclusión de una solicitud de E/S. En este caso, la E/S puede estar dirigida a una unidad de cinta dedicada o a un dispositivo compartido, por ejemplo un disco. Puesto que en el sistema hay varios procesos, el disco puede estar ocupado con la solicitud de E/S de otro proceso, por lo que el proceso tendrá que esperar al disco. La lista de procesos que espera a un dispositivo de E/S determinado se denomina cola del dispositivo, y cada dispositivo tiene su propia cola (

Figura 2.4). Si se trata de un dispositivo dedicado, como una unidad de cinta, la cola del dispositivo nunca tendrá más de un proceso. Si, por el contrario, el dispositivo se puede compartir, como es el caso de un disco, en la cola del dispositivo puede haber varios procesos. Una representación común para analizar la planificación de procesos es el diagrama de colas, como se muestra en la Figura 2.5. Cada rectángulo representa una cola, y hay dos tipos de colas: la cola de procesos listos y un conjunto de colas de dispositivo. Los círculos representan los recursos que dan servicio a las colas y las flechas indican el flujo de los procesos en el sistema.
Mg. Abraham Gamarra Moreno 31

Figura 2.4. Cola de procesos listos y varias colas de dispositivo de E/S.

Un proceso nuevo se coloca inicialmente en la cola de procesos listos y allí espera hasta que se selecciona para su ejecución y se le entrega la UCP; una vez que ésta se asigna al proceso y se ejecuta, puede ocurrir uno de estos sucesos: • El proceso puede emitir una solicitud de E/S y colocarse en una cola de dispositivo. El proceso puede crear un nuevo proceso y esperar a que éste termine. El proceso podría ser extraído de la UCP por la fuerza, como resultado de una interrupción, y colocarse de nuevo en la cola de procesos listos.

• •

En los dos primeros casos, el proceso cambia eventualmente del estado de espera al estado de listo y se coloca de nuevo en la cola de procesos listos. Un proceso continúa con este ciclo hasta que termina, y es entonces cuando sale del sistema.
32 SISTEMAS OPERATIVOS

el planificador a largo plazo se ejecuta con una frecuencia mucho menor. y el sistema operativo de alguna manera debe seleccionar procesos de estas colas. entonces 1/(10 + 1) = 9% de la UCP se usa (se desperdicia) simplemente para que la planificación funcione.2. El planificador a largo plazo (o planificador de trabajos) selecciona procesos de este depósito y los carga en memoria para su ejecución. Debido al breve lapso de tiempo entre ejecuciones. un proceso transita entre las distintas colas de planificación. donde se conservan para su posterior ejecución. Por otra parte. PLANIFICADORES En el transcurso de su vida.5. Representación de la planificación de procesos mediante un diagrama de colas. este planificador de la UCP se ejecuta por lo menos una vez cada 10 milisegundos.1. con frecuencia se presentan más procesos que los que se pueden ejecutar de inmediato. normalmente). el planificador de la UCP debe ser muy rápido. y el proceso quizá se ejecute única mente durante unos milisegundos antes de esperar una solicitud de E/S. 2. en muchos casos. Abraham Gamarra Moreno 33 . El planificador a corto plazo debe seleccionar con mucha frecuencia un nuevo proceso para la UCP. El planificador a corto plazo (o planificador de la UCP) selecciona uno de los procesos listos para ejecución y le asigna la UCP. Si cuesta un milisegundo decidir la ejecución de un proceso de 10 milisegundos.Figura 2. Pueden transcurrir minutos entre la creación de nuevos procesos Mg. En un sistema por lotes. estos procesos se envían a un spooler en un dispositivo de almacenamiento masivo (un disco. Esta actividad de selección es realizada por el planificador correspondiente. La principal diferencia entre estos dos planificadores es la frecuencia de su ejecución.

Algunos sistemas operativos. los sistemas de tiempo compartido muchas veces no cuentan con un planificador a largo plazo. Si el rendimiento baja hasta niveles inaceptables. pueden presentar un nivel intermedio adicional de planificación. y colocan cada nuevo proceso en la memoria para que lo manipule el planificador a corto plazo. Los intercambios se analizan con mayor detalle en el capítulo de Administración de memoria. un proceso limitado por la UCP es el que genera solicitudes de E/S con poca frecuencia. Un proceso limitado por E/S es aquel que emplea más tiempo en realizar E/S que en efectuar cálculos. El diagrama de este planificador a mediano plazo se presenta en la Figura 2. el planificador a largo plazo puede emplear más tiempo para decidir qué proceso se debe seleccionar para su ejecución. algunos usuarios abandonarán y se dedicarán a otra cosa. El planificador a largo plazo controla el grado de multiprogramación (el número de procesos en memoria). Debido al mayor intervalo de tiempo entre ejecuciones.en el sistema. entonces la tasa promedio de creación de procesos debe ser igual a la tasa promedio de salida para los procesos que dejan el sistema. Por otra parte. la mayoría de los procesos pueden describirse como limitados por la UCP o limitados por E/S. o porque un cambio en los requisitos de memoria ha comprometido en exceso la memoria disponible. lo que requiere que se libere la memoria. La estabilidad de estos sistemas depende de una limitación física (como el número de terminales disponibles) o de que las características de los usuarios se ajusten automáticamente. como los de tiempo compartido. invirtiendo la mayor parte de su tiempo en efectuar cálculos que los procesos limitados por E/S. También puede ser más importante que el planificador a largo plazo efectúe una selección cuidadosa. 34 SISTEMAS OPERATIVOS .6. si el grado de multiprogramación es estable. El sistema con el mejor rendimiento tendrá una combinación de procesos limitados por la UCP y limitados por E/S. En algunos sistemas es posible que no exista el planificador a largo plazo o que su función sea mínima. Por ejemplo. Los intercambios pueden ser necesarios para mejorar la mezcla de procesos. de modo que sólo hay que invocar al planificador a largo plazo cuando un proceso sale del sistema. A este esquema comúnmente se le denomina intercambio (swapping). y una vez más se desequilibrará el sistema. la cola de espera de E/S casi siempre permanecerá vacía. El planificador a mediano plazo intercambia el proceso. sacándolo y volviéndolo a introducir más tarde. Es importante que el planificador a largo plazo seleccione una buena mezcla de procesos limitados por la UCP y limitados por E/S. Por lo general. Más tarde el proceso se volverá a introducir en la memoria y continuará su ejecución a partir del punto donde se quedó. Si todos los procesos están limitados por E/S. La idea clave de un planificador a mediano plazo es que en ocasiones puede ser ventajoso eliminar procesos de la memoria (y reducir la contienda por el uso de la UCP) y de este modo reducir el grado de multiprogramación. la cola de procesos listos estará casi vacía y el planificador a corto plazo tendrá poco que hacer. Si todos los procesos están limitados por la UCP.

Figura 2.6. Adición de la planificación a mediano plazo al diagrama de colas.

2.2. PLANIFICACIÓN DE LA UCP
La planificación es una función fundamental del sistema operativo. Casi todos los recursos de un computador se planifican antes de usarse. Por supuesto, la UCP es uno de los principales recursos del computador, de modo que su planificación es parte medular del diseño de los sistemas operativos.

2.2.1. CICLO DE RÁFAGAS DE UCP Y DE E/S
El éxito de la planificación de la UCP depende de la siguiente propiedad observada de los procesos: la ejecución de un proceso consiste en un ciclo de ejecución de la UCP y espera de E/S, y los procesos se alternan entre estos dos estados. La ejecución del proceso se inicia con una ráfaga de UCP; a ésta le siguen una ráfaga de E/S, otra ráfaga de UCP, una más de E/S, etc. Finalmente, la última ráfaga de UCP terminará con una solicitud al sistema para que concluya la ejecución, en vez de otra ráfaga de E/S (Figura 2.7). Las duraciones de estas ráfagas de UCP se han medido, y, aunque varían considerablemente de un proceso a otro y entre computadores, tienden a presentar una curva de frecuencias similar a la que se muestra en la Figura 2.8. Generalmente la curva se caracteriza como exponencial o hiperexponencial. Hay un gran número de ráfagas de UCP de corta duración y un pequeño número de ráfagas de larga duración. Un programa limitado por E/S normalmente tendrá muchas ráfagas de UCP breves, mientras que un programa limitado por la UCP tendrá pocas ráfagas de muy larga duración. Esta distribución puede ser muy importante al seleccionar un algoritmo adecuado para la planificación de la UCP.

Mg. Abraham Gamarra Moreno

35

Figura 2.7. Secuencia alterna de ráfagas de UCP y E/S.

36

SISTEMAS OPERATIVOS

Figura 2.8. Histograma de tiempos de ráfaga de la UCP.

2.2.2. PLANIFICADOR DE LA UCP
Siempre que la UCP queda inactiva, el sistema operativo debe seleccionar para su ejecución uno de los procesos de la cola de procesos listos. El proceso de selección es realizado por el planificador a corto plazo (o planificador de la UCP). El planificador selecciona uno de los procesos en memoria que están listos para ejecución y le asigna la UCP. Observe que la cola de procesos listos no es necesariamente una cola “primero que entra, primero que sale” (Fifo, first-in, first-out). Como veremos cuando tratemos los distintos algoritmos de planificación, una cola de procesos listos puede implantarse como una cola FIFO, una cola de prioridades, un árbol o simplemente como una lista ligada desordenada. Sin embargo, conceptualmente todos los procesos de la cola de procesos listos están en fila esperando una oportunidad para ejecutarse en la UCP. Los registros de las 1as suelen ser los PCB de los procesos.

2.2.3. ESTRUCTURA DE PLANIFICACIÓN
Las decisiones de planificación de la UCP pueden efectuarse en una de las cuatro circunstancias siguientes:

Mg. Abraham Gamarra Moreno

37

1. Cuando un proceso cambia del estado de ejecución a estado de espera (por ejemplo, solicitud de E/S, petición de esperar la terminación de uno de los procesos hijo). 2. Cuando un proceso cambia del estado de ejecución al estado listo (por ejemplo, cuando ocurre una interrupción). 3. Cuando un proceso cambia del estado de espera al estado listo (por ejemplo, al completarse la E/S) 4. Cuando termina un proceso Para los casos 1 y 4 no hay opción en términos de planificación: se debe seleccionar un nuevo proceso para su ejecución (si existe en la cola de procesos listos). Sin embargo, esto no se aplica a los casos 2 y 3. Cuando la planificación tiene lugar únicamente en las situaciones 1 y 4, decimos que el esquema de planificación es no apropiativo; de lo contrario decimos que es apropiativo. En la planificación no apropiativa, una vez que la UCP se ha asignado a un proceso, éste la conserva hasta que la libera, ya sea por terminar o por cambiar al estado de espera.

2.2.4. CAMBIO DE CONTEXTO
Para cambiar la UCP a otro proceso se requiere guardar el estado del proceso anterior y cargar el estado guardado para el nuevo proceso. Esta tarea se conoce como cambio de contexto. El tiempo de cambio de contexto es un puro gasto adicional, y varía de una máquina a otra, dependiendo de la velocidad de la memoria, del número de registros y de la existencia de instrucciones especiales (como una sola instrucción para cargar o almacenar todos los registros). Típicamente se encuentra en el intervalo de uno a cien microsegundos. Los tiempos de cambio de contexto dependen en gran medida del apoyo del hardware; por ejemplo, algunos procesadores ofrecen varios conjuntos de registros, y un cambio de contexto implica únicamente cambiar el apuntador al conjunto actual de registros. Por supuesto, si hay más procesos activos que conjuntos de registros, el sistema copia los datos usando la memoria, como se mencionó antes. Además, cuanto más complejo sea el sistema operativo, más trabajo hay que realizar durante un cambio de contexto. Como veremos en capítulos posteriores, las técnicas avanzadas de administración de memoria pueden requerir que con cada contexto se cambien otros datos adicionales.

38

SISTEMAS OPERATIVOS

5. Su utilización puede variar del O al 100% y en un sistema real debe fluctuar entre el 40% (para un sistema con poca carga) y el 90% (para un sistema con gran carga de trabajo).2. así que al elegir qué algoritmo se aplicará en una situación determinada debemos considerar las propiedades de los diversos algoritmos. Desde el punto de vista de un proceso en particular.2. El intervalo entre el momento de ofrecerlo hasta el momento en que termina es el tiempo de retorno. algunos de los cuales describiremos en esta sección. el despachador debe ser lo más rápido posible. 2. Abraham Gamarra Moreno . la productividad puede ser de 10 procesos por segundo. para transacciones más breves. esta tasa puede ser un proceso por hora. Productividad. El despachador es el módulo que realmente entrega el control de la UCP al proceso seleccionado por el planificador a corto plazo. Tiempo de retorno. el criterio más importante es cuánto tiempo tarda en ejecutarse ese proceso. DESPACHADOR Otro componente que participa en la función de planificación de la UCP es el despachador. Se cuenta con varios algoritmos de planificación de la UCP. y las características que se utilicen para la comparación pueden representar diferencias considerables en la determinación del mejor algoritmo. llamada productividad.3. Si la UCP se encuentra ocupada. ALGORITMOS DE PLANIFICACIÓN La planificación de la UCP tiene que ver con el problema de decidir a cuál de los procesos que están en la cola de procesos listos se le asignará la UCP. Los distintos algoritmos de planificación tienen propiedades diferentes y pueden favorecer a un tipo de proceso en lugar de a otro. Para comparar los algoritmos de planificación de la UCP se han propuesto varios criterios. Una medida del trabajo es el número de procesos que se completan por unidad de tiempo. la suma de los periodos transcu39 • • Mg. Esta función implica: • Cambiar de contexto • Cambiar a modo usuario • Saltar a la posición adecuada del programa del usuario para reiniciar el programa Obviamente. Para procesos largos. los criterios que se emplean incluyen los siguientes: • Utilización de la UCP. se está efectuando algún trabajo. es decir. Queremos que la UCP se mantenga tan ocupada como sea posible.

40 SISTEMAS OPERATIVOS . pero no el tiempo necesario para mostrar esa respuesta. podemos considerar sólo el tiempo de espera para cada proceso. y cada uno de ellos una secuencia de centenares de ráfagas de UCP y de E/S. Tiempo de respuesta. para garantizar que todos los usuarios obtengan un buen servicio podríamos minimizar el máximo tiempo de respuesta. • Tiempo de espera. en nuestros ejemplos consideramos sólo una ráfaga de UCP (en milisegundos). Para simplificar las ilustraciones. El algoritmo afecta únicamente a la cantidad de tiempo que el proceso espera en la cola de procesos listos. Nuestra medida de comparación es el tiempo promedio de espera. para sistemas interactivos (como los sistemas de tiempo compartido). A medida que analicemos los distintos algoritmos para la planificación de la UCP. Por ejemplo. es la cantidad de tiempo para comenzar a responder.rridos esperando entrar en la memoria. pero muy variable. Por esto. Un sistema con tiempo de respuesta razonable y predecible puede considerarse más deseable que un sistema que en promedio sea más rápido. • Es deseable maximizar la utilización de la UCP y la productividad. Esta medición. es más importante minimizar la varianza en el tiempo de respuesta que minimizar su promedio. de modo que en vez de tener en cuenta el tiempo de retorno. Una ilustración precisa podría incluir muchos procesos. El tiempo de retorno generalmente se encuentra limitado por la velocidad del dispositivo de salida. otra medición es el tiempo transcurrido desde la presentación de una solicitud hasta que se produce la primera respuesta. Sin embargo. esperando en la cola de procesos listos. es posible que el tiempo de retorno no sea el mejor criterio. en la mayoría de los casos optimizamos el promedio. y minimizar los tiempos de retorno. llamada tiempo de respuesta. es poco lo que se ha hecho respecto a los algoritmos para la planificación de la UCP que minimicen la varianza. El algoritmo para la planificación de la UCP no afecta realmente a la cantidad de tiempo durante el cual un proceso se ejecuta o lleva a cabo E/S. ejecutándose en la UCP y efectuando la E/S. Con frecuencia un proceso puede producir alguna salida en los primeros instantes y continuar calculando nuevos resultados mientras se presentan al usuario los resultados anteriores. de espera y de respuesta. en vez del promedio. En un sistema interactivo. También se ha propuesto que. ilustraremos su funcionamiento. pero en ocasiones puede ser deseable optimizar los valores mínimos o máximos.

Abraham Gamarra Moreno 41 . P2 y P3 y se les da servicio por orden de llegada. los resultados serán los que se muestran en la siguiente gráfica de Gantt: Mg.2. first-served). P3 y P1. sin embargo. cuando la UCP está libre se asigna el proceso colocado al inicio de la cola de procesos listos. El código para la planificación FCFS es sencillo de escribir y comprender. obtenemos el resultado que se presenta en la siguiente gráfica de Gantt: El tiempo de espera es 0 milisegundos para el proceso P1. Con este esquema. Sin embargo. PLANIFICACIÓN “SERVICIO POR ORDEN DE LLEGADA” Definitivamente. su PCB se enlaza al final de la cola.3. 24 milisegundos para el proceso P2 y 27 milisegundos para el proceso P3. el proceso que primero solicita la UCP es el primero al que se le asigna. y entonces el proceso en ejecución se elimina de esa misma cola. el algoritmo más sencillo para la planificación de la UCP es el algoritmo “servicio por orden de llegada” (FCFS. si los procesos llegan en el orden P2.En la política FCFS el tiempo promedio de espera es bastante largo. Considere el siguiente conjunto de procesos que llegan en el instante O. La política FCFS se implanta fácilmente con una cola FIFO: cuando un proceso entra en la cola de procesos listos. donde la duración de la ráfaga de uci se expresa en milisegundos: Proceso Duración de la ráfaga P1 P2 P3 24 3 3 Si los procesos llegan en el orden P1.1. first -come. de manera que el tiempo promedio de espera es (0 + 24 + 27)/3 = 17 milisegundos.

considere el siguiente conjunto de procesos. Si dos procesos tienen la misma longitud para la siguiente ráfaga de UCP se utiliza la planificación FCFS para romper el empate. Por esto.2. Una vez que se ha asignado la UCP a un proceso. Esto se conoce como efecto de convoy. El algoritmo FCFS es especialmente problemático en los sistemas de tiempo compartido. ya sea por terminación o por solicitud de E/S. se puede presentar la siguiente situación: el proceso limitado por la UCP obtendrá la UCP y la retendrá. Suponga que tenemos un proceso limitado por la UCP y varios procesos limitados por E/S. se ejecutan rápidamente y regresan a las colas de dispositivos de E/S. Una vez más. el tiempo promedio de espera en la política FCFS generalmente no es mínimo y puede variar bastante si los tiempos de ráfagas de UCP de los procesos varían mucho. El proceso limitado por la UCP regresará a la cola de procesos listos y se le asignará la UCP. Como ejemplo. considere el rendimiento de la planificación FCFS en una situación dinámica.3. En este momento la UCP está inactiva. donde es importante que cada usuario reciba una porción de la UCP a intervalos regulares. donde la longitud de ráfaga de UCP se presenta en milisegundos: 42 SISTEMAS OPERATIVOS . durante este tiempo. El algoritmo de planificación FCFS es no apropiativo. 2. Todos los procesos limitados por E/S. shortest-job-first). en espera de la UCP. el proceso limitado por la UCP termina su ráfaga de UCP y pasa a un dispositivo de E/S. Mientras esperan en la cola de procesos listos. los dispositivos de E/S permanecen inactivos. Cuando la UCP está disponible. lo que representa una reducción considerable. Este efecto provoca que la UCP y los dispositivos se aprovechen menos que si se permitiera que los procesos más cortos pasaran antes. ya que todos los demás procesos esperan a que un proceso de gran tamaño salga de la UCP. Sería desastroso permitir que un proceso retuviera la UCP por un periodo largo. Al pasar los procesos por el sistema. PLANIFICACIÓN “PRIMERO EL TRABAJO MÁS BREVE” Un enfoque distinto para la planificación de la UCP es el algoritmo “primero el trabajo más breve” (SJF. que tienen ráfagas de UCP breves. todos los demás procesos terminarán su E/S y pasarán a la cola de procesos listos. los procesos limitados por E/S se encuentran en la cola de procesos listos esperando a que termine el proceso limitado por la UCP. (No empleamos el término primero el proceso más breve porque la mayoría de las personas y los textos se refieren a este tipo de disciplina de planificación como primero el trabajo más breve. se le asigna al proceso que tiene la ráfaga siguiente de UCP menor. éste la conserva hasta que desee liberarla.El tiempo promedio de espera es ahora (6 + 0 + 3)/3 = 3 milisegundos.) Este algoritmo asocia a cada proceso la longitud de su siguiente ráfaga de UCP. Además. Finalmente.

podemos utilizar el tiempo límite del proceso. se reduce el tiempo de espera promedio.) La planificación SJF se usa frecuentemente en la planificación de procesos. 16 milisegundos para el proceso P2 nueve milisegundos para P3 y 0 para P4. ya que ofrece el mínimo tiempo promedio de espera para un conjunto de procesos dado.Proceso Duración de la ráfaga P1 P2 P3 P4 6 8 7 3 Usando la planificación SJF. Para la planificación a largo plazo de (trabajos) en un sistema por lotes. Mg. el tiempo promedio de espera sería de 10. De esta manera. De esta manera se motiva a los usuarios a estimar con precisión el tiempo límite del proceso. Si usáramos la planificación FCFS. La comprobación muestra que poniendo un proceso breve antes de uno largo se reduce el tiempo de espera del proceso corto más de lo que aumenta el tiempo de espera del proceso largo ( Figura 2. Puede comprobarse que el algoritmo SJF es Óptimo. El problema real con el algoritmo SJF es conocer la longitud de la siguiente solicitud de la UCP. Abraham Gamarra Moreno 43 . ya que un valor menor representa una respuesta más rápida. planificaríamos estos procesos de acuerdo con la siguiente gráfica de Gantt: El tiempo de espera es tres milisegundos para el proceso P1. Por tanto.9). el tiempo promedio de espera es (3 + 16 + 9 + 0)/4 = 7 milisegundos.25 milisegundos. (Un valor demasiado bajo ocasionará un error de tipo “tiempo límite excedido” y se tendrá que ofrecer de nuevo el proceso.

y la historia reciente no tiene efecto (se supone que las condiciones actuales son transitorias). para encontrar 44 SISTEMAS OPERATIVOS . no puede implantarse al nivel de la planificación a corto plazo de la UCP. El valor inicial de τ0 puede definirse como una constante o como un promedio global del sistema.10 muestra un promedio exponencial para α = ½. Sea tn la longitud de la enésima ráfaga de UCP. podemos desarrollar la fórmula para τn+1 sustituyéndolo por τn. esperando que sea de longitud similar a las anteriores. Es más habitual que α = ½.9. Así. y τn contiene nuestros datos históricos. La Figura 2. Para comprender el comportamiento del promedio exponencial. pero se puede tratar de efectuar una aproximación a la planificación SJF. El parámetro α controla la ponderación de la historia reciente y antigua para nuestra predicción. En general. al calcular una aproximación de la longitud de la siguiente ráfaga de UCP podemos elegir el proceso con la ráfaga de UCP prevista más breve. por lo que la historia reciente y antigua se ponderan de igual manera. El valor de tn contiene nuestra información más reciente. la siguiente ráfaga de UCP se predice como un promedio exponencial de las longitudes medidas de las ráfagas de UCP anteriores.Figura 2. Aunque el algoritmo SJF es óptimo. Aunque no conocemos la longitud de la siguiente ráfaga de UCP. para α. si α=1. y τn+1 nuestro valor previsto para la siguiente ráfaga de UCP. Comprobación de que el algoritmo de planificación SJF es óptimo. se define: τ n+1 = α t n + (1 − α )τ n Esta fórmula define un promedio exponencial. Entonces. entonces τn+1 = tn y sólo tiene importancia la ráfaga de UCP más reciente (se supone que los datos históricos son viejos e irrelevantes). entonces τn+1 = τn. 0<=α<=1. No hay manera de conocer la longitud de la siguiente ráfaga de UCP. podemos predecir su valor. Si α=O.

cada término sucesivo tiene menor peso que su predecesor. La alternativa se plantea cuando un nuevo proceso llega a la cola de procesos listos mientras se está ejecutando otro proceso. Un algoritmo SJF apropiativa desplazará al proceso que se ejecuta. El algoritmo SJF puede ser apropiativo o no apropiativo.α) son menores o iguales a 1.τ n +1 = α ⋅ t n + (1 − α ) ⋅ α ⋅ t n −1 + ⋅ ⋅ ⋅ + (1 − α ) j ⋅ α ⋅ t n −1 + ⋅ ⋅ ⋅ + (1 − α )n +1τ 0 Puesto que tanto α como (1 . La planificación SJF apropiativa en ocasiones se denomina planificación “primero el que tenga el menor tiempo restante” (shortest remaining-time-first). mientras que un algoritmo SJF no apropiativo permitirá que el proceso que se ejecuta termine su ráfaga de UCP.10 Predicción de la siguiente ráfaga de UCP utilizando un promedio exponencial. Figura 2. Abraham Gamarra Moreno 45 . Mg. El nuevo proceso puede tener una ráfaga de UCP menor que lo que resta del proceso que se ejecuta en ese momento.

Los procesos con igual prioridad se planifican en orden FCFS. no existe ningún con46 SISTEMAS OPERATIVOS . donde la prioridad (p) es la inversa de la siguiente ráfaga (prevista) de UCP (τ): p=1/τ. El tiempo promedio de espera para este ejemplo es ((10 .Como ejemplo. 2.3))/4 = 26/4 = 6. El tiempo restante para el proceso P1 (siete milisegundos) es mayor que el tiempo que requiere el proceso P2 (cuatro milisegundos). Se asocia una prioridad a cada proceso y la UCP se asigna al de mayor prioridad.75 milisegundos. El proceso P2 llega en el instante 1.5 milisegundos. Sin embargo. PLANIFICACIÓN POR PRIORIDADES El algoritmo SJF es un caso especial del algoritmo general para la planificación por prioridades.1) + (17 . la prioridad será menor y viceversa. por lo que el proceso P1 se expulsa y el proceso P2 se planifica. entonces la planificación SJF apropiativa que resulta se muestra en la siguiente gráfica de Gantt: El proceso P1 comienza en el instante 0. ya que es el único proceso en la cola. Un algoritmo SJF es sencillamente un algoritmo de prioridades. Si la ráfaga de UCP es mayor. El resultado de una planificación SJF no apropiativa sería 8. considere los cuatro procesos siguientes.2) + (5 .1) + (1 . Las prioridades generalmente corresponden a un intervalo fijo de números. donde la longitud de las ráfagas de UCP se proporciona en milisegundos: Proceso Instante de llegada Duración de la ráfaga P1 P2 P3 P4 0 1 2 3 8 4 9 5 Si los procesos llegan a la cola de procesos listos en los tiempos mostrados y necesitan los tiempos de ráfaga indicados.3.3. como 0 a 7 o 0 a 4095. Observe que analizamos la planificación en términos de una alta prioridad y una baja prioridad.

Las prioridades pueden definirse interna o externamente. el departamento que patrocina el trabajo y otros factores. que se supone llegaron en el instante 0. el número de archivos abiertos y la tasa de intervalos entre ráfagas de E/S y de UCP.. P2.. requisitos de memoria. Un algoritmo apropiativo para la planificación por prioridades se apropiará de la UCP si la prioridad del proceso recién llegado Mg. La planificación por prioridades puede ser apropiativa o no apropiativa. P5 y cuyas longitudes de ráfaga de UCP se indican en milisegundos: Proceso Duración de la ráfaga Prioridad P1 P2 P3 P4 P5 10 1 2 1 5 3 1 3 4 2 Usando la planificación por prioridades. otros utilizan números bajos para representar una prioridad alta. con frecuencia de carácter político. Las prioridades definidas internamente utilizan alguna cantidad o cantidades mensurables para calcular la prioridad del proceso. Algunos sistemas emplean números bajos para representar una prioridad baja. su prioridad se compara con la del proceso en ejecución. para calcular prioridades se han utilizado los límites de tiempo. Abraham Gamarra Moreno 47 . En este libro supondremos que los números bajos representan prioridades altas. Esta diferencia puede prestarse a confusiones. Por ejemplo. Como ejemplo.senso respecto a si 0 es la prioridad más alta o la más baja. como la importancia del proceso. planificaríamos estos procesos de acuerdo con la siguiente gráfica de Gantt: El tiempo promedio de espera es de 6. en el orden P1. el tipo y cantidad de fondos que se pagan por utilizar el computador. Cuando un proceso llega a la cola de procesos listos..2 milisegundos. considere el siguiente conjunto de procesos.. Las prioridades externas se fijan empleando criterios ajenos al sistema operativo.

Por otra parte. programa un cronómetro para que interrumpa después de un cuanto de tiempo y despacha el proceso. encontraron un proceso de baja prioridad que se había enviado en 1967 y que todavía no se había ejecutado. Los nuevos procesos se agregan al final de la cola de procesos listos. La cola de procesos listos se trata como una cola circular. no costaría más de 32 horas que un proceso pasara de prioridad 0 a prioridad 127. PLANIFICACIÓN CIRCULAR El algoritmo de planificación circular (RR. el planificador de la UCP la recorre asignando la UCP a cada proceso por un intervalo de hasta un cuanto de tiempo. Por ejemplo.3. (Según algunos rumores. Un algoritmo para la planificación por prioridades puede dejar a un proceso de baja prioridad esperando indefinidamente a la UCP. técnica por la cual aumenta gradualmente la prioridad de los procesos que esperan durante mucho tiempo en el sistema. incluso un proceso con prioridad inicial 0 podría alcanzar la prioridad más alta del sistema y ejecutarse. Por lo general sucederá una de estas dos cosas: o el programa finalmente se ejecuta (a las 2 AM del domingo. en espera de la UCP. 2. llamada cuanto de tiempo o porción de tiempo. un flujo constante de procesos de alta prioridad puede evitar que un proceso de baja prioridad obtenga la UCP. En un sistema de computación con gran carga. cuando por fin disminuye la carga del sistema) o el sistema de computación falla y pierde todos los procesos de baja prioridad. round-robin) está diseñado especialmente para sistemas de tiempo compartido.4. El planificador de la UCP toma el primer proceso de la cola. si la ráfaga de UCP del pro ceso 48 SISTEMAS OPERATIVOS . podríamos incrementar en uno la prioridad de un proceso en espera cada 15 minutos. Para poner en práctica la planificación mantenemos la cola de procesos listos como una cola “primero que entra. si las prioridades varían entre 0 (baja) y 127 (alta). que generalmente varía entre 10 y 100 milisegundos. en cuyo caso el proceso liberará voluntariamente a la UCP y el planificador continuará con el siguiente proceso de la cola de procesos listos.es mayor que la del proceso en ejecución. Se define una pequeña unidad de tiempo. primero que sale” (FIF0). Un serio problema de los algoritmos para la planificación por prioridades es el bloqueo indefinido o inanición.) Una solución para el problema del bloqueo indefinido de los procesos de baja prioridad es el envejecimiento. Un proceso que está listo para ejecutarse pero no obtiene la UCP puede considerarse como bloqueado. cuando dieron de baja el computador IBM del MIT en 1973. Un algoritmo no apropiativo para la planificación por prioridades únicamente dejará al nuevo proceso al inicio de la cola de procesos listos. De hecho. Entonces sucederá una de estas dos cosas: el proceso puede tener una ráfaga de UCP menor que un cuanto de tiempo. Tarde o temprano.

Entonces se proporciona la UCP al siguiente proceso. Abraham Gamarra Moreno 49 .en ejecución es mayor que un cuanto de tiempo. El resultado obtenido de la planificación RR es: El tiempo promedio de espera es 17/3 = 5. el cronómetro se activará y provocará una interrupción para el sistema operativo. se expulsa y regresa a la cola de procesos listos. la UCP no se asigna a ningún proceso por más de un cuanto consecutivo de tiempo. Se ejecutará un cambio de contexto y el proceso se colocará al final de la cola de procesos listos. si hay cinco procesos. Ningún proceso debe esperar más de (n . Puesto que necesita otros 20 milisegundos. P3 Una vez que cada proceso ha recibido un cuanto de tiempo. cada proceso recibe 1/n de tiempo de la UCP en trozos de q unidades de tiempo como máximo.66 milisegundos. se expulsa tras el primer cuanto de tiempo y la UCP se otorga a P2 el siguiente proceso de la cola. entonces cada proceso recibirá hasta 20 milisegundos cada 100 milisegundos. Mg. En el algoritmo de planificación RR. Sin embargo. Como el proceso P2 no requiere cuatro milisegundos. el proceso P1 obtiene los primeros cuatro milisegundos. sale antes de que termine el cuanto de tiempo. se devuelve la UCP al proceso P1 durante un cuanto de tiempo adicional. donde la longitud de la ráfaga de UCP se expresa en milisegundos: Proceso Duración de ráfaga P1 P2 P3 24 3 3 Si usamos un cuanto de tiempo de cuatro milisegundos. Por ejemplo. Considere el siguiente conjunto de procesos que llegan en el instante 0. Si existen n procesos en la cola de procesos listos y el cuanto de tiempo es q. El algoritmo de planificación RR es apropiativo. con un cuanto de tiempo de 20 milisegundos. el tiempo promedio de espera es bastante grande en la política RR. El planificador de la UCP seleccionará entonces el siguiente proceso de la cola. Si la ráfaga de UCP de un proceso excede de un cuanto.1) x q unidades de tiempo antes de recibir su siguiente cuanto.

queremos que el cuanto de tiempo sea grande respecto al tiempo de cambio de contexto.) Sin embargo. el proceso termina en menos de un cuanto. si el cuanto es muy grande (infinito). el enfoque RR se llama compartir el procesador.El rendimiento del algoritmo RR depende en gran medida del tamaño del cuanto de tiempo. Este ciclo continúa. Este enfoque se utilizó en el computador de Control Data Corporation (CDC) para implantar 10 procesadores periféricos con sólo un equipo de hardware y 10 conjuntos de registros. sin tiempo de procesamiento adicional. El hardware ejecuta una instrucción para un conjunto de registros y luego pasa al siguiente. dando como resultado 10 procesadores lentos en vez de uno rápido. en el software tenemos que considerar el efecto del cambio de contexto en el rendimiento de la planificación RR. Figura 2. y para los usuarios parece (en teoría) que cada uno de los n procesos tiene su propio procesador que se ejecuta a 1/n de la velocidad del procesador real. ocurrirán nueve cambios de contexto. Por lo anterior. produciendo un cambio de contexto.11 Un cuanto de tiempo menor incrementa el número de cambios de contexto. Supongamos que tenemos sólo un proceso de 10 unidades de tiempo. los procesadores no eran mucho más lentos de lo que habría sido un solo procesador. la política RR es la misma que la FCFS. Si el cuanto de tiempo es de 12 unidades de tiempo.11). Si el cuanto de tiempo es muy pequeño digamos un microsegundo). el proceso requiere 2 cuantos. lo que hará más lenta la ejecución del proceso ( Figura 2. Si el cuanto de tiempo es una unidad. como el procesador era mucho más rápido que la memoria y cada instrucción hacia referencia a ella. Si el tiempo de cambio de contexto es aproxi50 SISTEMAS OPERATIVOS . pero si el cuanto de tiempo es de seis unidades. En un extremo. (En realidad.

12. Una regla empírica es Mg. dados tres procesos de 10 unidades de tiempo cada uno y un cuanto de tiempo de una unidad. Por otra parte. si el cuanto de tiempo es demasiado grande. el tiempo de retorno promedio se reduce a 20. el tiempo de retorno promedio de un conjunto de procesos no necesariamente mejora al aumentar el cuanto de tiempo.madamente 10% del cuanto. Si se añade el tiempo de cambio de contexto. entonces en el cambio de contexto se invierte cerca de un 10% del tiempo de la UCP. En general. el tiempo de retorno promedio es 29. Figura 2. la planificación RR degenera hasta convertirse en una política FCFS. Abraham Gamarra Moreno 51 . pero si el cuanto es 10. el tiempo de retomo promedio puede mejorar si la mayoría de los procesos terminan su siguiente ráfaga de UCP en un solo cuanto de tiempo. Como podemos ver en la Figura 2. Por ejemplo. puesto que se requieren más cambios de contexto. El tiempo de retorno también depende del tamaño del cuanto de tiempo.12 El tiempo de retorno promedio varía con el cuanto de tiempo. el tiempo de retorno promedio aumenta para un cuanto de tiempo más pequeño.

mientras que la de segundo plano se planifica con un algoritmo FCFS.que el 80% de las ráfagas de UCP deben ser menores que el cuanto de tiempo. Por ejemplo. pueden emplearse colas distintas para los procesos de primer y segundo planos. no podría ejecutarse ningún proceso de la cola de procesos por lotes a menos que las colas de procesos del sistema. Cada cola tiene su propio algoritmo de planificación. por ejemplo. generalmente a partir de alguna propiedad del proceso. Un algoritmo de planificación de colas de múltiples niveles divide la cola de procesos listos en diversas colas ( Figura 2. la cola de procesos de primer plano puede tener prioridad absoluta sobre la cola de procesos de segundo plano. como puede ser el tamaño de la memoria o el tipo de proceso. Si un proceso interactivo de 52 SISTEMAS OPERATIVOS . una división habitual consiste en diferenciar los procesos de primer plano (interactivos) de los procesos de segundo plano (por lotes). Veamos un ejemplo de algoritmo de planificación de colas de múltiples niveles con cinco colas: • • • Procesos del sistema Procesos interactivos Procesos interactivos de edición • Procesos por lotes • Procesos de estudiantes Cada cola tiene prioridad absoluta sobre las colas de menor prioridad.3.13). los procesos de primer plano pueden tener una prioridad superior (definida externamente) a la de los procesos de segundo plano. Por ejemplo. por que pueden presentar distintas necesidades de planificación. la cual generalmente es una planificación apropiativa de prioridad fija. La cola de primer plano puede planificarse con un algoritmo RR. procesos interactivos y procesos interactivos de edición estuvieran vacías. PLANIFICACIÓN DE COLAS DE MÚLTIPLES NIVELES Se ha creado otra clase de algoritmos de planificación para aquellas situaciones donde los procesos se pueden clasificar fácilmente en distintos grupos. 2. Además. Los procesos se asignan en forma permanente a una cola. Estos dos tipos de procesos tienen requisitos de tiempo de respuesta bastante diferentes. Por ejemplo.5. Debe existir además una planificación entre las colas.

Por ejemplo. Otra posibilidad es utilizar una porción de tiempo para las colas. la cola de primer plano puede recibir el 80% del tiempo de la UCP para la planificación RR de sus procesos. si hay colas diferentes para los procesos de primer y segundo planos. pero es inflexible. no cambian de una cola a otra.3. ya que los procesos no modifican su naturaleza de primer o segundo planos. PLANIFICACIÓN DE COLAS DE MÚLTIPLES NIVELES CON REALIMENTACIÓN En un algoritmo para la planificación de colas de múltiples niveles normalmente los procesos se asignan de manera permanente a una cola al entrar al sistema y no se mueven a otras colas.edición entrara en la cola de procesos listos durante la ejecución de un proceso por lotes. este último se expulsaría. la cual se planificaría entre los procesos de su cola.13 Planificación de colas de múltiples niveles. Esta configuración tiene la ventaja de provocar poco gasto de procesamiento adicional durante la planificación. Por ejemplo.6. en el caso de las colas de primer y segundo planos. Cada cola recibiría cierta porción del tiempo de la UCP. Figura 2. mientras que la cola de segundo plano recibe el 20% de la UCP para distribuirlo entre sus procesos de manera FCFS. Mg. Abraham Gamarra Moreno 53 . 2.

Los proce54 SISTEMAS OPERATIVOS . Esta es una forma de envejecimiento que evitaría el bloqueo indefinido. De igual manera. Figura 2. A los procesos que entran a la cola de procesos listos se les coloca en la cola 0.14). se mueven al final de la cola 1. y se les asigna un cuanto de tiempo de ocho milisegundos. si un proceso espera demasiado tiempo en una cola de menor prioridad se puede mover a una de mayor prioridad. numeradas del 0 al 2 ( Figura 2. Si un proceso utiliza demasiado tiempo de la UCP. Este esquema deja a los procesos limitados por E/S y a los procesos interactivos en las colas de mayor prioridad. los procesos de la cola 2 sólo se ejecutarán si las colas 0 y 1 están vacías. la planificación de colas de múltiples niveles con realimentación permite a un proceso moverse de una cola a otra. considere un planificador de colas de múltiples niveles con realimentación con tres colas. A su vez. Si no terminan en este lapso. Sólo cuando ésta se encuentre vacía. se pasará a una cola de menor prioridad. se asigna un cuanto de tiempo de 16 milisegundos al proceso que se encuentre al inicio de la cola 1. La idea es separar los procesos con diferentes características en cuanto a ráfagas de la UCP.14 Colas de múltiples niveles con realimentación. Por ejemplo. Si no termina. un proceso de la cola 1 será expulsado por un proceso que llegue a la cola 0. es expulsado y pasa a la cola 2. El planificador ejecutará primero todos los procesos de la cola 0.Sin embargo. En forma similar. Un proceso que llegue a la cola 1 expulsará a un proceso de la cola 2. se ejecutarán los procesos de la cola 1. si la cola 0 está vacía.

Abraham Gamarra Moreno 55 . A continuación analizaremos brevemente algunos de los asuntos relacionados con la planificación de procesadores múltiples.4. Los procesos que requieren más de ocho. los cuales pueden ser idénticos (un sistema homogéneo) o distintos (un Mg. Este proceso recibirá rápidamente la UCP. un planificador de colas de múltiples niveles con realimentación se define con los siguientes parámetros • • El número de colas El algoritmo de planificación para cada cola • El método utilizado para determinar cuándo promover un proceso a una cola de mayor prioridad • El método utilizado para determinar cuándo degradar un proceso a una cola de menor prioridad • El método utilizado para determinar a cuál cola entrará un proceso cuando necesite servicio La definición de un planificador de colas de múltiples niveles con realimentación lo convierte en el algoritmo de planificación de la UCP más general. también son el más complejo. el problema de planificación se vuelve más complejo. Uno de los factores principales es el tipo de procesadores que entran en juego. 2. Se puede configurar para ajustarse a un sistema específico que se esté diseñando. Se han probado varias posibilidades y. pero menos de 24 milisegundos. Los procesos de larga duración descienden automáticamente a la cola 2 y son atendidos en orden de llegada utilizando cualquier ciclo de la UCP que no ocupe las colas 0 y 1. Este algoritmo de planificación da mayor prioridad a cualquier proceso con una ráfaga de UCP de ocho milisegundos o menos. Por lo general. Aunque las colas de múltiples niveles con realimentación son el esquema más general. no hay una solución única que sea la mejor. PLANIFICACIÓN DE PROCESADORES MÚLTIPLES Hasta ahora nuestro análisis se ha centrado en los problemas de la planificación de la UCP en un sistema con un solo procesador. también son atendidos con rapidez. únicamente cuando estén vacías las colas 0 y 1.sos de esta cola se ejecutan sobre una base FCFS. Si hay múltiples UCP. pero por desgracia también requiere alguna forma de selección de valores para todos los parámetros que definan el mejor planificador. aunque con menor prioridad que los procesos más breves. terminará su ráfaga de UCP y pasará a su siguiente ráfaga de E/S. como hemos visto en la planificación de la UCP con un solo procesador.

los procesos se restringen a ciertos procesadores y cada procesador puede planificarse a sí mismo. Si tenemos varios procesadores que tratan de acceder a una estructura de datos común y actualizarla. Así. es que en todo momento se ejecute un proceso para maximizar la utilización de la UCP (Unidad Central de Proceso). España: Addison Wesley Iberoamericana. Peterson J. con una cola vacía. el multiprocesamiento asimétrico. Sería posible proporcionar una cola distinta a cada procesador. 1998. SISTEMAS OPERATIVOS • 56 . creando así una estructura amo-esclavo. y deben ejecutarse en un procesador determinado. Debemos asegurar que dos procesadores no elijan el mismo proceso. 1994. En una de ellas. pero en esta situación un procesador podría estar inactivo. Cada procesador tiene su propia cola y su propio algoritmo de planificación.sistema heterogéneo). Sistemas Operativos. Si hay varios procesadores idénticos. Silberschatz A. todos los procesos entran a esta cola y se planifican en cualquier procesador disponible. Con este esquema puede emplearse una de dos estrategias d planificación. cada procesador se planifica a sí mismo. las opciones son relativamente limitadas. mientras los demás procesadores estuvieran muy activos. Introducción a los Sistemas Operativos. Resumen El objetivo de la multiprogramación en los Sistemas Operativos. Galvin P. un programa escrito en lenguaje ensamblador VAX no puede ejecutarse en un IBM Series/1. por lo tanto. hay que programar con cuidado cada procesador. La otra estrategia evita este problema estableciendo un procesador como planificador para los demás. Cada procesador examina la cola común de procesos listos y selecciona un proceso para ejecución. Si los procesadores son diferentes. Bibliografía Recomendada • Deitel M. esto es. Indicadores de logro El lector utiliza los algoritmos de planificación de la UCP. Los procesos están tipificados intrínsecamente por su estructura. pueden compartir cargas. se debe utilizar algún algoritmo que nos permita planificar la UCP. hay que ejecutarlo en un VAX. y que no se pierdan procesos de la cola. Usa: Editorial Addison Wesley Iberoamericana. 3ra Edición. Para evitarlo utilizamos una cola común de procesos listos. Segunda Edición.

P4. SJF. Segunda Edición. Auto evaluación formativa Resuelva los siguientes problemas: PROBLEMA UNO Considere el siguiente conjunto de procesos. 2003. Abraham Gamarra Moreno 57 . Nexo La siguiente unidad académica analiza el procesamiento concurrente para un sistema operativo. una prioridad no apropiativa (un menor número de prioridad representa una prioridad mayor) y RR (cuanto = 1). b) ¿Cuál es el tiempo de retomo de cada proceso para cada uno de los algoritmos de planificación del apartado a)? c) ¿Cuál es el tiempo de espera de cada proceso para cada uno de los algoritmos de planificación del apartado a)? d) ¿Cuál de los esquemas de planificación del apartado a) ofrece el menor tiempo promedio de espera (para todos los procesos)? Mg. cuyas longitudes de ráfaga de UCP se expresan en milisegundos: Proceso P1 P2 P3 P4 P5 Duración de la ráfaga 10 1 2 1 5 Prioridad 3 1 3 4 2 Se supone que los procesos llegaron en el orden P1. Actividad Realice una prueba de escritorio a los algoritmos de planificación. P5 todos en el instante 0. a) Dibuje cuatro gráficas de Gantt que ilustren la ejecución de estos procesos utilizando la planificación FCFS. Mexico: Pearson Educación. P3. Sistemas Operativos Modernos.• Tanenbaum A. P2.

4 y 8 minutos. llegan a un centro de cómputo casi al mismo. A-E.0 Duración de la ráfaga 8 4 1 a) ¿Cuál es el tiempo de retorno promedio para estos procesos con el algoritmo de planificación FCFS? b) ¿Cuál es el tiempo de retorno promedio para estos procesos con el algoritmo de planificación SJF? c) Supuestamente. 58 SISTEMAS OPERATIVOS . 4 y 8).0 0. Planificación por prioridad. Calcule cuál sería el tiempo de retorno total promedio si la UCP estuviera inactiva durante la primera unidad de tiempo y luego se aplicara la planificación SJF. determine el tiempo promedio de retorno a cada proceso. Ignore el costo excesivo de la alternancia entre procesos. PROBLEMA TRES Cinco trabajos por lote.PROBLEMA DOS Suponga que los procesos siguientes llegan para su ejecución en los momentos indicados. por lo que puede aumentar su tiempo de espera. Para B y D. hasta que termina. Recuerde que los procesos P1 y P2 están en espera durante este periodo de inactividad. Proceso P1 P2 P3 Instante de llegada 0. Round robin. Para cada uno de los siguientes algoritmos de planificación. A este algoritmo se le podría conocer como planificación con conocimiento del futuro. utilice la planificación no apropiativa y base todas sus decisiones en la información que tenga en el momento de tomar la decisión. 2. Sus prioridades (determinadas en forma externa) son de 3.4 1. suponga que el sistema es multiprogramado y que cada tarea obtiene la porción justa de la CPU. En primer lugar el trabajo más corto. Dar servicio primero al que llego en primer lugar (se ejecuta en el orden 10. respectivamente. Todos los trabajos tienen limitaciones de uso de la CPU. Al responder a estas preguntas. 6. A. Tienen tiempo estimados de ejecución de 10. suponga que sólo se ejecuta un trabajo a la vez. 5. el algoritmo de planificación SJF mejora el rendimiento. B. Cada proceso se ejecutará en el tiempo indicado. 6. siendo 5 la máxima prioridad. 1 y 4. D.En A. pero observe que decidimos ejecutar el proceso P1 en el instante 0 porque no sabíamos que pronto llegarían dos procesos más breves. C. 2. 2.

PROBLEMA CUATRO Se tiene el siguiente conjunto de procesos: Proceso P1 P2 P3 P4 P5 Duración de la ráfaga 8 2 5 4 9 Prioridad 3 2 3 0 1 Instante de llegada 0 1 3 4 6 Nota: Usar la columna prioridad sola para la planificación por prioridades. Calcular el tiempo promedio de espera (considere algoritmos apropiativos) para: E. SJF Planificación por prioridades Planificación circular. quantum=3 Mg. F. G. Abraham Gamarra Moreno 59 . Planificación del trabajo del más corto primero.

60 SISTEMAS OPERATIVOS .

DEFINICIONES DE PROCESO. Abraham Gamarra Moreno . en alguna medida intercambiada con tarea.UNIDAD ACADEMICA 3 PROCESAMIENTO CONCURRENTE – PARTE 1 3.1. en principio.1.1. se le ha dado muchas definiciones. El término proceso fue utilizado. 61 • • • Mg. por los diseñadores del sistema Multics en la década de 1960. el proceso. CONCEPTOS DE PROCESOS 3. Las que siguen son algunas de ellas: • • • • un programa que se está ejecutando una actividad asincrónica el “espíritu animado” del procedimiento el “emplazamiento del control” de un procedimiento que está siendo ejecutado aquello que se manifiesta por la existencia en el sistema operativo de un “bloque de control de proceso” aquella entidad a la cual son asignados los procesadores la unidad “despachable”. Desde entonces.

La l ista de bloqueados no está ordenada. La lista de listos se mantiene en orden prioritario. ESTADOS DE UN PROCESO Durante su existencia.3. hace que el proceso que anteriormente se hallaba en estado de ejecución pase al de listo. ya sea de manera accidental o maliciosamente. entonces. haciendo que el sistema operativo recupere el control. del estado listo al estado de ejecución (Figura 3. 62 SISTEMAS OPERATIVOS . y es insertado en la última parte de la lista de listos. se crea un proceso equivalente. El sistema operativo. los procesos no se desbloquean (o sea.1. si espera que ocurra algo (como la terminación de una entrada / salida) para poder ponerse en marcha. el sistema operativo ajusta un reloj de interrupción del hardware para permit ir al usuario ejecutar su proceso durante un intervalo de tiempo específico o cuantum. si tiene en ese momento el CPU. y una lista de bloqueados. TRANSICIONES DE ESTADO DE LOS PROCESOS Cuando un trabajo es admitido en el sistema. pero puede haber varios procesos listos y varios más bloqueados. Por tanto. Varias circunstancias pueden hacer que un proceso cambie de estado. aun cuando hacer la extensión hacia el multiprocesamiento no es difícil. un proceso pasa por una serie de estados discretos. Si el proceso no abandona voluntariamente el CPU antes de que expire el intervalo.1).1. Para prevenir que cualquier proceso monopolice el sistema. no quedan listos) en orden prioritario.2. el reloj genera una interrupción. en estado bloqueado). y hace que el primer proceso de la lista de listos pase al estado de ejecución. si hubiera uno di sponible. en lugar de esto. y es ejecutado por la entidad del sistema llamado despachador. Un proceso se dice que está listo (es decir. se dice que está en ejecución. 3. en estado de listo). y cuando el CPU se encuentre disponible. para los bloqueados.3. El proceso se va moviendo gradualmente hacia la cabeza de esta relación a medida que se completan los procesos anteriore s. para que el siguiente proceso que reciba el CPU sea el primer proceso de la lista. Sólo puede estar corriendo un proceso al mismo tiempo. Se dice que un programa se está ejecutando (es decir. está en estado de ejecución). Se dice que un proceso está bloqueado (es decir. se est ablece una lista de listos para los procesos listos. cuando podría usar un CPU. Cuando el proceso llega a la cabeza de la lista. los procesos se desbloquean en el orden en que tienen lugar los eventos que están esperando. Por simplicidad consideraremos un solo CPU. Mientras el proceso tenga el CPU. La asignación del CPU al primer proceso de la lista de listos es llamada despacho. el proceso recibe el CPU y se dice que hace una transición de estado.

EL BLOQUE DE CONTROL DE PROCESOS La manifestación de un proceso en un sistema operativo es un bloque de control de proceso (PCB = Process Control Block). Abraham Gamarra Moreno .Si un proceso que se encuentra en estado de ejecución inicia una operación de entrada/salida antes de que termine su quantum. Figura 3. incluyendo: • • estado actual del proceso identificación única del proceso 63 Mg. Transiciones de Estado de los Procesos. el proceso se bloquea a sí mismo hasta la terminación de la operación de e ntrada/salida).4. 3. La única otra transición posible en este modelo de tres estados ocurre cuando termina una operación de entrada/salida (o alguna otra causa por la que esté esperando el proceso).1.1. El PCB es una estructura de datos que contiene cierta información importante acerca del proceso. el proceso voluntariamente abandona el CPU (es decir. El proceso cambia del estado bloqueado al estado listo.

1. La creación de un proceso implica varias operaciones.5. OPERACIONES SOBRE PROCESOS Los sistemas que administran los procesos deben ser capaces de realizar ciertas operaciones sobre los procesos. El PCB es un almacenamiento central de información que permite al sistema operativo localizar toda la información clave sobre el proceso. SISTEMAS OPERATIVOS .• • • • prioridad del proceso apuntadores para localizar la memoria del proceso apuntadores para asignar recursos área para preservar registros. 3. Estos incluyen: • • • • • • • • crear un proceso destruir un proceso suspender un proceso reanudar un proceso cambiar la prioridad de un proceso bloquear un proceso despertar un proceso despachar un proceso. Cuando el sistema operativo cambia la atención del CPU entre los procesos. incluyendo: • • • • • 64 dar nombre al proceso insertar un proceso en la lista del sistema de procesos conocidos determinar la prioridad inicial del proceso crear el bloque de control de proceso asignar los recursos iniciales del proceso. utiliza las áreas de preservación del PCB para mantener la información que necesita para reiniciar el proceso cuando consiga de nuevo el CPU.

2. y el proceso creado se llama proceso hijo. Abraham Gamarra Moreno 65 . Sus recursos son devueltos al sistema. en la cual cada hijo tiene un solo padre. Cambiar la prioridad de un proceso no suele implicar más que cambiar el valor de la prioridad en el bloque de control de procesos. y la destrucción de un padre no tiene ningún efecto sobre los hijos que ha creado. pero cada padre puede tener varios hijos. Figura 3. Estas operaciones son importantes por varias razones: Mg. Un proceso suspendido no puede proseguir hasta que otro proceso lo reanude. La destrucción de un proceso es mucho más complicada si ha creado otros procesos. SUSPENSIÓN Y REANUDACIÓN En la sección anterior se introdujeron las nociones de procesos suspendidos y reanudados. A menudo son realizados por el sistema para sacar temporalmente ciertos procesos durante una situación de carga pico. En algunos sistemas. el proceso que lo crea se llama proceso padre. se purga de todas las listas o tablas del sistema.2. Las suspensiones suelen durar sólo un breve período de tiempo.1. los procesos creados continúan independientemente de sus padres. Si lo hace. un proceso creado se destruye automáticamente al destruir al padre.6.Un proceso puede crear un nuevo proceso. en otros sistemas. y se borra su bloque de control de proceso. Jerarquía de Procesos. Destruir un proceso implica borrarlo del sistema. Reanudar (o activar) un proceso implica el reiniciarlo en el punto donde fue suspendido. 3. Tal creación produce una estructura jerárquica de procesos como la mostrada en la Figura 3.

Si un sistema está funcionando deficientemente y puede fallar, entonces los procesos que están en ejecución deberán ser suspendidos para reanudarlos una vez que el problema ha sido corregido. Un usuario que sospeche que algo no está bien, partiendo de los resultados parciales obtenidos de un proceso, puede suspenderlo (en lugar de abortarlo) hasta que el usuario esté seguro de si el proceso funciona correctamente o no. Como respuesta a las fluctuaciones a corto plazo en la carga del sistema, algunos procesos pueden ser suspendidos y reanudados más tarde, cuando la carga vuelva a sus niveles normales.

La Figura 3.3 muestra el diagrama de transición de estado de los procesos modificado para incluir suspensión y reanudación. Se han añadido dos estados más: el suspendido listo y el suspendido bloqueado; no hay necesidad de un estado suspen dido de ejecución. Sobre la línea de trazos de la figura están los estados activos; debajo de ella están los estados suspendidos. Una suspensión puede ser iniciada por el propio proceso o por otro proceso. En un sistema uniprocesador, un proceso en estado de ejecución puede suspenderse a sí mismo; ningún otro proceso puede estar en ejecución al mismo tiempo para emitir la suspensió n. En un sistema multiprocesador, un proceso en estado de ejecución puede ser suspendido por otro proceso en el mismo estado que se esté ejecutando en un procesador diferente.

3.1.7. EL NÚCLEO DEL SISTEMA OPERATIVO
Todas las operaciones que implican procesos son controladas por una porción del sistema operativo, el cual es llamado su núcleo. El núcleo representa, solamente, una pequeña porción del código de todo el sistema operativo, pero se encuentra entre los códigos de más amplio uso. Por esta razón, el núcleo suele permanecer en memoria principal, mientras otras porciones del sistema operativo son transportadas de un lado a otro, entre la memoria principal y la secundaria, según las necesidades. Una de las funciones más importantes incluidas en el núcleo es el proceso de interrupciones. En los grandes sistemas de múltiples usuarios hay una corriente constante de interrupciones dirigidas al procesador. La rápida respuesta a estas interrupciones es esencial para mantener bien utilizados los recursos del sistema, y para proveer tiempos de respuesta aceptables a los usuarios interactivos.

66

SISTEMAS OPERATIVOS

Figura 3.3. Transiciones de estado de proceso con suspensión y reanudación.

3.1.8. RESUMEN DE FUNCIONES DEL NÚCLEO.
Un núcleo de sistema operativo contiene normalmente el código necesario para la realización de las siguientes funciones: • • • • • • • Manipulación de interrupciones. Creación y destrucción de procesos. Cambios de estados de proceso. Despacho Suspensión y reanudación de procesos. Sincronización de procesos. Comunicación entre procesos.
67

Mg. Abraham Gamarra Moreno

• • • • • •

Manipulación de bloques de control de proceso. Soporte de las operaciones de entrada/salida. Soporte para la administración de memoria principal. Soporte del sistema de archivos. Soporte de un mecanismo de llamada/regreso al procedimiento. Soporte de ciertas funciones contables del sistema.

3.2. PROCESOS CONCURRENTES ASINCRÓNICOS.
Los procesos son concurrentes si existen al mismo tiempo. Los procesos concurrentes pueden funcionar con total independencia unos de otros, o pueden ser asincrónicos, lo cual significa que requieren una sincronización y cooperación ocasionales. El asincronismo es un tópico complejo; aquí se exponen la organización y administración de sistemas que soportan procesos concurrentes asincrónicos. Se presentan muchos problemas importantes de asincronismo. Sus soluciones se presentan como programas concurrentes codificados utilizando el lenguaje Pascal concurrente desarrollado inicialmente por Wirth (Pascal-S), extendido por Ben Ari y modificado en la Universidad de Bradford (UK) por G.L. Davies (Pascal-FC).

3.2.1. PROCESAMIENTO EN PARALELO
A medida que disminuyen tanto el tamaño como el precio del hardware de las computadoras se irá produciendo una tendencia hacia el multiprocesamiento y la masificación del paralelismo. Si ciertas operaciones pueden ser ejecutadas en paralelo de forma lógica, entonces las computadoras con múltiples procesadores las ejecutarán físicamente en paralelo, aunque en el nivel de paralelismo se den miles o, tal vez, millones de actividades concurrentes. El procesamiento en paralelo es interesante por varias razones. La gente parece más capaz de centrar su atención en una sola actividad a la vez que de pensar en paralelo. (Intente leer dos libros al mismo tiempo, leyendo una línea de un libro, una línea del otro, la segunda línea del primero, y así sucesivamente.) Es difícil determinar cuáles actividades pueden ejecutarse o no en paralelo. Los programas en paralelo son mucho más difíciles de depurar que los programas secuenciales; después de haber arreglado supuestamente un error, puede resultar imposible reconstruir la secuencia de eventos que han ocacionado el error. Por ello, sería en cierto modo inapropiado asegurar que se ha corregido el error.
68 SISTEMAS OPERATIVOS

Los procesos asincrónicos deben interactuar ocasionalmente entre sí, y esas interacciones pueden ser complejas. Aquí se trata varios ejemplos de interacción de procesos.

3.2.2. UNA ESTRUCTURA PARA INDICAR EL PARALELISMO: COBEGIN/COEND
Son muchas las construcciones de lenguajes de programación para indicar paralelismo que han aparecido en la literatura. Estas implican pares de proposiciones como las siguientes: • Una proposición indicando que la ejecución secuencial debe ser dividida entre varias secuencias de ejecución en paralelo (trayectoria de control). Una proposición indicando que ciertas secuencias de ejecución en paralelo están a punto de producirse y se reanudará la ejecución secuencial.

Estas proposiciones ocurren en pares y suelen denominarse parbegin/parend (para comenzar y finalizar una ejecución en paralelo), o cobegin/coend (para comenzar o finalizar una ejecución concurrente). En este trabajo emplearemos cobegin/coend de acuerdo a la sintaxis del Pascal-FC. Su forma general es:
cobegin proposición 1; proposición 2; : . proposición n; coend

Supongase que un programa está ejecutando una sola secuencia de instrucciones cuando se encuentra con la construcción cobegin anterior. Esto determina que la trayectoria de control simple se divida en n trayectorias separadas de control, una por cada proposición de la construcción cobegin/coend. Estas pueden ser proposiciones simples, llamadas a procedimientos, bloques de proposiciones secuenciales delineados por begin/end, o combinaciones de éstos. Cada una de las trayectorias de control individuales acaba por alcanzar y terminar al coend. Cuando todas las trayectorias de control paralelas llegan al final, se reanuda una trayectoria de control simple y el sistema prosigue más allá del coend. Como ejemplo, considérese el siguiente cálculo de una raíz de la ecuación cuadrática: x := ( -b + (b**2 - 4*a*c) ** 0.5) / (2*a) Esta asignación puede ser evaluada en un procesador secuencial (poseedor de una instrucción de exponenciación) de la siguiente manera:
Mg. Abraham Gamarra Moreno 69

5 ) 2*a (-b+(b**2-4*a*c)**0. Considérese lo que pasaría si dos procesos intentaran incrementar NOLINEAS simultáneamente.(4*a*c) (b**2 . 4 t5:= t5 ** 0. Supóngase que cada proceso tiene su propia copia del código: LOAD ADD STORE NOLINEAS 1 NOLINEAS 70 SISTEMAS OPERATIVOS .5 . Aquí se evalúan en paralelo las cuatro operaciones contenidas dentro de la construcción cobegin/coend. la expresión puede evaluarse de la manera siguiente: 1 cobegin t1:= -b. EXCLUSIÓN MUTUA Considérese un sistema con varias terminales de tiempo compartido. 3 t5:= t2 . 5 t5:= t1 + t5. Al ejecutar los cálculos en paralelo se reduce en gran medida el tiempo real de ejecución. las cinco operaciones restantes deben ser ejecutadas de forma secuencial. t2:= b ** 2.3. t3:= 4 * a. coend 2 t5:= t3 * c. Supóngase que los usuarios acaban cada línea. En un sistema que soporte procesamientos en paralelo.2.b 7 (-b) + ( (b**2 . 3. 6 x:= t5 / t4.5)/(2*a) Aquí se ejecutan de una en una cada una de las nueve operaciones en una secuencia determinada por las reglas de un sistema de precedencia de operadores.5.4*a*c)**0. y que cada terminal está supervisada por un proceso diferente.t5. que teclean al sistema con un retorno de carro. t4:= 2 * a.4*a*c) ** 0.1 2 3 4 5 6 8 9 b**2 4*a (4*a)*c (b**2) . Supóngase que se desea supervisar continuamente el número total de líneas que los usuarios han introducido al sistema desde el comienzo del día. Cada vez que uno de estos procesos recibe una línea de la terminal de un usuario incrementa en 1 la variable global compartida NOLINEAS.

A continuación. cobegin uno. dejando así el valor de 2346 en un acumulador. (* dos *) (* Programa principal *) begin nolineas := 0.exe. program pro00.var lin: integer. ubiquese en la carpeta unidad 3. dos coend. Suponga ahora que el primer proceso ejecuta las instrucciones LOAD y ADD.La carga de los archivos se realiza con File. Entonces el proceso pierde el procesador (debido a la terminación de un quantum) en beneficio del segundo proceso. (* El proceso uno contará 60 lineas *) process uno. begin for lin := 1 to 60 do begin nolineas := nolineas + 1end end. ajustando así NOLINEAS con el valor 2346.var lin: integer. y realice doble click en compilador. El proceso uno pone 60 líneas mientras que el proceso dos pone 40. la suma total de líneas debería ser 100. Debido al acceso incontrolado a la variable compartida NOLINEAS el sistema ha perdido la pista de una de las líneas. (* uno *) (* El proceso dos contará 40 líneas *) process dos. writeln(‘Total de líneas =’. Open. Para ejecutar lo ejemplos que se analizan de aquí en adelante.Suponga que NOLINEAS tiene un valor de 2345. Abraham Gamarra Moreno 71 . Pierde el procesador y lo obtiene de nuevo el primer proceso. Este último ejecuta ahora las tres instrucciones. La ejecución con la tecla F9. Con ese archivo se ejecuta el Pascal Concurrente. pero observe lo que pasa. begin for lin := 1 to 40 do begin nolineas := nolineas + 1end end. el cual continúa con la ejecución de la instrucción STORE. el total correcto debería ser 2347. var nolineas: integer. colocando también el valor 2346 en NOLINEAS. se muestra el programa pro00 que simula este concepto así como diferentes corridas del mismo.nolineas) Mg. Por supuesto. luego en la carpeta PFCWIN.

4. La salida en varias ejecuciones es: Total de líneas = Total de líneas = Total de líneas = Total de líneas = Total de líneas = 57 74 78 76 69 NOTA: La salida que se obtiene al ejecutar el programa podría variar en su computador.2. Cuando un proceso abandona su sección crítica. cuando los procesos ejecutan operaciones que no estén en conflicto entre sí. los demás procesos pueden continuar su ejecución fuera de sus secciones críticas. debe permitirseles proceder de forma concurrente. Se han diseñado muchas soluciones para esto: algunas de software y algunas de hardware. SECCIONES CRÍTICAS La exclusión mutua necesita ser aplicada sólo cuando un proceso accesa a datos compartidos. algunas que requieren de cooperación voluntaria 72 SISTEMAS OPERATIVOS . Cuando un proceso está accesando a datos compartidos se dice que el proceso se encuentra en su sección crítica (o región crítica). cuando un proceso esté en su sección crítica. Este problema puede solucionarse dándole a cada proceso acceso exclusivo a NOLINEAS. De esta manera. Mientras un proceso incrementa la variable compartida. Esto se denomina exclusión mutua. le será permitido proceder a uno de los procesos. cuando ese proceso termine de accesar la variable deseada. los demás procesos que deseen hacer lo mismo al mismo tiempo deben permanecer a la espera.end. entonces debe permitírsele proceder a otros procesos que esperan entrar en su propia sección crítica (si hubiera un proceso en espera). Esta claro que para prevenir el tipo de problema experimentado en la sección anterior debe asegurarse que. 3. La aplicación de la exclusión mutua es uno de los problemas clave de la programación concurrente. Mientras un proceso se encuentre en su sección crítica. más de bajo nivel y otras de alto nivel. todos los demás procesos (o al menos aquellos que tengan acceso a los mismos datos compartidos) sean excluidos de sus propias secciones críticas. cada proceso que esté accesando el dato compartido impide a todos los demás hacer lo mismo al mismo tiempo.

tanto de forma voluntaria como involuntaria. saledeexclusionmutuaend end. Abraham Gamarra Moreno 73 . un programa no debe bloquearse dentro de su sección crítica. Estas operaciones se llaman. y todos los demás procesos que necesitan accesar a esos datos permanecen en espera.4 implementa correctamente el mecanismo contador de líneas de la sección anterior. primitivas de exclusión mutua. process uno. estas construcciones demarcan las secciones críticas.2. la posibilidad de incurrir en ciclos infinitos).5. que invocan las operaciones más fundamentales inherentes a la exclusión mutua. Si un proceso dentro de una sección crítica termina.4 encapsulan el código en cada proceso que accesa la variable compartida NOLINEAS. trataremos tan sólo dos procesos concurrentes en los programas presentados en esta y en las próximas secciones. por ejemplo. o sea. PRIMITIVAS DE EXCLUSIÓN MUTUA El programa concurrente de la Figura 3. var lin: integer. El manejo de n procesos concurrentes es mucho más complejo. a veces. 3. las secciones críticas deben ser ejecutadas lo más rápido posible. Las construcciones entraexcluisionmutua y saledeexclusionmutua introducidas en la Figura 3. Por tanto. el sistema operativo debe liberar la exclusión mutua para que otros procesos puedan entrar en sus s ecciones críticas. es decir. El proceso tiene acceso exclusivo a los datos compartidos.var lin: integer. (* uno *) process dos. entonces. al realizar su limpieza de terminación. Estar dentro de una sección crítica es un estado muy especial asignado a un proceso. program exclusionmutua. begin for lin := 1 to 40 do begin Mg. Por simplicidad. begin for lin := 1 to 60 do begin entraexclusionmutua.var nolineas: integer. nolineas := nolineas + 1.entre los procesos. y las secciones críticas deben ser codificadas con todo cuidado (para evitar. y algunas que demandan una adherencia rígida a protocolos estrictos.

accesa la variable deseada y después ejecuta saledeexclusionmutua para indicar que ha abandonado su sección crítica. proceder a entrar en su sección crítica. Proceso uno puede. Cada instrucción de lenguaje de máquina se ejecuta de forma indivisible. se hace que las referencias sucedan una a la vez.2. entonces proceso uno entra a su sección crítica. saledeexclusionmutua end. Utilización de las primitivas de exclusión mutua. esto es.end. El interbloqueo de almacenamie nto secuencializa las referencias en conflicto por medio de procesadores separados. debemos suponer que una característica del hardware llamada interbloqueo de almacenamiento resuelve todos los conflictos. Si proceso dos está en su sección crítica cuando proceso uno ejecuta entraexclusionmutua. (* dos *) begin nolineas := 0. ésta se termina sin interrupción. En el caso de los dos procesos. entonces. una vez iniciada una instrucción. entonces proceso uno entra en espera hasta que proceso dos ejecute saledeexclusionmutua. estas primitivas operan como sigue: cuando proceso uno ejecuta entraexclusionmutua. entonces le será permitido proceder a alguno. 3.4. SISTEMAS OPERATIVOS 74 . IMPLEMENTACIÓN DE LAS PRIMITIVAS DE EXCLUSION MUTUA Se busca una implementación de entraexclusionmutua código de entrada a exclusión mutua y saledeexclusionmutua código de salida de exclusión mutua que satisfaga las cuatro restricciones siguientes: • La solución se implementa sólo en software en una máquina que no tenga instrucciones de exclusión mutua especialmente diseñadas. Si proceso uno y proceso dos ejecutan entraexclusionmutua simultáneamente. Se da por supuesto que las referencias separadas son servidas en orden aleatorio.6. dos coend. nolineas := nolineas + 1.entraexclusionmutua. Si procesadores múltiples tratan de accesar el mismo dato. end Figura 3. es decir. permaneciendo el otro en espera. si proceso dos no está en su sección crítica. cobegin uno.

Los procesos que se encuentren operando fuera de sus secciones críticas no pueden evitar que entren otros procesos en sus propias secciones críticas.7. En la siguiente sección seguimos el desarrollo de Dijkstra del algoritmo de Dekker. Abraham Gamarra Moreno 75 . entrando repetidamente en su sección crítica. nolineas := nolineas + 1. begin for lin := 1 to 50 do begin while pnumero = 2 do null. dentro del contexto de un programa concurrente con dos procesos. En el programa pro01 entraexclusionmutua se implementa por un ciclo ‘while’ simple.var lin: integer. process uno. begin for lin := 1 to 50 do Mg. pnumero := 2end end. ALGORITMOS DE EXCLUSIÓN MUTUA: DESARROLLO INTUITIVO El programa pro01 muestra un primer intento de especificar el código para forzar la aplicación de la exclusión mutua. nolineas: integer. que mantiene el ciclo hasta que pnumero iguala al número del proceso.2. Cada uno de estos procesos entra en un ciclo. program pro01. 3. La construcción cobegin/coend hace que el proceso uno y el proce so dos operen como procesos concurrentes. (* primera version de las primitivas de exclusión mutua *) var pnumero: integer. No deben postergarse indefinidamente la entrada de los procesos en sus secciones críticas. saledeexclusionmutua se implementa por una instrucción simple que ajusta pnumero al número del otro proceso. (* uno *) process dos.var lin: integer.• No deberá hacerse ninguna suposición en relación con las velocidades relativas de procesos concurrentes asincrónicos. • • Una implementación elegante de software de la exclusión mutua fue la presentada por primera vez por el matemático holandés Dekker.

deberá tardar bastante. El proceso uno debe de entrar primero.nolineas) end. si ambos intentan entrar simultáneamente en sus secciones críticas. así es que si el proceso dos está listo para entrar en su sección crítica. ajustando p2dentro en falso. El proceso uno acaba por terminar la ejecución dentro de su sección crítica (ha de suponerse que no hay ciclos infinitos) y ajusta pnumero a 2. simplemente permanece en el ciclo en espera de que pnumero se ajuste a 2. Entonces. El proceso dos acaba abandonando su sección crítica y realiza su propio código de salida de exclusión mutua. cobegin uno. aun cuando el proceso uno desee reentrar y el proceso dos no esté listo. Ahora. en la segunda versión (pro02). Si un proceso requiere hacer esto muchas más veces que el otro. El proceso uno ejecuta el while-do. pero el precio es alto. la cual es verdadera si el proceso uno está dentro de su sección crítica. así que proceso dos no entra en su sección crítica y la exclusión mutua queda garantizada. está restringido a operar a una velocidad más lenta de la que requiere. La exclusión mutua está garantizada. el proceso uno entra a su sección crítica. El proceso dos encuentra pnumero igual a 1 y permanece encerrado en su ciclo de while-do. Después de que el proceso uno entre y salga de su sección crítica. El proceso uno ajusta entonces p1dentro en verdadero y entra en su sección crítica. Cuando el proceso dos obtiene el procesador. que es verdadera si proceso dos está dentro de su sección crítica. el proceso uno permanece encerrado en una espera. 76 SISTEMAS OPERATIVOS . El sistema no debe interbloquearse completamente. y esto forzaba la aparición del problema de sincronización bloqueada. Así es que. Como pnumero es inicialmente 1. (* dos *) begin pnumero := 1. nolineas := nolineas + 1. se usan dos variables: p1dentro. Si uno de los proceso termina. y p2dentro. nolineas := 0. entonces el proceso dos deberá seguir. dos coend.begin while pnumero = 1 do null. En la primera solución existe solamente una variable global simple. pnumero := 1end end. mientras p2dentro sea verdadera. por lo menos puede proceder un proceso.writeln(‘Total de líneas =’. los procesos deberán entrar y salir de sus secciones críticas en estricta alternancia. permitiendo así que el proceso dos entre en su sección crítica. entonces el otro no podrá continuar.

El proceso uno podría probar p2dentro y encontrarla falsa. dos coend. nolineas := nolineas + 1. nolineas: integer.var lin: integer. cobegin uno. p1dentro := true. A continuación se muestra el listado del programa pro02.nolineas) end. p2dentro := false. ambos podrían intentar en forma simultánea sus secuencias de código de entrada de exclusión mutua.writeln(‘Total de líneas = ‘. begin for lin := 1 to 50 do begin while p1dentro do null.var lin: integer. p1dentro := false end end. como quiera que el proceso uno y el proceso dos son concurrentes. el proceso dos podría probar p1dentro y Mg. nolineas := nolineas + 1. (* dos *) begin p1dentro := false. La sutileza de la programación concurrente vuelve a salir a la superficie. (* uno *) process dos. process uno. nolineas := 0. Abraham Gamarra Moreno 77 . begin for lin := 1 to 50 do begin while p2dentro do null. entonces. tanto p1dentro como p2dentro son falsas. proceso dos no podrá entrar en su sección crítica.Mientras p1dentro sea verdadera. p2dentro := falseend end. antes de que el proceso uno pueda ajustar p1dentro en verdadero. (* segunda version de las primitivas de exclusión mutua *) var p1dentro. program pro02. p2dentro := true. En principio. p2dentro: boolean.

var lin: integer. debe tener la seguridad de que el otro proceso no puede ir más allá de su propia prueba del while. (* tercer version de primitivas de exclusion mutua *) var p1quiere. nolineas: integer. program pro03. Por tanto. nolineas := nolineas + 1. while p1quiere do null. A continuación se muestra la corrida del programa pro02. así es que la segunda versión ni siquiera garantiza la exclusión mutua. hay tiempo suficiente para que el otro proceso pruebe su bandera y entre en su sección crítica. begin for lin := 1 to 20 do begin p2quiere := true. La tercera versión intenta resolver esto haciendo que cada proceso ajuste su bandera antes de la ejecución del while. p1quiere :=false end end. begin for lin := 1 to 20 do begin p1quiere := true. p2quiere: boolean. (* uno *) process dos.enco ntrarla falsa. La salida para varias ejecuciones es: Total de líneas = Total de líneas = 91 94 En la segunda versión existe una dificultad.var lin: integer. Ambos procesos se encuentran en sus secciones críticas al mis mo tiempo. una vez que el proceso intenta la prueba del while. process uno. el proceso uno coloca p1dentro en verdadero y entra a su sección crítica. y el proceso dos ajusta p2dentro en verdadero y entra a su sección crítica. 78 SISTEMAS OPERATIVOS . while p2quiere do null. nolineas := nolineas + 1. En este punto. pues entre el tiempo en que un proceso determina (en la prueba del while) que puede seguir adelante y el tiempo en que el proceso ajusta una bandera para indicar que está en su sección crítica.

p2quiere := falseend end. con su bandera todavía conectada. p2quiere: boolean. Mg. p1quiere := falseend end.var lin: integer. nolineas: integer.writeln(‘Total de líneas =’. (El programa bloquea la computadora) El problema de la tercera versión es que todos los procesos pueden encerrarse en su ciclo while-do respectivo. cobegin uno. Se ha solucionado un problema pero se ha creado otro. cada proceso se encontrará con la bandera de la otra ajustada y entrarán para siempre en el ciclo while-do. Es necesaria una manera de “romper” estos ciclos. dos coend. entonces. begin for lin := 1 to 20 do begin p1quiere := true. (* uno *) process dos. Abraham Gamarra Moreno 79 .nolineas) end.var lin: integer. nolineas := nolineas + 1. program pro04. sleep(random(10)). (* dos *) begin nolineas := 0. Este es un ejemplo de un interbloqueo de dos procesos (la corrida de este programa causa que la máquina quede bloqueada). while p2quiere do begin p1quiere := false. La cuarta versión logra esto al forzar cada proceso de ciclo a ajustar su bandera en falso rep etidamente en períodos breves. process uno. esto permitirá al otro proceso proceder más allá de su prueba del while. p1quiere := true end. (* cuarta version de primitivas de exclusion mutua*) var p1quiere. Si cada proceso ajusta su bandera antes de proceder con la prueba del while.

nolineas := nolineas + 1. comenzando con la prueba del while. El proceso podría. ajustar su bandera en verdadero y. ajustar su bandera en falso. repetir la secuencia. 80 SISTEMAS OPERATIVOS . las condiciones de prueba perm anecerán verdaderas. Veamos como. while p1quiere do begin p2quiere := false. Cada proceso puede seguir la siguiente secuencia: ajustar su bandera en verdadero. Debido a que no pueden hacerse suposiciones acerca de las velocidades relativas de los procesos concurrentes asincrónicos. dos coend. Si un sistema que utiliza este sistema de exclusión mutua estuviera controlando un vue lo espacial. por ejemplo. la posibilidad de que ocurra una postergación indefinida con el consecuente fallo del sistema no es admisible. hacer la prueba del while. A continuación se muestra una corrida para este programa. 3. p2quiere := true end. entrar en el cuerpo del ciclo while. Desde luego que la probabilidad de que tal operación ocurra es muy baja. cobegin uno. pero puede ocurrir. sleep(random(10)).8.2. pero puede presentarse otro problema devastador en potencia. (* dos *) begin nolineas := 0. el de postergación indefinida.writeln(‘Total de líneas =’.begin for lin := 1 to 30 do begin p2quiere := true.nolineas) end. retardarse. proceder en tándem. habrá que considerar todas las secuencias de ejecución posibles. p2quiere := falseend end. el algoritmo de Dekker (Programa dekker) maneja de manera elegante la exclusión mutua de dos procesos sin necesidad de ninguna instrucción especial de hardware. un marcapasos cardíaco o un sistema de control de tráfico aéreo. En tanto hacen esto. ALGORITMO DE DEKKER En sólo unas cuantas líneas de código. La ejecución del programa es: Total de líneas = 50 La exclusión mutua queda garantizada y no puede ocurrir el interbloqueo. luego. Por lo tanto. la cuarta versión es inaceptable.

Si el proceso uno es el favorecido. entra al ciclo del próximo while y permanece allí en tanto el proceso dos siga s iendo el proceso favorecido. (Luego veremos que el proceso dos debe acabar haciendo eso. p1quiere. Abraham Gamarra Moreno 81 . Estas instrucciones ajustan el proceso favorecido de vuelta al proceso uno y desconectan la bandera del proceso dos. p2quiere: boolean. sin embargo. El proceso dos acabará abandonando su sección crítica y ejecutará su código de salida de exclusión mutua. Si la bandera del proceso dos (que acaba de desconectarse) sigue aún desconectada. Aquí busca la variable pfavorecido. El proceso uno indica su deseo de entrar en su sección crítica. entonces el proceso uno entra en su sección crítica. que se utiliza para resolver los conflictos que surgen cuando ambos procesos desean entrar al mismo tiempo en sus secciones críticas. hasta que el proceso dos “humildemente”. esperando a que el proceso dos descon ecte su bandera. debido a que ahora es el proceso favorecido (recuerde que cuando el proceso dos abandonó su sección crítica.El algoritmo de Dekker resuelve la posibilidad de la postergación indefinida experimentada en la cuarta versión. el proceso uno está “sentado en el asiento del conductor”. program dekker. sin embargo. salta el cuerpo del if y ejecuta repetidamente la prueba del while. Entonces proced e con la prueba del while donde verifica si el proceso dos también quiere entrar. (* solución de Dekker al problema de la exclusion mutua *) var favorecido: integer.) Si el proceso uno determina que el proceso favorecido es el proceso dos. descubre que la bandera del proceso dos está conectada. entonces la bandera del proceso dos estará conectada y el proceso uno será obligado de nuevo a entrar en el cuerpo del while externo. Esto obliga al proceso uno a entrar al cuerpo del ciclo while. El proceso uno realiza ahora el while externo. permitiendo entrar en su sección crítica. Si la bandera del proceso dos está desconectada (ajustada en falso). ajustó pfavorecido al primero). el proceso uno permite al proceso dos entrar en su sección crítica. Sin embargo. entonces el proceso uno salta el cuerpo del ciclo while y entra en su sección crítica. Veamos como. El proceso uno puede entrar aho ra al while interno y conectar su propia bandera. al conectar su bandera (ajustarla en verdadero). desconecte su bandera. Mg. Al desconectar su propia bandera.En esta ocasión. donde desconecta su propia bandera. Así es que el proceso un o salta el cuerpo del if y ejecuta de forma repetida la prueba del while externo. entonces el proceso uno es forzado a entrar en el cuerpo del if. A continuación se muestra el listado del programa que utiliza el algoritmo de Dekker para la exclusión mutua. Supóngase. que cuando el proceso uno realice la prueba del while. si el pro ceso dos intentó reentrar rápidamente en su sección crítica.

nolineas) end. while favorecido = 2 do null. while favorecido = 1 do null. (* uno *) process dos. favorecido := 1.var lin: integer. begin for lin := 1 to 20 do begin p2quiere := true. dos coend. process uno. Total de líneas = 40 Considere la siguiente posibilidad interesante. Al salir el proceso uno del ciclo interno de espera. favorecido := 2. (* dos *) begin nolineas := 0. p2quiere := true end. p1quiere := true end. while p2quiere do begin p1quiere := false. begin for lin := 1 to 20 do begin p1quiere := true. A continuación se tiene la corrida del programa anterior. y que el proceso dos complete el ciclo e intente entrar de nuevo en su sección crítica.var lin: integer. p2quiere := falseend end.nolineas: integer. nolineas := nolineas + 1.writeln(‘Total de líneas = ‘. cobegin uno. while p1quiere do begin p2quiere := false. nolineas := nolineas + 1. p1quiere := falseend end. El proceso 82 SISTEMAS OPERATIVOS . favorecido := 1. es posible que pierda el procesador.

begin nolineas := 0. nolineas := nolineas + 1. process uno. si el proceso dos intenta entrar. Algoritmo de PetersonOtro interesante algoritmo para manejar la exclusión mutua entre dos procesos. begin for lin := 1 to 30 do begin band2:= true. nolineas := nolineas + 1. program peterson.dos conectará ent onces su bandera primero y entrará en su sección crítica. Como será el turno del proceso uno. este truco no dará como resultado una postergación indefinida. (* le da prioridad al otro proceso *) while band1 and (turno = 1) do null. (* le da prioridad al otro proceso *) while band2 and (turno = 2) do null. turno : integer. var lin: integer. band2 := false. Cuando el proceso uno obtenga de nuevo el procesador. band1. De esta manera. band2: boolean. band1 := false. (*Algoritmo de Peterson para la exclusión mutua de dos procesos *) var nolineas. del cual presentamos el siguiente listado y corrida. var lin: integer. desconectará su propia bandera y será obligado a en trar al ciclo interno de espera. turno := 1. band1:= false end end. conectará su bandera. (* anuncia el intento de entrar *) turno:= 1. y el proceso uno podrá entrar en su sección crítica. cobegin uno. Abraham Gamarra Moreno 83 . es el algoritmo de Peterson (programa ptrson). process dos. (* anuncia el intento de entrar *) turno:= 2. band2:= falseend end. Mg. begin for lin := 1 to 20 do begin band1:= true.

Si uno ha establecido band1 = true y también está ejecutando su enunciado while. permitiendo que dos entre en su sección crítica. Inicialmente band1 = band2 = false. pero no los dos. Para demostrar la propiedad (1) observamos que cada proceso entra en su sección crítica únicamente cuando band2 = false o turno = 1 para el proceso uno (band1 = false o turno = 2 para el proceso dos). entonces band1= false. dos entrará 84 SISTEMAS OPERATIVOS . entonces turno = 1 o turno = 2. En el listado de los procesos. Para comprobar las propiedades (2) y (3) observamos que se puede evitar que el proceso dos entre en su sección crítica únicamente cuando se queda en el ciclo while con la condición band1=true y turno = 1.writeln(‘Total de Líneas: ‘. ya que el valor de turno puede ser 1 o 2. band2 y turno. como dos no cambia el valor de la variable turno mientras ejecuta el ciclo while. Estas dos observaciones representan que uno y dos no pueden haber cumplido con éxito la condición del while aproximadamente al mismo tiempo. debió ejecutar con éxito la condición while. y dos puede entrar en su sección crítica. S in embargo. Si ambos procesos tratan de entrar a la vez. Observe también que. Si uno no está listo para entrar en la sección crítica. la otra ocurrirá. digamos uno. y esta condición persistirá mientras uno se encuentre en su sección crítica. entonces band1 = band2 = true. se asignará turno como 1 y 2 aproximadamente al mismo t iempo.dos coend. Por consiguiente. también deberá establecer turno=2. Empero. éste es el único ciclo. La salida del programa es: Total de Líneas: 50 Los procesos comparten las variables band1. se concluye que se conserva la exclusión mutua. Si uno vue lve a establecer band1 como true. Por lo tanto. si ambos procesos pueden estar en ejecución en sus secciones críticas al mismo tiempo. uno de los procesos. mientras que dos tuvo que ejecutar por lo menos un enunciado adicional (“turno=2”). volverá a establecer band1=false. Sólo una de estas asignaciones durará. Ahora demostraremos que esta solución es correcta. pero será reemplazada de inmediato. Si turno = 2.nolineas) end. se puede apreciar que para entrar en la sección crít ica. Necesitamos demostrar: (1) que se conserva la exclusión mutua. (2) que se respeta el requisito de progreso y (3) que se cumple el requisito de espera limitada. como en ese momento band1=true y turno=2. entonces uno entrará en la sección crítica. El valor eventual de turno decide a cual de los dos procesos se le permitirá entrar primero en su sección crítica. una vez que uno sale de su sección crítica. y el valor de turno no tiene relevancia (pero debe ser 1 o 2). el proceso uno primero asigna true a band1 y luego afirma que es el turno del proceso dos para entrar si así lo desea (turno=2).

Deitel M. como máximo. compatible con Java 2”. Resumen Los procesos son concurrentes si existen al mismo tiempo.en la sección crítica (progreso) des pués de. 1992. Tanenbaum A. “Estructuras de Datos en Java. Actividad • Analice los aspectos teóricos relacionados con los procesos. Peterson J. Segunda Edición. extendido por Ben Ari y modificado en la Universidad de Bradford (UK) por G. Segunda Edición. • • • Nexo La siguiente unidad académica analiza más algoritmos de exclusión mutua. UK: University of Bradford. lo cual significa que requieren una sincronización y cooperación ocasionales. Los procesos concurrentes pueden funcionar con total independencia unos de otros. Sistemas Operativos. Sus soluciones se presentan como programas concurrentes codificados utilizando el lenguaje Pascal concurrente desarrollado inicialmente por Wirth (Pascal-S). 1998.L. PASCAL-FC (Version 5): Language Reference Manual. o pueden ser asincrónicos. Davies (Pascal-FC). Sistemas Operativos Modernos. 85 Mg. Indicadores de logro El lector es capaz de modificar los programas que contienen los algoritmos de exclusión mutua. Abraham Gamarra Moreno . Allen Weiss. España. Editorial Addison Wesley. Galvin P. una entrada de uno (espera limitada). Mexico: Pearson Educación. Usa: Editorial Addison Wesley Iberoamericana. Se presentan muchos problemas importantes de asincronismo. 3ra Edición. Mark (2000). Silberschatz A. Introducción a los Sistemas Operativos. 2003. 1994. España: Addison Wesley Iberoamericana. Bibliografía Recomendada • Davies G.

Explique la siguiente figura: • Mencione las diferencias entre procesamiento concurrente y procesamiento en paralelo. Mencione un ejemplo de sección crítica. Demuestre con una corrida del programa (prueba de escritorio) como ocurre esto.• Pruebe los programas de los ejemplos anteriores y realice un análisis de su implementación. Justifique su respuesta. garantiza la exclusión mutua y no puede ocurrir el interbloqueo. Auto evaluación formativa Encuentre la solución a los siguientes problemas: PROBLEMA UNO • • Mencione 2 ejemplos de procesos. pero puede presentar el problema de postergación indefinida. Mencione un ejemplo de exclusión mutua. PROBLEMA TRES 86 SISTEMAS OPERATIVOS . PROBLEMA DOS • • • El programa “pro04” (Cuarto intento). Exponga 3 razones que justifiquen por qué es apropiado e importante el estudio de la concurrencia.

Si esto es posible. explique cómo podría suceder e indique si se trata de un ejemplo de postergación indefinida. ¿Puede realmente el proceso dos entrar en su sección crítica muchas veces antes que el proceso uno tenga su oportunidad?. Si no puede suceder. es posible que el proceso dos abandone su sección crítica. Mg. ejecute su código de entrada en exclusión mutua y entre en su sección crítica antes de el proceso uno tenga la oportunidad que ha estado esperando para entrar en su sección crítica. explique con precisión cómo se evita.En el algoritmo de Dekker. ejecute su código de salida de exclusión mutua. Abraham Gamarra Moreno 87 .

.

nprocs] of boolean.UNIDAD ACADEMICA 4 PROCESAMIENTO CONCURRENTE – PARTE 2 4. EXCLUSION MUTUA DE N-PROCESOS 4. A continuación se muestra un programa que utiliza el algoritmo de Dijkstra para la exclusión mutua. (* algoritmo de dijkstra para la exclusión mutua *) const nprocs=3. Dijkstra fue el primero en presentar una solución de software para la implementación de primitivas de exclusión mutua de n-procesos. j: integer. turno: integer. i. ALGORITMO DE DIJKSTRA. Mg. var ok: boolean.1. program dijkstra. Abraham Gamarra Moreno 89 .1. c: array[0.1. begin b[pnum] := false. procedure lock(pnum: integer). var b. nolineas : integer..

writeln(‘Total de Líneas: ‘. turno := 0 end.nprocs] of terminal. (* unlock *) process type terminal(n: integer). A continuación se muestran los resultados de la corrida del programa (obsérvese que son 4 procesos que ponen 20 líneas cada uno): Total de Líneas: 80 90 SISTEMAS OPERATIVOS . (* while *) c[pnum] := false. nolineas := nolineas + 1. (* lock *) procedure unlock(pnum: integer). (* terminal *) var p: array[0. var loop: integer. if b[turno] then turno := pnum end. for turno := 0 to nprocs do begin b[turno] := true.. for j := 1 to nprocs do if j <> pnum thenok := ok and c[j] until ok end.unlock(n) end end.nolineas)end. begin nolineas := 0. begin for loop := 1 to 20 do begin lock(n). turno := 0. cobegin for i := 0 to nprocs do p[i](i) coend. begin c[pnum] := true.repeat while turno <> pnum do begin c[pnum] := true. c[turno] := true end. b[pnum] := true. ok := true.

var Mg. En el caso de un empate.. n max(a1 . si Pi y Pj reciben el mismo número y si i < j.. an) es un (esto se número.. como el usado en las panaderías muy concurridas.nprocs] of integer. (* Exclusión mutua con el algoritmo de la panadería de Lamport *) const nprocs = 5.. Nos centraremos únicamente en los aspectos del algoritmo relacionados con un entorno centralizado. nuestro algoritmo es completamente determinista.nprocs] of boolean. tal implementa en el que k programa > ai para i=1. k. eleccion: array[1. Como los nombres de procesos son únicos y ordenados.. (en el programa bakery esta condición se implementa por medio de la función favorecido).d) si (a < c) o si (a = c) y b < d condición que determina si el proceso b con el boleto a es favorecido o no para entrar a la sección crítica con respecto al proceso d con el boleto c.4. y se atiende primero al que tenga el número menor. Al entrar en la tienda cada cliente recibe un número. Abraham Gamarra Moreno 91 . y ha sido apodado el algoritmo de la panadería de Lamport.b) < (c.. el algoritmo de la panadería no puede garantizar que dos procesos (clientes) no reciban el mismo número. Por desgracia.2. Las estructuras de datos comunes son: var boleto: array[1. entonces primero se servirá a Pi. ALGORITMO DE LAMPORT Lamport desarrolló una solución que es particularmente aplicable a los sistemas de procesamiento distribuido. . mediante la función .. respectivamente. Por conveniencia. Es decir. .1. Al principio. El algoritmo usa un sistema de “toma de boleto”. program bakery. definimos la siguiente notación: n (a. primero se atiende el proceso con el nombre menor.n max) A continuación se muestra un listado del programa para resolver el mismo problema de exclusión mutua (conteo de líneas) mediante el algoritmo de la panadería de Lamport. a estas estructuras se les asigna un valor inicial 0 y false.

(* favorecido *) begin for lp := 1 to 20 do begin eleccion[esteproc] := true. begin if (boleto[i] = 0) or (boleto[i] > boleto[j]) then favorecido := false else if boleto[i] < boleto[j] then favorecido := trueelse favorecido := (i < j) end. while favorecido(otroproc.nprocs] of boolean. boleto[esteproc] := max. eleccion: array[1. largo: integer. lp: integer. end.nprocs] of Entrada. for lp := 1 to nprocs do 92 SISTEMAS OPERATIVOS .nprocs] of integer. esteproc) do null.. (* Entrada *) var turnos: array[1. j: integer): boolean. lp: integer. for otroproc := 1 to nprocs do begin while eleccion[otroproc] do null. var otroproc.. for i := 1 to nprocs do if boleto[i] > largo then largo := boleto[i]. process type Entrada(esteproc: integer). boleto[esteproc] := 0 end end. nolineas: integer. function max: integer.. begin nolineas := 0.boleto: array[1. (* max *) function favorecido(i. max := largo + 1 end. eleccion[esteproc] := false. var i. begin largo := 0. nolineas := nolineas + 1.

eleccion[lp] := false. opera de la siguiente manera: if (uno o más procesos están en espera en S) then (deja proseguir a uno de estos procesos) else S:=S+1 Supondremos que hay una disciplina de colas del primero en entrar .1 else (espera en S) La operación signal en el semáforo S.primero en salir para los procesos que esperan a completar un wait(S). El programa sem01 que se lista a continuación. es aplicada en wait(S) y signal(S). escrito wait(S). Un semáforo es una variable protegida cuyo valor puede ser accesado y alterado tan sólo por las operaciones wait. opera de la siguiente manera: if S > 0 then S:=S .2.begin boleto[lp] := 0. escrito signal(S). sólo uno podrá proseguir. La ejecución de las instrucciones wait y signal son indivisibles. los otros permanecerán en espera. S. (* solución por semáforos al problema de la exclusión mutua *) Mg. En general. program sem01. La operación wait en el semáforo S. Los semáforos contadores pueden tomar valores enteros no negativos. muestra como pueden utilizarse los semáforos para aplicar la exclusión mutua. Abraham Gamarra Moreno 93 . SEMÁFOROS Dijkstra extractó las nociones clave de la exclusión mutua en su concepto de semáforo. end. La exclusión mutua en el semáforo.nolineas:4)end. donde se controlan los cambios de estado de un proceso. Los semáforos binarios sólo pueden tomar los valores 0 y 1. Si varios procesos intentan ejecutar wait(S) al mismo tiempo. writeln(‘Total de Líneas: ‘. cobegin for lp := 1 to nprocs do turnos[lp](lp)coend. Los semáforos y las operaciones de semáforos pueden implementarse en software o hardware. signal y una operación de inicialización del semáforo initial. A continuación se muestran los resultados de la corrida del programa: Total de Líneas: 100 4. se implementan en el núcleo del sistema operativo.

A continuación se muestran los resultados de la corrida del programa.nolineas) end. Total de Líneas = 40 4. (* se inicializa el semáforo *) cobegin uno. Algunos procesos deben despertar al proceso bloqueado.1). dos coend. nolineas := nolineas + 1.1. se bloquea a sí mismo para esperar a que termine esta operación. (* Espera por el semáforo *) nolineas := nolineas + 1. Supóngase que otro proceso es capaz de detectar que ese acontecimiento ya ha ocurrido. var lin: integer. En forma más general. Tal interacción es un ejemplo de un protocolo de bloqueo/despertar.supóngase que un proceso desee ser informado de la ocurrencia de un evento. (* declaración del semáforo *) process uno. begin for lin := 1 to 20 do egin wait(mutex). writeln(‘Total de Líneas = ‘.2. begin for lin := 1 to 20 do begin wait(mutex). SINCRONIZACIÓN DE PROCESOS CON SEMÁFOROS Cuando un proceso emite una petición de entrada/salida. mutex: semaphore. El siguiente programa (sem02) muestra cómo pueden utilizarse la s operaciones de semáforos para implementar 94 SISTEMAS OPERATIVOS . (* sección crítica *) signal(mutex) (* libera el semáforo *) end end. var lin: integer. (* dos *) begin nolineas := 0.var nolineas: integer. (* uno *) process dos. signal(mutex) end end. initial(mutex.

program sem02. writeln(‘Otras cosas del Dos. end. Abraham Gamarra Moreno 95 . así es que wait(mutex).end.un mecanismo simple de sincronización de bloqueo/despertar de dos procesos. La ejeución del programa es: Cosas Cosas Otras Otras preliminares de Uno preliminares del Dos cosas del Dos. (* uno *) process dos. cosas del Uno El proceso uno ejecuta algunas cosas preliminares y después ejecuta wait(mutex). dos coend. y proceso uno proseguirá sin tener que esperar a que ocurra el evento. begin writeln(‘Cosas preliminares de Uno’). end.’). Obsérvese que este mecanismo trabaja incluso cuando proceso dos detecta y señala el evento antes de que el proceso uno ejecute wait(mutex). begin writeln(‘Cosas preliminares del Dos’). el semáforo habrá sido incrementado de 0 a 1.0). cobegin uno. (* Proceso de sincronización de bloqueo/despertar con semáforos *) var mutex: semaphore. (* declaración del semáforo *) process uno. (* dos *) begin initial(mutex. Esto permite proceder al proceso uno. Mg. El semáforo ha sido inicializado a cero. (* Espera por el semáforo *) writeln(‘Otras cosas del Uno’). de modo que el proceso debe esperar. El proceso dos ejecuta signal(mutex) para señalar que el evento ha ocurrido. signal(mutex). decrementa el semáforo de 1 a 0. wait(mutex).

Suponga que Uno ejecuta wait(S) y luego Dos ejecuta wait(Q). consideremos un sistema que consta de dos procesos.2.2. cuando Dos ejecuta wait(S). debe esperar a que Dos ejecute signal(Q). signal(Q) signal(S) Dos wait(Q) wait(S) . con valor inicial 1: Uno wait(S) wait(Q) . BLOQUEOS MUTUOS Y BLOQUEOS INDEFINIDOS La implantación de un semáforo con una cola de espera puede dar como resultado una situación donde dos o más procesos esperen indefinidamente un suceso que sólo puede ocacionar uno de los procesos en espera. Este tipo de listado se presenta para determinar.(* declaración de los semáforos *) process Uno. El suceso en cuestión consiste en la ejecución de una operación signal. corresponde a la dirección de memoria de esa instrucción en lenguaje de máquina. . Q: semaphore. de cada proceso en el programa fuente. signal(S) signal(Q) . Uno y Dos están en bloqueo mutuo. A continuación se muestra el listado de un programa sencillo que ilustra el concepto de bloqueo mutuo. Para ilustrarlo. . La segunda columna de números en el listado del compilador. se dice que los procesos están en bloqueo mutuo. donde ocurre el bloqueo. cada uno con acceso a dos semáforos. 96 SISTEMAS OPERATIVOS . Decimos que un conjunto de procesos está en un estado de bloqueo mutuo cuando cada uno de los procesos del conjunto está esperando un suceso que únicamente puede ser provocado por otro proceso del conjunto. Cuando se llega a este estado. Cuando Uno ejecuta wait(Q). el punto exacto.4. debe esperar a que Uno ejecute signal(S). (* Proceso de sincronización de bloqueo/despertar con semáforos *) var S. De manera parecida. en que los procesos pueden esperar indefinidamente dentro del semáforo. . program sem03. S y Q. Uno y Dos. Otro problema relacionado con el bloqueo mutuo es el bloqueo indefinido o inanición. Como estas operaciones de signal no pueden ejecutarse. El bloqueo indefinido se puede presentar si añadimos y eliminamos procesos de la lista aso ciada con un semáforo en orden LIFO.

1). (* Espera por el semáforo *) writeln(‘El Dos toma Q y espera por S’). signal(Q). Entramos al Uno Entramos al Dos El Uno toma S y espera por Q Uno entra a la sección crítica El Dos toma Q y espera por SDos entra a la sección crítica Program terminated normally Type r and RETURN to rerun r Entramos al UnoEntramos al Dos El Dos toma Q y espera por S Dos entra a la sección crítica El Uno toma S y espera por Q Uno entra a la sección crítica Program terminated normally Type r and RETURN to rerun r Mg. (* dos *) begin initial(S. wait(S). writeln(‘Uno entra a la sección crítica ‘). begin writeln(‘Entramos al Dos’). end.begin writeln(‘Entramos al Uno’). end.wait(Q). (* Espera por el semáforo *) writeln(‘El Uno toma S y espera por Q’).wait(S). signal(Q). Abraham Gamarra Moreno 97 . A continuación se muestran diferentes corridas del programa hasta obtener un bloqueo mutuo. signal(S).1).end.Dos coend. initial(Q. writeln(‘Dos entra a la sección crítica ‘). signal(S). (* uno *) process Dos. cobegin Uno. wait(Q).

Suponga que se comunican por medio de la variable compartida. buffer< /I>. Suponga que un proceso. un productor. cuando un procedimiento llama a otro y le trasmite datos. El productor agrega datos en el arreglo buffer.3. un consumidor.Entramos al Uno El Uno toma S y espera por Q Entramos al Dos El Dos toma Q y espera por S Abnormal halt in process dos with pc = 28 Reason: deadlock See pmdfile for post-mortem report En estas condiciones se obtiene el bloqueo mutuo antes mencionado. está generando información que utiliza un segundo proceso. LA RELACIÓN PRODUCTOR . los procedimientos son parte de un proceso simple y no operan de forma concurrente.Interpreter Version P5.CONSUMIDOR En un programa secuencial. los problemas son mucho más complejos.3 Abnormal halt in process dos with pc = 28 Reason: deadlock Main program Status: awaiting process termination Process uno Status: activepc = 10 Process suspended on: q (semaphore) Process dos Status: activepc = 28 Process suspended on: s (semaphore) Global variables q s = = 0 0 4. Pero cuando un proceso transmite datos a otro. Considérese la siguiente relación productor consumidor. el consumi98 SISTEMAS OPERATIVOS . El intérprete ofrece un diagnóstico de esta condición de la siguiente forma: Pascal-FC post-mortem report on sem03 .2. Tal transmisión es un ejemplo de comunicación interprocesos.

listos controla la sincronización de los procesos para determinar si existen datos en el buffer. Los procesos utilizan la variable compartida buffer.buffmax] of integer. (* Solución al problema del Productor . el consumidor lo lee y lo imprime de inmediato. El productor va poniendo en el arreglo los números del 65 al 90 (código ASCII de las letras A-Z) mientras que el consumidor los va tomando e imprimiendo. Pero supóngase que las velocidades de los procesos son dispares. el comportamiento que deseamos aquí es que el productor y el consumidor cooperen de forma tal que los datos escritos en buffer no se dupliquen ni se pierdan. mutex: semaphore. beginch := buffer[sigsale]. La aplicación de tal comportamiento se conoce como sincronización de procesos. Si el consumidor está operando con más rapidez que el productor. El siguiente programa (pcsem) muestra un programa concurrente que utiliza las operaciones de semáforos para implementar una relación productor . Si cada vez que el productor deposita un dato en buffer. sigsale: integer.. o que sus velocidades de ejecución sean muy parecidas. program pcsem. entonces la salida impresa representará fielmente la corriente de números generada por el productor. el productor podría sobreescribir los datos previos antes de que el consumidor tenga la oportunidad de leerlos e imprimirlos. el consumidor puede leer e imprimir datos antes de que el productor los deposite. Aquí hemos utilizado tres semáforos: mutex se utiliza para aplicar el acceso de exclusión mutua a la variable compart ida buffer.Consumidor mediante el uso de semáforos*) const buffmax = 5. procedure pon(ch: integer). Si el productor está operando más rápido q ue el consumidor. sigentra := (sigentra + 1) mod (buffmax + 1) end. Es posible que los procesos productor y consumidor trabajen bien en tándem. espacios controla en la sincronización la existencia de espacio en el buffer. Como es evidente. listos: semaphore.consumidor. (* apuntadores a buffer para el manejo de la cola*) espacios. sigentra.dor lee los datos de buffer y los imprime. un productor muy veloz podría hacer esto muchas veces. Abraham Gamarra Moreno 99 . Mg. var buffer: array[0. con lo cual muchos resultados se perderían. (* pon *) procedure toma(var ch: integer). begin (* el buffer es una cola circular *) buffer[sigentra] := ch.

(* Entrada a la sección crítica *) pon(local). (* consumidor *) begin initial(espacios.consumidor coend end.buffmax + 1). Las letras minúsculas indican el dato y el momento en que el consumidor tomó el dato. (* Entra en la sección crítica *) toma(local). (* Sección crítica *) signal(mutex). (* Sale de sección crítica *) signal(listos) (* Avisa que ya hay un dato listo *)end end. (* sale de la sección crítica *) signal(espacios). Las letras mayúsculas corresponden al dato y el momento en que el productor pone en el buffer el dato. var local: integer. signal(mutex).1). La salida es:AaBCbDcEFdGeHfIgJhKiLjMkNlmOnPoQpRqSrTsUtVuWvXwYxZyz AaBbCcDEdFeGfHgIhJiKjLkMlNmOnPoQpRSqTrUsVtWuXYvwZxyz ABaCbDcEdFeGfHgIhJiKjLkMlNmOnPoQpRqSrTsUtVuWvXYwZxyz AaBCbDcEdFeGfHgIhJKLijMNkOlPmQnRoSpTqUrVWsXtYuZvwxyz 100 SISTEMAS OPERATIVOS .0). enduntil local = 90. sigentra := 0. var local: integer. (* toma *) process productor. begin for local := 65 to 90 do begin wait(espacios). initial(mutex. sigsale := 0. begin repeat begin wait(listos). writeln end. cobegin productor. (* Avisa que hay un espacio *) write(chr(local+32)). initial(listos. (* productor *) process consumidor.sigsale := (sigsale + 1) mod (buffmax + 1) end. (* Sección crítica *) write(chr(local)). A continuación se muestran diferentes corridas de este programa. (* Espera que haya espacio *) wait(mutex). (* Espera que haya datos listos *) wait(mutex).

Abraham Gamarra Moreno 101 . PROGRAMACIÓN CONCURRENTE Anteriormente se ha presentado algunos algoritmos para la implementación de las primitivas de exclusión mutua. Cada operación wait decrementa el semáforo en 1. Mg. indicando qu e ha extraído otro recurso de la bolsa y está siendo usado por un proceso. Los recursos en Pascal-FC brindan algunos de los comportamientos del protected record del lenguaje Ada.2. sugerida por Dijkstra. y se mencionaron los semáforos de Dijkstra. en lugar de las variables de condición. y su presencia en los programas concurrentes dificulta aún más el problema de probar la corrección del programa. Cada operación signal incrementa el semáforo en 1. Este tema no será tratado en el presente libro. Tal vez.4. la más importante de estas construcciones sea el monitor. El uso incorrecto de estas primitivas. ya sea intensionado o accidental. del acceso a datos encapsulados. y puede ser asignado a otro proceso. pero las condiciones de sincronización se realizan por barrera (barriers) en los procedimientos. podría corromper la operació n de un sistema concurrente. garantizada por el compilador. Por este motivo. indicando que un proceso ha devuelto un recurso a la bolsa. Los recursos son similares a los monitores en que ellos proporcionan una exclusión mutua.4. SEMÁFOROS CONTADORES Los semáforos contadores son particularmente útiles cuando un recurso va a ser asignado desde una bolsa de recursos idénticos. Pero estos métodos tienen varias debilidades: son tan primitivos que es difícil expresar la solución de problemas de concurrencia más complejos. y luego refinada por Hoare. 4. después por Brinch Hansen.3. Este tema no será tratado en el presente libro. los investigadores se han entregado a la tarea de buscar construcciones de exclusión mutua de más alto nivel que • • faciliten expresar los problemas de concurrencia complejos faciliten probar la corrección del programa resulte muy difícil (cuando no imposible) su uso incorrecto o corrupción por parte del usuario. Si se intenta una operación wait cuando el semáforo ha sido decrementado hasta cero. El semáforo se inicializa para el número de recursos de la bolsa. el proceso debe esperar hasta que se devuelva algún recurso a la bolsa por medio de una operación signal.

1. obviamente.4. Un filósofo sólo puede coger un palillo a la vez y. Ocasionalmente. un filósofo tiene hambre y trata de coger los dos palillos que están más cerca de él (los palillos colocados entre él y sus vecinos de la derecha y de la izquierda). Figura 4. Cuando termina de comer. 4.1.4. no interactúa con sus colegas. coloca ambos palillos sobre la mesa y comienza a pensar otra vez (Figura 4.4. y también sobre la mesa hay cinco palillos chinos. Cuando un filósofo hambriento tiene sus dos palillos al mismo tiempo come sin soltarlos. Cuando un filósofo piensa. EL PROBLEMA DE LOS FILÓSOFOS COMELONES Cinco filósofos pasan su vida pensando y comiendo.1). En el centro de la mesa se encuentra una fuente de arroz. Los filósofos comparten una mesa circular rodeada por cinco sillas. una para cada uno de ellos. La situación de los Filósofos comelones. no puede ser el que está en la mano de un vecino. PROBLEMAS CLÁSICOS. El problema de los filósofos comelones (comensales) se considera un pro102 SISTEMAS OPERATIVOS .

N] of semaphore. (* binario *) I : integer. (* Filosofos comelones .4] of semáforo.semáforos versión 1 *) const N = 5. (* PENSANDO *) wait(palillo[numero]). (* COMIENDO *) signal(palillo[numero]). pero no por su importancia práctica sino porque es un ejemplo de una gran clase de problemas de control de concurrencia. Un filósofo trata de coger el palillo ejecutando una operación wait en ese semáforo. var palillo : array [1.numero). begin for I := 1 to N do initial(palillo[I]. process type filosofos(numero : integer).. sleep(random(5)). cobegin for I := 1 to N doprocfil[I](I). los datos compartidos son: var palillo:array [0. Así...numero). A continuación se presenta un programa que simula esta situación. Abraham Gamarra Moreno .1). sleep(random(5)).blema de sincronización clásico. wait(palillo[(numero mod N) + 1]).N] of filosofos. La salida es: Pensando Pensando Pensando Pensando Comiendo Pensando Pensando Comiendo el el el el el el el el 1 5 2 3 1 4 1 2 103 Mg. begin repeat writeln(‘Pensando el ‘. writeln(‘Comiendo el ‘. signal(palillo[(numero mod N) + 1]). forever end. donde todos los elementos de palillo reciben un valor inicial de 1. suelta sus palillos ejecutando signal en los semáforos correspondientes.Una solución sencilla consiste en representar cada palillo con un semáforo. program Filo01. coendend. (* filosofos *) var procfil: array[1.

program Filo02.Comiendo el Comiendo Pensando Pensando Pensando Comiendo 4 el el el el 4 el 1 2 1 3 5 2 4 5 2 3 5 1 2 2 4 4 5 1 3 5 1 2 Comiendo el Comiendo el Pensando el Comiendo el 3 Pensando el Comiendo el Pensando el 1 Comiendo el Pensando el 4 Comiendo el Pensando el Pensando el Comiendo el 3 Pensando el Comiendo el Pensando el Pensando el Comiendo el Comiendo el Comiendo el Pensando el Pensando el 5 Comiendo el Pensando el 3 Aunque esta solución garantiza que dos vecinos no pueden comer simultáneamente. Suponga que los cinco filósofos tienen hambre al mismo tiempo y cada uno coge el palillo que está a su izquierda. Se aclara que cualquier solución satisfactoria para este problema debe eliminar la posibilidad de que uno de ellos muera de hambre.semáforos versión 2 *) const N = 5. Permitir que cuatro filósofos como máximo. Cuando cada filósofo trata de coger el palillo a su derecha. con diferentes algoritmos y con diferentes elementos del lenguaje para la sincronización de procesos. se sienten a comer al mismo tiempo. su ejecución se aplazará eternamente. Una solución libre de bloqueos mutuos no la elimina necesariamente. var 104 SISTEMAS OPERATIVOS . todos los elementos del arreglo palillo serán iguales a cero. (* Filósofos comelones . hay que rechazarla porque existe la posibilidad de crear un bloqueo mutuo. A continuación se presentan varias posibles soluciones.

1). Abraham Gamarra Moreno 105 . cobegin for I := 1 to N doprocfil[I](I). initial(sillaslibre. La salida es: Pensando Pensando Pensando 1 Comiendo 5 Pensando Comiendo Comiendo Comiendo Pensando Comiendo Pensando Comiendo 5 Pensando Pensando Comiendo Comiendo Pensando Comiendo Pensando Comiendo Comiendo el Pensando el el 4 el Pensando el el 4 2 3 el 4 el 4 el 2 el 1 el 2 el 3 el 4 el Pensando el el el el el el el el el el 3 5 3 2 3 4 4 4 1 1 Mg.N] of filosofos. begin for I := 1 to N do initial(palillo[I]. process type filosofos(numero : integer).numero:2). signal(palillo[(numero mod N) + 1]).N . (* PENSANDO *) wait(sillaslibre).palillo : array [1. (* filosofos *) var procfil: array[1. wait(palillo[numero]).1). sleep(random(5)).N] of semaphore. coendend. (* general *) I : integer. sleep(random(5)). wait(palillo[(numero mod N) + 1]).. begin repeat writeln(‘Pensando el ‘. writeln(‘Comiendo el ‘. (* binario *) sillaslibre : semaphore. (* COMIENDO *) signal(palillo[numero]).numero:2).. signal(sillaslibre) forever end.

La razón para el uso de enespera 106 SISTEMAS OPERATIVOS . que cuenta el número de clientes en espera (sin incluir al cliente de la silla del peluquero.4. Si no hay clientes presentes. si es que los hay. También necesitamos una variable. Cuando llega un cliente. barberos. una silla de peluquero y n sillas para que se sienten los clientes en espera. el b arbero se sienta en su silla de peluquero y se duerme. ellos se sientan (si hay sillas desocupadas). que se utiliza para la exclusión mutua. enespera. El problema consiste en programar al barbero y los clientes sin entrar en condiciones de competencia.Pensando el 2 Pensando el 1 Comiendo el 3 Pensando el 4 Comiendo el 5 Comiendo el 2 Pensando el 3 Pensando el 2 Comiendo el 4 Pensando el 5 Comiendo el 1 Pensando el 1 Comiendo el 3 Pensando el 4Comiendo el 2 Pensando el 3 Comiendo el 4 Comiendo el 1 Pensando el 2 Comiendo el 3 Pensando el 4 Pensando el Comiendo el 5 1 Comiendo el 2 Pensando el 3 Pensando el Comiendo el 4 5 Comiendo el 1 Pensando el 2 Comiendo el 3 Pensando el 4 Comiendo el 5 Pensando el 1 Comiendo el 2 Pensando el 3 4. La peluquería tiene un barbero. Esto es en esencia una copia de clientes. éste debe despertar al barbero dormilón. que no está esperando). Si llegan más clientes mientras el barbero corta el cabello de un cliente. el número de barberos inactivos y que esperan clientes (0 o 1) y mutex.2. que también cuenta el número de clientes que esperan. Esta solución utiliza tres semáforos: clientes. EL BARBERO DORMILÓN Otro de los problemas clásicos de la comunicación entre procesos ocurre en una peluquería.

ejecuta el procedimiento Barbero. writeln(‘Corta el pelo’). ya que intenta continuar con el s iguiente cliente. que inicia procurando que mutex entre a una región crítica. process Barbero. hasta que el otro haya liberado a mutex. wait(mutex). begin Mg. Cuando el cliente libera a mutex. enespera := enespera . después se va a dormir. el cliente sale del procedimiento y deja la peluquería. Cuando el barbero abre su negocio por la mañana. signal(mutex). Si otro cliente llega poco tiempo después. until enespera = 0 end. Abraham Gamarra Moreno 107 . (* declaración de los semáforos *) enespera:integer. NC = 15. Sin embargo. en esta solución. el barbero se va a dormir. con lo que despierta al barbero. En este momento. program pelucas. un cliente que entra en la peluquería debe contar el número de clientes que esperan. No existe un ciclo para el cliente. begin repeat wait(clientes). El cl iente verifica entonces si el número de clientes que esperan es menor que el número de sillas. ordena algunas cosas e inicia el corte de pelo. varclientes. signal(barberos). Si esto no ocurre. tanto el cliente como el barbero están despiertos. el segundo no podrá hacer nada. Cuando llega el primer cliente. lo que establece un bloqueo en el semáforo clientes hasta que alguien llega. el barbero lo retiene. libera mutex y sale sin cortarse el pelo. Si no. mutex: semaphore.1. puesto que el corte de pelo es una operación idempotente.es que no hay forma de leer el valor activo de un semáforo. el barbero hace otro corte de pelo. él ejecuta Cliente. se va. Al terminar el corte. (* Barbero *) process type Cli(n:integer). él se queda. (* Problema del barbero dormilon *) const sillas = 4. sí existe un ciclo para el barbero. el cliente incrementa la variable entera enespera. barberos. Si existe otro cliente presente. Luego realiza un signal en el semáforo clientes. Si es menor que el número de sillas. en caso contrario. Si existe una silla disponible.

for i:=0 to NC do Cliente[i](i). i:integer.NC] of Cli.n:2). cobegin Barbero. signal(mutex). (* Cli *) var Cliente:array [0. end else begin writeln(‘Encuentra lleno el ‘. coend. initial(mutex.1). initial(barberos. if (enespera < sillas) then begin enespera := enespera + 1.signal(mutex). begin enespera := 0. wait(barberos).n:2). signal(clientes). end.wait(mutex). initial(clientes.1). La ejecución es: Toma asiento el15 Toma asiento el 4 Toma asiento el 5 Encuentra lleno el 13 Toma asiento el14 Corta el pelo Toma asiento el 1 Encuentra lleno el 10 Corta el pelo Toma asiento el 8 Corta el pelo Toma asiento el 12 Encuentra lleno el 3 Corta el pelo Toma asiento el 0 Encuentra lleno el 6 Corta el pelo Toma asiento el 7 Encuentra lleno el 11 Corta el pelo Toma asiento elCorta el pelo Toma asiento el 2 9 Corta el pelo 108 SISTEMAS OPERATIVOS .0)..end. writeln(‘Toma asiento el’. end.

Abraham Gamarra Moreno 109 . Los semáforos contadores pueden tomar valores enteros no negativos. Un semáforo es una variable protegida cuyo valor puede ser accesado y alterado tan sólo por las operaciones wait. Dijkstra extractó las nociones clave de la exclusión mutua en su concepto de semáforo.Corta el pelo Corta el pelo Corta el pelo Program terminated normally Toma asiento el 0 Toma asiento el 2 Toma asiento el 1 Corta el pelo Toma asiento el13 Toma asiento el 3 Encuentra lleno el 11 Encuentra lleno el 15 Corta el pelo Toma asiento el 4 Encuentra lleno el 14 Corta el pelo Toma asiento el 5 Corta el pelo Toma asiento el 6 Corta el pelo Toma asiento el 7 Corta el pelo Toma asiento el12 Encuentra lleno el 8 Corta el pelo Toma asiento el 9 Encuentra lleno el 10 Corta el pelo Corta el pelo Corta el pelo Corta el pelo Program terminated normally Resumen Dijkstra fue el primero en presentar una solución de software para la implementación de primitivas de exclusión mutua de n-procesos. Lamport desarrolló una solución que es particularmente aplicable a los sistemas de procesamiento distribuido. signal y una operación de inicialización del semáforo initial. Los semáforos binarios sólo pueden tomar los valores 0 y 1. Mg.

Indicadores de logro El lector es capaz de explicar y modificar los algoritmos de exclusión mutua de n procesos y es capaz de modificar los programas con semáforos y los problemas clásicos de concurrencia. compatible con Java 2”. España. explique con una corrida que sucedería para este problema si no son atómicas. Auto evaluación formativa Encuentren la solución a los siguientes problemas: PROBLEMA UNO En el problema del productor. • • • Nexo La siguiente unidad académica trata de la administración de la memoria. 110 SISTEMAS OPERATIVOS . Bibliografía Recomendada • Davies G. Galvin P. Deitel M. Sistemas Operativos Modernos. 2003. para el almacenamiento real. las operaciones wait y signal deben ser atómicas. Segunda Edición. 1998. Allen Weiss. Usa: Editorial Addison Wesley Iberoamericana. 1994. 1992. España: Addison Wesley Iberoamericana. Segunda Edición. Sistemas Operativos. Silberschatz A. “Estructuras de Datos en Java. UK: University of Bradford. Introducción a los Sistemas Operativos. PASCAL-FC (Version 5): Language Reference Manual. Tanenbaum A. Mark (2000). Peterson J.consumidor implementada con semáforos. Editorial Addison Wesley. 3ra Edición. Mexico: Pearson Educación. Actividad Pruebe los programas de los ejemplos anteriores y realice un análisis de su implementación.

PROBLEMA TRES A través de una prueba de escritorio muestre como se obtiene la exclusión mutua en EL BARBERO DORMILON.PROBLEMA DOS A través de una prueba de escritorio muestre como se obtiene la exclusión mutua en el problema de los filósofos comelones. Abraham Gamarra Moreno 111 . Mg.

112 SISTEMAS OPERATIVOS .

O. Abraham Gamarra Moreno .UNIDAD ACADEMICA 5 ADMINISTRACIÓN DE LA MEMORIA: ALMACENAMIENTO REAL 5. que administra la memoria se llama “administrador de la memoria”: • Lleva un registro de las partes de memoria que se están utilizando y de aquellas que no. 113 • Mg. “memoria primaria” o “memoria real” de un sistema ha sido y es uno de los factores más importantes en el diseño de los S. Los programas y datos deben estar en el almacenamiento principal para: • • Poderlos ejecutar. La parte del S. Referenciarlos directamente.1. Los términos “memoria” y “almacenamiento” se consideran equivalentes. O. Se considera “almacenamiento secundario” o “almacenamiento auxiliar” al generalmente soportado en discos. INTRODUCCIÓN AL ALMACENAMIENTO REAL La organización y administración de la “memoria principal”. Asigna espacio en memoria a los procesos cuando estos la necesitan.

1.2. 114 SISTEMAS OPERATIVOS . Figura 5.1). que posee las siguientes características: • • Es más rápida y costosa que la memoria principal. JERARQUÍA DE ALMACENAMIENTO Los programas y datos tienen que estar en la memoria principal para poder ejecutarse o ser referenciados. Los programas y datos que no son necesarios de inmediato pueden mantenerse en el almacenamiento secundario. Los sistemas con varios niveles de almacenamiento requieren destinar recursos para administrar el movimiento de programas y datos entre niveles (ver Figura 5. Organización jerárquica del almacenamiento.• Libera espacio de memoria asignada a procesos que han terminado. El almacenamiento principal es más costoso y menor que el secundario pero de acceso más rápido. Un nivel adicional es el “caché” o memoria de alta velocidad. 5. Impone al sistema un nivel más de traspaso: Los programas son traspasados de la memoria principal al caché antes de su ejecución.

3. Las “estrategias de búsqueda” están relacionadas con el hecho de cuándo obtener el siguiente fragmento de programa o de datos para su inserción en la memoria principal. Estrategias de reposición. • Al utilizar memoria caché se espera que: La sobrecarga que supone el traspaso de programas de un nivel de memoria a otro sea mucho menor que la mejora en el rendimiento obtenida por la posibilidad de una ejecución mucho más rápida en la caché.Estrategias de búsqueda por demanda. • • Estrategias de colocación. Abraham Gamarra Moreno 115 . . 5. Se dividen en las siguientes categorías: • Estrategias de búsqueda: .Estrategias de búsqueda anticipada. Mg. Se considera que la “búsqueda anticipada” puede producir un mejor rendimiento del sistema. Las “estrategias de reposición” están relacionadas con la determinación de qué fragmento de programa o de datos desplazar para dar lugar a los programas nuevos.• Los programas en la memoria caché ejecutan mucho más rápido que en la memoria principal. Las “estrategias de colocación” están relacionadas con la determinación del lugar de la memoria donde se colocará (cargará) un programa nuevo. ESTRATEGIAS DE ALMACENAMIENTO ADMINISTRACIÓN DEL Están dirigidas a la obtención del mejor uso posible del recurso del almacenamiento principal. En la “búsqueda por demanda” el siguiente fragmento de programa o de datos se carga al almacenamiento principal cuando algún programa en ejecución lo referencia.

2). En la “asignación no contigua” un programa se divide en varios bloques o “segmentos” que pueden almacenarse en direcciones que no tienen que ser necesariamente adyacentes. ASIGNACIÓN CONTIGUA VERSUS NO CONTIGUA DE ALMACENAMIENTO En la “asignación contigua” cada programa ocupa un bloque contiguo y sencillo de localizaciones de almacenamiento. Figura 5.2. 116 SISTEMAS OPERATIVOS .Los periféricos de e / s frenan la ejecución de los procesos ya que comparativamente la cpu es de magnitud más rápida que los dispositivos de e / s. por lo que es más compleja pero más eficiente que la asignación continua.5. que ya poseen desarrollado el “sistema de control de entrada / salida”: IOCS: input / output control system (ver Figura 5. Los sistemas de un solo usuario desperdician gran cantidad de recursos computacionales debido a que (ver Figura 5. Asignación contigua de almacenamiento de un solo usuario.3): • Cuando ocurre una petición de e / s la cpu normalmente no puede continuar el proceso hasta que concluya la operación de e / s requerida.4. ASIGNACIÓN CONTIGUA DE ALMACENAMIENTO DE UN SOLO USUARIO Se consideran S. 5. O.5. El tamaño de los programas está limitado por la cantidad de memoria principal.

• • • 5. Se incrementa la utilización de la cpu y la capacidad global de ejecución del sistema.6. Existe paralelismo entre el procesamiento y la e / s.Figura 5. MULTIPROGRAMACIÓN DE PARTICIÓN FIJA Los sistemas de “multiprogramación” permiten que varios procesos usuarios compitan al mismo tiempo por los recursos del sistema: • Un trabajo en espera de e / s cederá la cpu a otro trabajo que esté listo para efectuar cómputos. Abraham Gamarra Moreno 117 .6.1.3. Utilización de la CPU en un sistema de un solo usuario. Es necesario que varios trabajos residan a la vez en la memoria principal. MULTIPROGRAMACIÓN DE PARTICIÓN FIJA: TRADUCCIÓN Y CARGA ABSOLUTAS Las “particiones” del almacenamiento principal: • Son de tamaño fijo. Mg. 5.

• Alojan un proceso cada una. El S. • • • 118 SISTEMAS OPERATIVOS . Confieren más flexibilidad en el armado de la carga de procesos.4. Son más complejos que los absolutos. Figura 5.6). tal como se muestra en la Figura 5.La cpu se cambia rápidamente entre los procesos creando la ilusión de simultaneidad. ensambladores y cargadores de relocalización: • Se usan para producir programas relocalizables que puedan ser ejecutados en cualquier partición disponible de tamaño suficiente para aceptarlos (ver Figura 5.6. MULTIPROGRAMACIÓN DE PARTICIÓN FIJA: TRADUCCIÓN Y CARGA RELOCALIZABLES Los compiladores. Los trabajos se traducían con ensambladores y compiladores absolutos para ser ejecutados solo dentro de una partición específica (ver Figura 5.4). O. Multiprogramación de partición fija con traducción y carga absolutas. Mejoran la utilización del almacenamiento.2. resulta de implementación relativamente sencilla pero no se optimiza la utilización de la memoria. 5.5.

6.Figura 5.5.8). Multiprogramación de partición fija con traducción y carga relocalizables.6.3. 5.7 y Figura 5. Abraham Gamarra Moreno 119 . Los extremos superior e inferior de una partición pueden ser: Mg. PROTECCIÓN EN LOS SISTEMAS DE MULTIPROGRAMACIÓN Si se utiliza asignación contigua de memoria la protección suele implementarse con varios “registros de límites” (ver Figura 5. Figura 5.

Protección del almacenamiento con asignación contigua de un solo proceso de usuario. FRAGMENTACIÓN EN PARTICIÓN FIJA LA MULTIPROGRAMACIÓN DE La “fragmentación de almacenamiento” ocurre en todos los sistemas independientemente de su organización de memoria.4.6. Figura 5. de multiprogramación de partición fija la fragmentación se produce cuando: 120 SISTEMAS OPERATIVOS . O. Protección del almacenamiento con asignación contigua en sistemas de multiprogramación. Figura 5. 5.8. Indicados el límite inferior o superior y el tamaño de la partición o región.7.• • Delineados con dos registros. En los S.

121 Mg. Los procesos que terminan dejan disponibles espacios de memoria principal llamados “agujeros”: • • Pueden ser usados por otros trabajos que cuando finalizan dejan otros “agujeros” menores. pero obviamente no deben superar el espacio disponible de memoria (ver Figura 5. No hay límites fijos de memoria. En sucesivos pasos los “agujeros” son cada vez más numerosos pero más pequeños. MULTIPROGRAMACIÓN DE PARTICIÓN VARIABLE Los procesos ocupan tanto espacio como necesitan.9).7. es decir que la partición de un trabajo es su propio tamaño. • 5. Una partición permanece sin usar porque es demasiado pequeña para alojar un trabajo que está en espera. Asignación de particiones iniciales en la multiprogramación de partición variable. Abraham Gamarra Moreno . por lo que se genera un desperdicio de memoria principal. Se consideran “esquemas de asignación contigua”.9.• Los trabajos del usuario no llenan completamente sus particiones designadas. Figura 5. dado que un programa debe ocupar posiciones adyacentes de almacenamiento.

COMPRESIÓN O COMPACTACIÓN DE ALMACENAMIENTO • Puede ocurrir que los agujeros (áreas libres) separados distribuidos por todo el almacenamiento principal constituyan una cantidad importante de memoria: Podría ser suficiente (el total global disponible) para alojar a procesos encolados en espera de memoria.5. COMBINACIÓN DE AGUJEROS (ÁREAS LIBRES) Consiste en fusionar agujeros adyacentes para formar uno sencillo más grande.10). 5.7. Agujeros del almacenamiento en la multiprogramación de partición variable.2. • La técnica de compresión de memoria implica pasar todas las áreas ocupadas del almacenamiento a uno de los extremos de la memoria principal: Deja un solo agujero grande de memoria libre contigua.7. Podría no ser suficiente ningún área libre individual (ver Figura 5.1.10. • Figura 5. Esta técnica se denomina “recogida de residuos” (ver Figura 5. Se puede hacer cuando un trabajo termina y el almacenamiento que libera tiene límites con otros agujeros.11). • 122 SISTEMAS OPERATIVOS .

5. “Estrategia de primer ajuste”: Un trabajo nuevo es colocado en el primer agujero disponible con tamaño suficiente para alojarlo (Figura 5.12). Una alta carga de trabajo significa mayor frecuencia de compresión que incrementa el uso de recursos. Combinación de agujeros adyacentes de almacenamiento en la multiprogramación de partición variable. El sistema debe detener todo mientras efectúa la compresión.7. ESTRATEGIAS DE COLOCACIÓN DEL ALMACENAMIENTO • Se utilizan para determinar el lugar de la memoria donde serán colocados los programas y datos que van llegando y se las clasifica de la siguiente manera: “Estrategia de mejor ajuste”: Un trabajo nuevo es colocado en el agujero en el cual quepa de forma más ajustada.11.14).Figura 5. Abraham Gamarra Moreno 123 .13). Implica la relocalización (reubicación) de los procesos que se encuentran en la memoria: La información de relocalización debe ser de accesibilidad inmediata. Debe dejarse el menor espacio sin usar (Figura 5. lo que puede afectar los tiempos de respuesta. • Mg.3. Principales desventajas de la compresión Consume recursos del sistema (ver Figura 5.

13. es decir en el más grande posible: El agujero restante es también grande para poder alojar a un nuevo programa relativamente grande (Figura 5. SISTEMAS OPERATIVOS 124 .15). Figura 5.12. Compresión (compactación) del almacenamiento en la multiprogramación de partición variable.Figura 5. Estrategia del mejor ajuste. • “Estrategia de peor ajuste”: Consiste en colocar un programa en el agujero en el que quepa de la peor manera.

14. Estrategia del primer ajuste. Abraham Gamarra Moreno 125 .16). MULTIPROGRAMACIÓN CON INTERCAMBIO DE ALMACENAMIENTO En el esquema de “intercambio” los programas del usuario no requieren permanecer en la memoria principal hasta su terminación (Figura 5. Figura 5.15. Mg.Figura 5. Estrategia del peor ajuste.

La totalidad del almacenamiento se dedica a un trabajo durante un breve período de tiempo. Una variante consiste en que un trabajo se ejecuta hasta que ya no puede continuar: • • Cede el almacenamiento y la cpu al siguiente trabajo.Figura 5. • Es un esquema razonable y eficiente para un número relativamente reducido de procesos de usuarios. Los trabajos son “intercambiados”. 126 SISTEMAS OPERATIVOS .16. Los sistemas de intercambio fueron los predecesores de los sistemas de paginación. dándose que un trabajo puede ser intercambiado varias veces antes de llegar a su terminación.

Introducción a los Sistemas Operativos. 2001. Segunda Edición. Bibliografía Recomendada • Deitel M. 2003.N. “memoria primaria” o “memoria real” de un sistema ha sido y es uno de los factores más importantes en el diseño de los S. • • Mg. Sistemas Operativos Modernos. Indicadores de logro El lector explica los fundamentos del almacenamiento en la memoria real. Resumen La organización y administración de la “memoria principal”. Incrementando la cantidad de memoria principal disponible en el sistema. Argentina: Universidad Nacional Del Nordeste U. Retirando una imagen de usuario de la memoria principal solo cuando es necesario su almacenamiento para una nueva imagen. Tanenbaum A.E. Los programas y datos que no son necesarios de inmediato pueden mantenerse en el almacenamiento secundario. Los programas y datos tienen que estar en la memoria principal para poder ejecutarse o ser referenciados.. • • Las imágenes de usuario (imágenes de memoria) retiradas del almacenamiento principal se graban en el almacenamiento secundario (discos). El almacenamiento principal es más costoso y menor que el secundario pero de acceso más rápido. Segunda Edición. Sistemas Operativos Modernos. Mexico: Pearson Educación.El rendimiento de los sistemas de intercambio mejora al reducir el tiempo de intercambio: • Manteniendo al mismo tiempo varias “imágenes de usuario o imágenes de memoria” en la memoria principal.N. España: Addison Wesley Iberoamericana. 1998. Luis la Red Martínez D. Abraham Gamarra Moreno 127 . O.

9K. 9K. 18K. 12K y 15K. ¿Cuál es el espacio que se elige si se solicitan en forma sucesiva segmentos de: (a) 12K (b) 10K (c) 9K con el método del primero que se ajuste?. PROBLEMA DOS Consideremos un sistema de intercambio en el que la memoria consta de los siguientes tamaños de espacios en orden de memoria: 10K. 35K. 4K. Actividad Realice un análisis de los aspectos teóricos de la administración de la memoria real. 7K. Repita ahora la pregunta con el mejor en ajustarse y el peor en ajustarse. 7K. 4K. ¿Cuál es el espacio que se elige si se solicitan en forma sucesiva segmentos de: (a) 8K (b) 10K (c) se libera 8K que se esta usando en la parte más alta de la memoria. 18K. (c) 9K 128 SISTEMAS OPERATIVOS . 20K. 12K y 15K.Nexo La siguiente unidad académica trata de la administración de la memoria virtual. Auto evaluación formativa Encuentre la solución a los siguientes problemas: PROBLEMA UNO Consideremos un sistema de intercambio en el que la memoria consta de los siguientes tamaños de espacios en orden de memoria: 10K.

Repita ahora la pregunta con el mejor en ajustarse y el peor en ajustarse. © 19K con el método del primero que se ajuste?. 18K. 4K. 12K y 15K. Abraham Gamarra Moreno 129 . Mg. 7K. 35K.con el método del primero que se ajuste ?. PROBLEMA TRES Consideremos un sistema de intercambio en el que la memoria consta de los siguientes tamaños de espacios en orden de memoria: 10K. 9K. Repita ahora la pregunta con el mejor en ajustarse y el peor en ajustarse. ¿Cuál es el espacio que se elige si se solicitan en forma sucesiva segmentos de: (a) 12K (b) 10K © se libera 8K que se esta usando en la parte más alta de la memoria.

130 SISTEMAS OPERATIVOS .

Técnicas de “segmentación”. Las direcciones generadas por los programas en su ejecución no son. Abraham Gamarra Moreno . 131 Mg. Los métodos más comunes de implementación son mediante: • • • Técnicas de “paginación”. aquellas contenidas en el almacenamiento primario (memoria real). Una combinación de ambas técnicas.1. INTRODUCCIÓN A LA ALMACENAMIENTO VIRTUAL ORGANIZACIÓN DEL “Almacenamiento virtual” significa la capacidad de direccionar un espacio de almacenamiento mucho mayor que el disponible en el almacenamiento primario de determinado sistema de computación. necesariamente.UNIDAD ACADEMICA 6 ADMINISTRACIÓN DE LA MEMORIA: ALMACENAMIENTO VIRTUAL 6. La evolución en las organizaciones de almacenamiento puede resumirse como sigue: • Real: Sistemas dedicados a un solo usuario. ya que las direcciones virtuales suelen seleccionarse dentro de un número mucho mayor de direcciones que las disponibles dentro del almacenamiento primario.

6. De las direcciones disponibles en la memoria real (almacenamiento primario). 132 SISTEMAS OPERATIVOS . mientras el proceso está en ejecución. CONCEPTOS VIRTUAL BÁSICOS DE ALMACENAMIENTO La clave del concepto de memoria (almacenamiento) virtual esta en la disociación: • • De las direcciones a las que hace referencia un programa. “Espacio de direcciones reales ®” de un computador: Es el número de direcciones reales disponibles en el ordenador. Segmentación pura y Combinación paginación / segmentación. “Espacio de direcciones virtuales (v)” de un proceso: Es el número de direcciones virtuales a que puede hacer referencia el proceso. La traducción de direcciones deberá hacerse rápidamente para no degradar al sistema.2. • • Los procesos hacen referencia a direcciones virtuales pero éstas deben ejecutarse en el almacenamiento real: Las direcciones virtuales deben ser transformadas dentro de las direcciones reales. • Multiprogramación en partición variable. Los principales conceptos son los siguientes: • • “Direcciones virtuales”: Son las referidas por un proceso en ejecución.• Real: Sistemas de multiprogramación en memoria real: • Multiprogramación en partición fija: Absoluta y Relocalizable (reubicable). • Virtual: • Multiprogramación en almacenamiento virtual: Paginación pura. Existen varios medios para asociar las direcciones virtuales con las reales (ver Figura 6. “Direcciones reales”: Son las disponibles dentro del almacenamiento primario.1).

Transformación de ítems del espacio de direcciones virtuales al espacio de direcciones reales.1. Los mecanismos de “traducción dinámica de direcciones” (dat) convierten las direcciones virtuales en reales al ejecutarse el proceso. a esto se denomina “contigüidad artificial” (ver Figura 6. Contigüidad artificial Mg. Abraham Gamarra Moreno 133 .2).Figura 6. Figura 6. Las direcciones contiguas dentro del espacio de direcciones virtuales de un proceso no tienen por qué ser contiguas dentro del almacenamiento real.2.

Solo se mantiene al mismo tiempo una pequeña parte de los programas y datos de cada proceso en el almacenamiento real. • Cuando se va a ejecutar un proceso su código y datos se pasan al almacenamiento principal. • Se utiliza un esquema de almacenamiento de dos niveles (ver Figura 6. • 6.3): • Primer nivel: “almacenamiento real”: En él se ejecutan los procesos y en él deben estar los datos para que un proceso pueda referirse a ellos.3. Segundo nivel: “almacenamiento auxiliar. La información se agrupa en “bloques”: El sistema está informado del lugar del almacenamiento real donde han sido colocados los bloques de almacenamiento virtual. El almacenamiento real es compartido por varios procesos: • Cada proceso puede tener un espacio de direcciones virtuales mucho mayor que el almacenamiento real. secundario o adicional”: Generalmente consta de discos de gran capacidad que pueden mantener los programas y datos que no caben al mismo tiempo en el más limitado almacenamiento real.6. 134 SISTEMAS OPERATIVOS .4. TRANSFORMACIÓN DE BLOQUES Los mecanismos de traducción dinámica de direcciones deben mantener “mapas” que ilustren qué direcciones del almacenamiento virtual se encuentran en el almacenamiento real y dónde se encuentran. Soportar multiprogramación de forma efectiva en un sistema con muchos usuarios que compartan el almacenamiento real. ORGANIZACIÓN DEL ALMACENAMIENTO DE NIVELES MÚLTIPLES Se deben proporcionar los medios para retener programas y datos en un gran almacenamiento auxiliar para: • Permitir que el espacio de direcciones virtuales de un usuario sea mayor que el espacio de direcciones reales.

Figura 6.3. Con bloques grandes: • Se reduce la sobrecarga de almacenamiento del mecanismo de transformación. Abraham Gamarra Moreno . 135 • Mg. Almacenamiento de dos niveles. • Cuanto mayor sea el bloque menor será la fracción del almacenamiento real que debe dedicarse a contener la información del mapa.

• Diferente: se denominan “segmentos” y la organización de almacenamiento virtual asociada se denomina “segmentación”. La traducción de una dirección virtual “v = (b.Igual: se denominan “páginas” y la organización de almacenamiento virtual asociada se denomina “paginación”.Se incrementa el tiempo de transferencia entre los almacenamientos secundario y primario. “d”: desplazamiento a partir del inicio del bloque. • Consumen más almacenamiento real pudiendo limitar el número de procesos que pueden compartirlo.5): • Cada proceso tiene su “tabla de mapa de bloques” mantenida por el sistema en el almacenamiento real.d)” a la dirección real “r” considera lo siguiente (ver Figura 6. Un registro especial del procesador llamado “registro origen de la tabla de bloques” se carga con la dirección real “a” de la “tabla de mapa de bloques”: . • 136 SISTEMAS OPERATIVOS . • Los bloques pueden ser de tamaño: . es decir que una dirección virtual “v” se indica por un par ordenado “(b.Contiene una entrada para cada bloque del proceso. .4 y Figura 6. donde: • • “b”: número del bloque donde reside. etc. • Se pueden combinar ambas técnicas: segmentos de tamaño variable compuestos de páginas de tamaño fijo. .Las entradas se mantienen en orden secuencial para el bloque 0..Se añade el bloque número “b” a la dirección base “a” de la “tabla de bloques” para formar la dirección real de la entrada de la “tabla de mapa de bloques” para el bloque “b”: Contiene la dirección real “b ’ ” para el bloque “b” y el desplazamiento “d” se añade a la dirección de inicio del bloque. bloque 1. Las direcciones son “bidimensionales”.d)”. “b ’ ”. para formar la “dirección real” deseada: “r = b ’ + d”.

La transformación de bloques se efectúa en forma dinámica mientras se ejecuta un proceso.5. 6. 137 Mg. Traducción de direcciones virtuales con transformación de bloques.Figura 6. Formato de la dirección virtual dentro de un sistema de transformación de bloques.4. CONCEPTOS BÁSICOS DE PAGINACIÓN Frecuentemente se diferencia entre la “paginación pura” y la “combinación de paginación y segmentación”.5. Abraham Gamarra Moreno . por lo cual. Las páginas se transfieren del almacenamiento secundario al primario en bloques llamados “marcos de páginas”: • Tienen el mismo tamaño que las páginas. si la implementación no es eficiente. su sobrecarga puede causar una degradación del rendimiento que podría eliminar en parte las ventajas de la utilización del almacenamiento virtual. Figura 6.

En caso negativo dónde puede estar en el almacenamiento secundario. 2. Figura 6. La dirección de almacenamiento primario “a”. carga la dirección de almacenamiento primario de la “tabla de mapa de páginas” en el “registro origen de la tabla de mapa de páginas” (Ver Figura 6. está dada por: “a = (p) (p’)”. Formato de la dirección virtual en un sistema de paginación pura. La dirección de almacenamiento real se forma por la concatenación de “p ’ ” y “d”. • Un mecanismo de transformación de páginas busca la página “p” en la “tabla de páginas” y determina si la página “p” se encuentra en el marco de página “p ’ ”.• Comienzan en direcciones del almacenamiento real que son múltiplos enteros del tamaño fijo de la página. O.5.10). • La “traducción dinámica de direcciones” incluye: • Un proceso en ejecución hace referencia a una dirección virtual “v = (p. el S.8 y Figura 6.9).1.7. Antes que un proceso comience su ejecución. 138 SISTEMAS OPERATIVOS . se supone marcos de página numerados 0.6). Podrá colocarse una nueva página dentro de cualquier “marco de página” o “celda de página” disponible. Figura 6. • La tabla de “mapa de páginas” debe indicar si se encuentra o no en el almacenamiento primario la página referenciada: • • En caso afirmativo dónde está en la memoria real. TRADUCCIÓN DE DIRECCIONES DE PAGINACIÓN POR TRANSFORMACIÓN DIRECTA Un proceso en ejecución hace referencia a la dirección virtual v = (p.d).d)” (ver Figura 6. etc. 1. (ver Figura 6. 6. donde comienza el marco de pagina “p’ ” (suponiendo un tamaño de página “p”).6.

“Esto es un ejemplo de transformación directa debido a que la tabla de mapa de páginas contiene una entrada por cada una de las páginas del almacenamiento virtual de este proceso”.Figura 6. La dirección en el almacenamiento primario de la entrada en la tabla de mapa de páginas para la página “p” es “b + p”: • Indica que el marco de página “p’” corresponde a la página virtual.7.“p ’ ” se concatena con el desplazamiento “d” par formar la dirección real “r”. El número de página es “p”.8. Una entrada en la tabla de mapa de páginas. Figura 6. Abraham Gamarra Moreno 139 . Almacenamiento real dividido en marcos de páginas. La dirección base de la tabla de mapa de páginas es “b”. Mg.

Figura 6. Correspondencia entre las direcciones de almacenamiento virtual y las direcciones de almacenamiento real en un sistema de paginación.9. que generalmente es la parte más larga de un ciclo de ejecución de instrucciones. 140 SISTEMAS OPERATIVOS . La dirección virtual que se está traduciendo y la dirección base de la tabla de mapa de páginas son mantenidas en un registro de alta velocidad del control del procesador. La tabla de mapa de páginas transformada directamente suele mantenerse en el almacenamiento primario: • Las referencias a esta tabla requieren un ciclo completo de almacenamiento primario.

TRADUCCIÓN DE DIRECCIONES DE PAGINACIÓN POR TRANSFORMACIÓN ASOCIATIVA Una forma de acelerar la traducción dinámica de páginas consiste en colocar la tabla completa de mapa de páginas en un “almacenamiento asociativo” que tenga un tiempo de ciclo mucho más rápido que el almacenamiento primario. Una variante es la “transformación asociativa pura” (ver Figura 6. 6.11). Mg.Figura 6.10. • Se requiere otro ciclo de ejecución de almacenamiento primario para la transformación de páginas. lo que puede ocasionar degradación equivalente a un 50%. para lo cual una solución sería tener la tabla completa de mapa de páginas de transformación directa en la “caché” de muy alta velocidad. Traducción de direcciones de página por transformación directa.2.5. Abraham Gamarra Moreno 141 .

tal lo ocurrido con la implementación de la transformación directa pura utilizando “caché”.3.Implementar la transformación asociativa pura resulta demasiado costoso.12). Un programa en ejecución hace referencia a la dirección virtual v = (p. TRADUCCIÓN DE DIRECCIONES DE PAGINACIÓN POR COMBINACIÓN DE TRANSFORMACIÓN ASOCIATIVA / DIRECTA Se utiliza un almacenamiento asociativo capaz de mantener solo un pequeño porcentaje del mapa completo de páginas para un proceso (ver Figura 6. 6.d).Figura 6.11. 142 SISTEMAS OPERATIVOS . Se concatena “p ’ ” con “d” formando la dirección real “r”. Cada una de las células del almacenamiento asociativo se registra de manera simultánea: • Hace costoso el almacenamiento asociativo.5. Traducción de direcciones de página por transformación asociativa pura. Cada entrada en el almacenamiento asociativo se busca de forma simultánea para la página “p”: • • Se obtiene “p ’ ” como el marco de página correspondiente a la página “p”.

El mecanismo de traducción de direcciones intenta encontrar la página “p” en el mapa de página asociativo parcial: • Si “p” se encuentra allí: El mapa asociativo devuelve “p ’ ” como el número de marco de página correspondiente a la página virtual “p”. Luego “p ’ ” se concatena con el desplazamiento “d” para formar la dirección real “r” que corresponde a la dirección virtual v=(p. • Un programa hace referencia a la dirección virtual v = (p.12.Figura 6.d). Abraham Gamarra Moreno . 143 Mg.d). Las entradas de página contenidas en este mapa reducido corresponden solo a las páginas referenciadas recientemente: • Se presupone que una página recientemente referenciada tendrá posibilidades de serlo de nuevo próximamente. Traducción de direcciones de paginación por combinación de transformación asociativa/directa. Los rendimientos obtenidos con este esquema de mapa asociativo parcial superan aproximadamente en un 100 % a los rendimientos obtenidos con esquemas de mapa asociativo de página completo.

Habrá marcos (celdas) de páginas compartidos por varios procesos. • Los procedimientos no modificables se llaman “procedimientos puros reentrantes”. .• Si “p” no se encuentra en el mapa de pagina parcial: Se utiliza un mapa directo convencional. La tabla indica que “p ’ ” es el marco de página correspondiente a la página virtual “p”. especialmente en los de tiempo compartido.5. es común que más de un usuario esté ejecutando los mismos programas: • Para optimizar el uso de la memoria real se comparten las páginas que pueden ser compartidas: • El compartimiento debe ser cuidadosamente controlado para evitar que un proceso modifique datos que otro proceso esta leyendo (ver Figura 6. El compartimiento: Reduce la cantidad de almacenamiento primario necesario para la ejecución eficaz de un grupo de procesos. COMPARTIMIENTO DE RECURSOS EN UN SISTEMA DE PAGINACIÓN En sistemas multiprogramados.Los datos no modificables (ej. La dirección “b” del registro de origen de la tabla de páginas se añade a “p” para localizar la entrada apropiada a la página “p” en la tabla de mapa de páginas de transformación directa del almacenamiento primario. Puede hacer posible que un sistema determinado mantenga una cantidad mayor de usuarios (procesos). • Los datos y procedimientos modificables no pueden ser compartidos.4.13). .d). 6.: tablas fijas) son compartibles. • 144 SISTEMAS OPERATIVOS . • • • Se debe identificar cada página como compartible o no.Los programas se encuentran divididos en áreas separadas de “procedimiento” y “datos”. Luego “p ’ ” se concatena con el desplazamiento “d” para formar la dirección real “r” correspondiente a la dirección virtual v = (p.

Deben estar compuestos de posiciones contiguas de almacenamiento.14).Figura 6.6. Compartimiento en un sistema de paginación pura. Los bloques: • • No necesitan ser de igual tamaño. Es más difícil limitar el rango de acceso de cualquier programa.Se complica la protección de bloques de memoria de un proceso de usuario. Abraham Gamarra Moreno 145 . SEGMENTACIÓN En los sistemas de “segmentación” un programa y sus datos pueden ocupar varios bloques separados de almacenamiento real (ver Figura 6.13. Los bloques separados no necesitan ser adyacentes. 6. Mg.

Asignación no contigua de almacenamiento. 146 SISTEMAS OPERATIVOS .Figura 6. Un programa de usuario. solo puede hacer referencia a los otros bloques del almacenamiento con igual clave de protección. Los segmentos se transfieren del almacenamiento secundario al primario como unidades completas. O. “d” es el desplazamiento en el segmento “s” en el cual se encuentra el elemento referido.15): • • Las claves están bajo el control estricto del S. • Un proceso solo puede ejecutarse si su segmento actual (como mínimo) está en el almacenamiento primario. Un esquema posible de protección es el uso de claves de protección del almacenamiento (ver Figura 6. Un nuevo segmento puede ser colocado en una serie disponible de posiciones contiguas del almacenamiento primario de tamaño suficiente para alojar al segmento.14.16): • “s” es el número del segmento del almacenamiento virtual en el cual residen los elementos referidos. Una dirección virtual es un par ordenado v=(s. a quien corresponde una cierta clave en la cpu.d) (ver Figura 6.

Mg. Figura 6. Abraham Gamarra Moreno 147 . Protección de alamcenamiento como claves en sistemas de multiprogramación de asignación no contigua de almacenamiento. Figura 6.La traducción dinámica de direcciones utiliza una “tabla de mapa de segmentos”.16.15. Traducción de direcciones virtuales en un sistema de segmentación pura.

pero no puede modificar la información existente. Un proceso con “acceso de ejecución” de un segmento puede ejecutarlo como si fuera un programa.1. escritura y ejecución para producir modos de protección útiles se dan en la Tabla 6. Modo 0 1 2 3 4 5 Lectura Escritura Ejecución Explicación N N S S S S N N N N S S N S N S N S No hay permiso de acceso Solo ejecución Solo lectura Lectura / ejecución Lectura / escritura pero no ejecución Acceso no limitado 148 SISTEMAS OPERATIVOS . Si un proceso tiene “acceso de escritura” a un segmento. Tabla 6. puede modificar cualquier contenido del segmento y puede introducirle información adicional.1 y en la Tabla 6. puede obtener cualquier elemento de información contenido en ese segmento.6.2. incluso destruir toda la información del segmento.1. Ejemplos de combinación de los accesos de lectura. En base a los “tipos de control de acceso” indicados pueden crearse distintos “modos de control de acceso”.6. Si un proceso tiene “acceso de lectura” a un segmento. Un proceso con “acceso de adición” puede escribir información adicional al final del segmento. Ejemplo de combinación de accesos. CONTROL DE ACCESO EN SISTEMAS DE SEGMENTACIÓN Se le otorga a cada proceso ciertos derechos de acceso a todos los segmentos y se les niega completamente el acceso a muchos otros.

Entrada de tabla de mapa de segmentos. Mg. que no pueden copiarlo ni modificarlo. Con caché suficiente para alojar la tabla completa de mapa de segmentos o caché parciales que contengan solo las entradas de los segmentos de referencia más reciente (ver Figura 6. asociativa o combinación de asociativa / directa.17. Ejemplo de aplicaciones de la combinación de accesos.6.17).Tabla 6.2. pero no puede ser modificado Protege los datos contra un intento erróneo de ejecutarlos Este acceso se concede a los usuarios de confianza 6. Abraham Gamarra Moreno 149 . • Figura 6. Modo Aplicación 0 1 2 3 4 5 Seguridad Un programa disponible a los usuarios.2. TRADUCCIÓN DE DIRECCIONES DE SEGMENTACIÓN POR TRANSFORMACIÓN DIRECTA • Existen varias estrategias para la implementación de la traducción de direcciones de segmentación: Por transformación directa. pero sí ejecutarlo Recuperación de información Un programa puede ser copiado o ejecutado.

que contiene la dirección del almacenamiento primario “s ’ ”. en el almacenamiento primario se añade al desplazamiento “d” formando la dirección de memoria real “r = s ’ + d”. de la entrada para el segmento “s” de la tabla de mapa de segmentos. Si el segmento buscado no está en el almacenamiento primario se genera un “fallo de pérdida de segmento”: • El S. correspondiente a la dirección virtual “v = (s. Se compara cada referencia a un segmento con los bits de protección para determinar si se permite la operación que se está intentando.d)”. Si el segmento no se encuentra en el almacenamiento primario “a” es la dirección en el almacenamiento secundario de donde debe recuperarse antes que el proceso pueda continuar.Se considerará la traducción de direcciones de segmentación con la tabla completa de mapa de segmentos en la caché. • Un “bit de residencia”.d): • El segmento número “s” se añade a la dirección base “b” en el registro origen de la tabla de mapa de segmentos formando la dirección de memoria real “b + s”. O.Si el desplazamiento está en el rango del segmento se comprueban los bits de protección para asegurarse si se permite la operación que se está intentando: Si es así entonces la dirección base del segmento. . Se comprueba si el desplazamiento “d” es menor o igual a la longitud del segmento “l ”: . Si la operación intentada no se permite se genera un “fallo de protección de segmento” y el S. “r”. O. obtiene el control y carga el segmento referido desde la dirección “a” del almacenamiento secundario.d)”. “s’”. El desplazamiento “d” se añade a “s ’ ” formando la dirección real “r = d + s ’ ”. obtiene el control y termina la ejecución del proceso. 150 SISTEMAS OPERATIVOS • . Un proceso en ejecución hace referencia a la dirección virtual v = (s. que corresponde a la dirección del almacenamiento virtual “v = (s. Si el segmento se encuentra en el almacenamiento primario “s ’ ” es la dirección en este almacenamiento donde comienza el segmento. indica si en la actualidad el segmento se encuentra o no en el almacenamiento primario. donde comienza el segmento. O.Si no es así se genera un “fallo de desbordamiento de segmento” y el S. obtiene el control y termina la ejecución del proceso.

entonces las estructuras que lo integran pueden cambiar de tamaño.p. COMPARTIMIENTO EN UN SISTEMA DE SEGMENTACIÓN • Una de las ventajas de la segmentación sobre la paginación es que se trata más de un hecho lógico que físico: En un sistema de segmentación. 6. Abraham Gamarra Moreno 151 . Mg. • Dos procesos pueden compartir un segmento con solo tener entradas en sus tablas generales que apunten al mismo segmento del almacenamiento primario (ver Figura 6.6. SISTEMAS DE PAGINACIÓN / SEGMENTACIÓN Ofrecen las ventajas de las dos técnicas de organización del almacenamiento virtual.7. No es necesario que todas las páginas de un segmento se encuentren al mismo tiempo en el almacenamiento primario. que son contiguas en este almacenamiento. no necesitan ser contiguas en el almacenamiento real.d)”: • • “s” es el número del segmento.3. una vez que un segmento ha sido declarado como compartido.18). “p” es el número de página. El direccionamiento es tridimensional con una dirección de almacenamiento virtual “v = (s.18. Compartimiento en un sistema de segmentación pura.6. Las páginas de almacenamiento virtual. Figura 6. El tamaño de los segmentos es múltiplo del de las páginas. Lo anterior no cambia el hecho lógico de que residen en un segmento compartido.

19). Traducción de direcciones virtuales con combinación de transformación asociativa/directa dentro de un sistema de paginación y segmentación. 6.• “d” es el desplazamiento en la página donde se encuentra asignado el elemento deseado.7. El proceso en ejecución hace referencia a la dirección virtual v = (s.d) (ver Figura 6.19). 152 SISTEMAS OPERATIVOS .p.19. TRADUCCIÓN DINÁMICA DE DIRECCIONES EN SISTEMAS DE PAGINACIÓN / SEGMENTACIÓN Se considera la traducción dinámica de direcciones de virtuales a reales en un sistema de paginación / segmentación utilizando la combinación de transformación asociativa / directa (ver Figura 6.1. Figura 6.

cuyo caso el S. manteniendo el mapa completo dentro del almacenamiento primario.d). localiza el segmento en el almacenamiento secundario. la referencia promedio de almacenamiento virtual requeriría: Mg.La entrada de la tabla de mapa de segmentos indica la dirección base “s ’ ” de la tabla de páginas para el segmento “s”. obtiene el control.p). localiza la página en el almacenamiento secundario y la carga. entonces: .Las páginas de referencia más reciente tienen entradas en un almacenamiento asociativo. O. Se realiza una búsqueda asociativa para intentar localizar (s. Si el segmento “s” está en el almacenamiento primario y si la referencia a la tabla de mapa de páginas indica que la página deseada no se encuentra en el almacenamiento primario.p).La dirección base “b” de la tabla de segmentos se añade al número de segmento “s” formando la dirección “b + s” de la entrada de la tabla de mapa de segmentos para el segmento “s” de la memoria real. O. Si no se encuentra (s. .p. en tal caso el S. Si se utiliza un mecanismo de transformación directa pura. O. entonces el marco de página “p ’ ” en el cual reside dicha página en la memoria real.p) en el almacenamiento asociativo: • Si se encuentra (s.p. • El número de página “p” se añade a “s ’ ” formando la dirección “p + s ’ ” de la entrada en la tabla de páginas para la página “p” del segmento “s”: Indica que “p ’ ” es el número del marco correspondiente a la página virtual “p”.d). se produce un “fallo de pérdida de página”. pudiendo reemplazar otra página. Luego “p ’ ” se concatena con el desplazamiento “d” formando la dirección real “r ” que corresponde a la dirección virtual v=(s. el que debe ser atendido por el S. crea una tabla de páginas para el segmento y carga la página apropiada en el almacenamiento primario. Si los bits de protección indican que la operación que se va a ejecutar en la dirección virtual referida no se permite. se genera un “fallo de protección de segmento”. Si el segmento “s” no se encuentra en el almacenamiento primario se produce un “fallo de pérdida de segmento”. el que también debe ser atendido por el S. Abraham Gamarra Moreno 153 • . pudiendo producir reemplazos de páginas. se concatena al desplazamiento “d” para formar la dirección de memoria real “r” correspondiente a la dirección virtual v= (s. Si una dirección de almacenamiento virtual está más allá del final del segmento se genera un “fallo de desbordamiento de segmento”. O.

O. 16 registros). 6. se logran velocidades de ejecución del 90 % o más de la velocidad total de procesamiento de sus procesadores de control.2. • • Cada referencia a un elemento comprende tres ciclos de almacenamiento: • • El sistema correría casi a 1 / 3 de su velocidad nominal.7.21). La traducción de direcciones insumiría 2 / 3 del tiempo. segmentación o paginación / segmentación.20 indica la estructura detallada de tablas requerida por un sistema con paginación/segmentación.• Un ciclo de almacenamiento para acceder a la tabla de mapa de segmentos. 154 SISTEMAS OPERATIVOS . Un tercer ciclo de almacenamiento para referenciar al elemento deseado del almacenamiento real. COMPARTIMIENTO EN CIÓN/SEGMENTACIÓN UN SISTEMA DE PAGINA- Se implementa disponiendo entradas en tablas de mapa de segmentos para diferentes procesos que apunten a la misma tabla de mapa de páginas (ver Figura 6. ya sea en sistemas de paginación. de mapas de segmentos y de mapas de páginas puede consumir un porcentaje importante del almacenamiento primario cuando se ejecutan un gran número de procesos. Un segundo ciclo de almacenamiento para hacer referencia a la tabla de mapa de páginas. Con la utilización de registros asociativos (por ej. lo que resta espacio para los procesos. El compartimiento requiere una administración cuidadosa por parte del S.. La traducción procede mucho más rápido si todas las tablas están en el almacenamiento primario.La estructura de tablas de procesos. pues se debe considerar qué sucedería si una nueva página reemplazara a otra página compartida por muchos procesos. La Figura 6.

Figura 6. Mg.20. Abraham Gamarra Moreno 155 . Estructura de tablas para un sistema de paginación y segmentación.

8. Se consideran las siguientes estrategias: 156 SISTEMAS OPERATIVOS .8. Segmentación. Segmentación y paginación. Las estrategias para la administración de sistemas de almacenamiento virtual condicionan la conducta de los sistemas de almacenamiento virtual que operan según esas estrategias. Dos procesos compartiendo un sistema de paginación y segmentación. 6.Figura 6.21.1. ESTRATEGIAS DE ADMINISTRACIÓN DEL ALMACENAMIENTO VIRTUAL Las diferentes organizaciones de almacenamiento virtual generalmente implementadas son: • • • Paginación. ADMINISTRACION DEL ALMACENAMIENTO VIRTUAL 6.

- • “Estrategias de colocación”: Tratan del lugar del almacenamiento primario donde se colocará una nueva página o segmento. Las estrategias de “búsqueda por demanda” esperan a que se haga referencia a una página o segmento por un proceso antes de traerlos al almacenamiento primario.primero en salir.8. 6.2. 157 Mg. Primero en entrar . ESTRATEGIAS PÁGINA Las principales son: • • • • • • • DE REPOSICIÓN (REEMPLAZO) DE El principio de optimización. Abraham Gamarra Moreno . Menos recientemente usada.• “Estrategias de búsqueda”: Tratan de los casos en que una página o segmento deben ser traídos del almacenamiento secundario al primario. Reposición de páginas al azar. Los sistemas toman las decisiones de colocación de una forma trivial ya que una nueva página puede ser colocada dentro de cualquier marco de página disponible. No usada recientemente. Los esquemas de “búsqueda anticipada” intentan determinar por adelantado a qué páginas o segmentos hará referencia un proceso para traerlos al almacenamiento primario antes de ser explícitamente referenciados. • “Estrategias de reposición”: Tratan de la decisión de cuál página o segmento desplazar para hacer sitio a una nueva página o segmento cuando el almacenamiento primario está completamente comprometido. Menos frecuentemente usada. Segunda Oportunidad.

ciertos patrones de referencias de páginas causan más fallos de páginas cuando se aumenta el número de marcos (celdas) de páginas asignados a un proceso: en esto consiste la “anomalía FIFO”. • 158 SISTEMAS OPERATIVOS .• • Por reloj. Todas las páginas del almacenamiento principal deben tener la misma probabilidad de ser reemplazadas. Conjuntos de trabajo. Este esquema es raramente usado. Se puede presentar la llamada “anomalía FIFO”: • Belady. incluyendo la que va a ser referenciada a continuación (peor selección). Debe poder seleccionar cualquier página.22). Nelson y Shedler descubrieron que con la reposición FIFO. se selecciona aquella que ha estado más tiempo almacenada. la página que se va a reponer (reemplazar) es una que no se va a utilizar en el futuro durante el período de tiempo más largo. Se presenta el inconveniente de que se pueden reemplazar páginas muy usadas. Reposición de Página al Azar Consiste en escoger al azar la página que va a ser reemplazada. Reposición de Página por el Sistema de Primero en Entrar Primero en Salir (FIFO) Se registra el momento en que cada página ingresa al almacenamiento primario. Para reemplazar una página. El problema es que no es factible predecir el futuro. que serán llamadas de nuevo al almacenamiento primario casi de inmediato. El Principio de Optimización El “principio de optimización” indica que para obtener un rendimiento óptimo. Esta anomalía contradice a la intuición (ver Figura 6.

No se implementa frecuentemente. etc. por lo que habría que paginarla de nuevo al almacenamiento principal casi de inmediato. el hardware primero activa todos los bits del renglón k y desactiva después todos los bits de la columna k. En una referencia al marco k. La página seleccionada para reemplazo podría ser la próxima en ser requerida. el renglón con el siguiente valor más pequeño es el segundo de uso menos reciente. El trabajo de este algoritmo aparece en la figura siguiente para cuatro marcos para páginas con referencias a las páginas en el orden0 1 2 3 2 1 0 3 2 3 Mg. cuyos datos iniciales son todos 0. En cualquier instante. Analicemos ahora un algoritmo LRU en hardware.Figura 6. el hardware LRU puede utilizar una matriz de n x n bits. Ejemplo de anomalía FIFO. el renglón cuyo valor en binario es mínimo es el de uso menos reciente.22. Reposición de Página Menos Recientemente Usada (LRU) Esta estrategia selecciona para ser reemplazada la página que no ha sido usada durante el mayor período de tiempo. En una máquina con n marcos para página. Requiere que cada página reciba un “sello de tiempo” cada vez que se referencia: Puede significar una sobrecarga adicional importante. Abraham Gamarra Moreno 159 . Se basa en la heurística de que el pasado reciente es un buen indicador del futuro próximo.

Figura 6.23. y por lo tanto existe una alta probabilidad de que sea usada de inmediato. El LRU con uso de una matriz. Reposición de Página No Usada Recientemente (NUR) Presupone que las páginas que no han tenido uso reciente tienen poca probabilidad de ser usadas en el futuro próximo y pueden ser reemplazadas por otras nuevas. Reposición de Página Menos Frecuentemente Usada (LFU) Acá interesa la intensidad de uso que haya tenido cada página. La página que será reemplazada es aquella que ha sido usada con menos frecuencia o que ha sido referida con menos intensidad. El inconveniente es que se puede seleccionar fácilmente para su reposición la página equivocada: • Ejemplo: La página de uso menos frecuente puede ser la página de entrada más reciente al almacenamiento principal.Después de hacer referencia a la página 0 tenemos la situación de la Figura 6.23-a). Es deseable reemplazar una página que no ha sido cambiada mientras estaba en el almacenamiento primario. 160 SISTEMAS OPERATIVOS . En la misma figura se muestra la referencia a las otras páginas.

Con el transcurso del tiempo la mayoría de los “bits referenciados” serán activados: • • Se pierde la capacidad para distinguir las páginas más deseables para ser reemplazadas.Se logra un nuevo inicio. . pero solo brevemente. pero si no la encuentra habrá que reemplazar una página que ha sido referenciada. Si una página ha sido referenciada se comprueba si ha sido modificada o no: • Si no ha sido modificada se la reemplaza: • Su reposición representa menos sobrecarga que la de una página modificada.Se vuelve vulnerable al reemplazo aún a las páginas activas. M = 1 si la página ha sido modificada. • Si no se encuentra una página que no ha sido modificada será reemplazada una página modificada. Mg. • “Bit modificado” (también llamado “bit sucio”): M = 0 si la página no ha sido modificada. ya que debería grabarse de nuevo en el almacenamiento secundario. La selección de la página que será reemplazada comienza buscando una página que no ha sido referenciada. Los “bits modificados” no se ajustan periódicamente según esta estrategia.La estrategia NUR se implementa con la adición de dos bits de hardware por página: • “Bit referenciado”: R = 0 si la página no ha sido referenciada. R = 1 si la página ha sido referenciada. Para evitarlo se ajustan periódicamente todos los “bits referenciados” a “0”: . Abraham Gamarra Moreno 161 . mientras se reajustan los bits.

A se retira de la memoria. el algoritmo siempre termina. Después continúa la búsqueda. Si el bit es 1. En ese momento. Figura 6. la página es tanto antigua como no utilizada. se muestra en la Figura 6. En la Figura 6. si R = 1.24(a). llamado de la segunda oportunidad. que llegó en el instante 0. La operación de este algoritmo. En cierto momento. el sistema operativo traslada las páginas al final de la lista y limpia el bit R cada vez que añade una. La página más antigua es A. La búsqueda de una página adecuada prosigue con B. Así. Algoritmo de reposición (reemplazo) de páginas de la segunda oportunidad. por lo que reemplaza en forma inmediata. Una a una. Lo que hace la segunda oportunidad es buscar una página antigua sin referencias durante el anterior intervalo de tiempo.24(a) anterior. Si A tiene el bit R = 0. el algoritmo de la segunda oportunidad deriva en un simple FIFO. Por otro lado. Supongamos que ocurre un fallo de página en el instante 20. Si es 0. la página se coloca al final de la lista de páginas y su tiempo de carga se actualiza. el bit se limpia. la cual tiene R = 0. en una lista ligada ordenada según el tiempo de llegada a la memoria. A se coloca al final de la lista y su “tiempo de carga” cambia al tiempo activo (20). ya sea mediante su escritura en el disco (si tiene nueva información) o sólo se abandona (en caso contrario). Se limpia entonces el bit R.24. 162 SISTEMAS OPERATIVOS . Si todas las páginas tienen alguna referencia. supongamos que todas las páginas de la Figura 6. se retira de la memoria. al iniciar el proceso. En efecto. vemos las páginas A hasta H. regresa a la página A.24. tienen R = 1. como si hubiera llegado en ese momento a la memoria.El algoritmo de reposición (reemplazo) de páginas de la segunda oportunidad Una modificación simple de FIFO que evita deshacerse de una página de uso frecuente inspecciona el bit R de la página más antigua.

Abraham Gamarra Moreno 163 . Una manecilla apunta hacia la página más antigua. Si R = 1. Si su bit R = O. Al ocurrir un fallo de página. se inspecciona la página a la que apunta la manecilla. Algoritmo de reposición (reemplazo) de páginas del reloj. Figura 6.25. como se muestra en la Figura 6.25. puesto que desplaza en forma constante las páginas en una lista. con la forma de un reloj. la página se retira de la memoria. Resumen “Almacenamiento virtual” significa la capacidad de direccionar un espacio de almacenamiento mucho mayor que el disponible en el almacenamiento primario de determinado sistema de computación. este bit se limpia y la manecilla avanza a la página siguiente. No debe sorprendernos que este algoritmo se llame del reloj. Mg. Un mejor enfoque es mantener las páginas en una lista circular. Este proceso continúa hasta encontrar una página con R = O. Difiere de la segunda oportunidad sólo por la implantación. es ineficiente e innecesario.El algoritmo de reposición (reemplazo) de páginas del reloj Aunque la segunda oportunidad es un algoritmo razonable. se inserta la nueva página en su lugar en el reloj y la manecilla avanza una posición.

Bibliografía Recomendada • Deitel M.Indicadores de logro El lector explica los fundamentos de la memoría virtual. Mexico: Pearson Educación. Auto evaluación formativa Escriba programas que encuentren la solución a los siguientes problemas: PROBLEMA UNO ¿Cuál es la diferencia entre una dirección física y una dirección virtual? PROBLEMA DOS Una computadora tiene cuatro marcos para página. 2001. España: Addison Wesley Iberoamericana. Segunda Edición. Argentina: Universidad Nacional Del Nordeste U. Luis la Red Martínez D. Introducción a los Sistemas Operativos. Sistemas Operativos Modernos. Segunda Edición. 2003. Actividad Analice los aspectos teóricos sobre la Memoria Virtual. El tiempo de carga.N. el tiempo del último acceso y los bits R y M para cada página aparecen en la tabla siguiente (los tiempos se miden mediante las marcas del reloj): 164 SISTEMAS OPERATIVOS . Sistemas Operativos Modernos..E. • • Nexo La siguiente unidad académica trata sobre el Sistema de Archivos.N. Tanenbaum A. 1998.

26. 165 Mg.Página Cargado 0 1 2 3 126 230 120 160 Ultima referencia 279 260 272 280 R M 0 1 1 1 0 0 1 1 (a) ¿Cuál página es reemplazada por NRU? (b) ¿Cuál página es reemplazada por FIFO? © ¿Cuál página es reemplazada por LRU? (d) ¿Cuál página es reemplazada por la segunda oportunidad? PROBLEMA TRES Una computadora tiene tres marcos para página. calcule las direcciones físicas correspondientes a cada una de las siguientes direcciones virtuales: A. Abraham Gamarra Moreno . 20. el tiempo del último acceso y los bits R y M para cada página aparecen en la tabla siguiente (los tiempos se miden mediante las marcas del reloj): Página Cargado 0 1 2 3 126 230 120 160 Ultima referencia 279 260 272 280 R M 0 1 1 1 0 0 1 1 (a) ¿Cómo se da el reemplazo por FIFO y cuantos fallos de páginas se producen para la carga de las 4 páginas? (b) ¿Cómo se da el reemplazo por NUR y cuantos fallos de páginas se producen para la carga de las 4 páginas? (c) ¿Cómo se da el reemplazo por la segunda oportunidad y cuantos fallos de páginas se producen para la carga de las 4 páginas? PROBLEMA CUATRO Mediante la tabla de páginas de la Figura 6. La tabla muestra páginas con el tiempo de carga.

B. C. 166 SISTEMAS OPERATIVOS .26. 8300. 4100. Figura 6.

1. Las condiciones esenciales para el almacenamiento de la información a largo plazo son: • • • Debe ser posible almacenar una cantidad muy grande de información. Trascendiendo a la duración de los procesos que las utilizan o generan. Abraham Gamarra Moreno . 167 Mg. La solución es el almacenamiento de la información en discos y otros medios externos en unidades llamadas archivos: • Los archivos deben ser persistentes. INTRODUCCIÓN Todas las aplicaciones computarizadas necesitan almacenar y recuperar la información: • • • Superando las limitaciones del almacenamiento real. Independizando a la información de los procesos permitiendo el acceso a la misma a través de varios procesos. es decir que no deben verse afectados por la creación o terminación de un proceso.PARTE 1 7. Debe ser posible que varios procesos tengan acceso concurrente a la información.UNIDAD ACADEMICA 7 SISTEMA DE ARCHIVOS . La información debe sobrevivir a la conclusión del proceso que la utiliza.

Se debe poder referenciar a los archivos mediante “Nombres Simbólicos”. Se deben poder compartir los archivos de una manera cuidadosamente controlada. brindando “Independencia de Dispositivos”. varias combinaciones de estos. rename. FUNCIONES DEL SISTEMA DE ARCHIVOS Los usuarios deben poder crear. list. El mecanismo encargado de compartir los archivos debe proporcionar varios tipos de acceso controlado: • Ej. O. etc. Pueden ser manipulados como una unidad por operaciones como: open. En ambientes sensibles. destroy. La destrucción maliciosa de información. “Acceso de Ejecución”. modificar y borrar archivos. delete. close.2. 7. create.• • Los archivos son una colección de datos con nombre. Es la parte del S. • El “Sistema de Archivos” es la parte del sistema de administración del almacenamiento responsable. Los usuarios deben poder ordenar la transferencia de información entre archivos. copy. El sistema de archivos debe brindar una interfase favorable al usuario: 168 SISTEMAS OPERATIVOS . de la administración de los archivos del almacenamiento secundario. principalmente. Se deben proporcionar posibilidades de “respaldo” y “recuperación” para prevenirse contra: • • La pérdida accidental de información. responsable de permitir “compartir controladamente” la información de los archivos. Los elementos de datos individuales dentro del archivo pueden ser manipulados por operaciones como: read.: “Acceso de Lectura”. write. “Acceso de Escritura”. Se debe poder estructurar los archivos de la manera más apropiada a cada aplicación. insert. update. el sistema de archivos debe proporcionar posibilidades de “Cifrado” y “Descifrado”.

169 • • Mg. El “directorio raíz ” apunta a los “directorios de usuarios”. “Administración del almacenamiento auxiliar” para la asignación de espacio a los archivos en los dispositivos de almacenamiento secundario.• Debe suministrar una “visión lógica” de los datos y de las funciones que serán ejecutadas. referenciados. • Dónde serán almacenados los datos. El “Sistema de Archivos” es un componente importante de un S.3. fundamentalmente con el almacenamiento de disco. Una forma de organización de un sistema de archivos puede ser la siguiente: • Se utiliza una “raíz ” para indicar en qué parte del disco comienza el “directorio raíz ”. Abraham Gamarra Moreno . O. • 7. EL SISTEMA DE ARCHIVOS Un “Archivo” es un conjunto de registros relacionados. Un “directorio de usuario” contiene una entrada para cada uno de los archivos del usuario. en vez de una “visión física”. compartidos y asegurados. El usuario no debe tener que preocuparse por: • Los dispositivos particulares. • Los medios físicos de la transferencia de datos hacia y desde los dispositivos. • El formato de los datos en los dispositivos. “Integridad del archivo” para garantizar la integridad de la información del archivo. “Administración de archivos” referida a la provisión de mecanismos para que los archivos sean almacenados. • • • El sistema de archivos está relacionado especialmente con la administración del espacio de almacenamiento secundario. y suele contener: • “Métodos de acceso” relacionados con la manera de acceder a los datos almacenados en archivos.

2).1. .4. Algunos sistemas de archivos distinguen entre las letras mayúsculas y minúsculas. 7. aunque las extensiones suelen ser meras convenciones. • Posee máxima flexibilidad.2. 7. mientras que otros no. El nombre del sistema para un archivo dado debe ser único para el sistema de archivos. O. En sistemas de archivo “jerárquicos” el nombre del sistema para un archivo suele estar formado como el “nombre de la trayectoria” del directorio raíz al archivo. O.• Cada entrada de archivo apunta al lugar del disco donde está almacenado el archivo referenciado. ARCHIVOS Se considerará el punto de vista del usuario. NOMBRE DE LOS ARCHIVOS Las reglas exactas para los nombres de archivos varían de sistema a sistema.El S. Muchos S. no ayuda pero tampoco estorba.4. • 170 “Secuencia de registros”: SISTEMAS OPERATIVOS . utilizan nombres de archivo con dos partes. 7. Los nombres de archivos solo necesitan ser únicos dentro de un directorio de usuario dado.1 y Figura 7.4. ESTRUCTURA DE UN ARCHIVO Los archivos se pueden estructurar de varias maneras (Figura 7. las más comunes son: • “Secuencia de bytes”: • El archivo es una serie no estructurada de bytes. separadas por un punto: • La parte posterior al punto es la extensión de archivo y generalmente indica algo relativo al archivo.

no necesariamente de la misma longitud.El archivo es una secuencia de registros de longitud fija.. Abraham Gamarra Moreno 171 . • “Árbol ”: . (b) Secuencia de registros. cada uno con su propia estructura interna. . .Cada registro tiene un campo key (llave o clave) en una posición fija del registro. Mg. Figura 7.El archivo consta de un árbol de registros.1.El árbol se ordena mediante el campo de clave para permitir una rápida búsqueda de una clave particular. Estructura de archivos: (a) Secuencia de bytes.

Los Directorios son archivos de sistema para el mantenimiento de una estructura del sistema de archivos. • Los Archivos Especiales de Bloques se utilizan para modelar discos.4. • Se utilizan para modelar dispositivos seriales de e / s (terminales.3. soportan varios tipos de archivos. Estructura de archivos: Árbol 7. O. 172 SISTEMAS OPERATIVOS . directorios. redes. ACCESO A UN ARCHIVO Los tipos de acceso más conocidos son: • Acceso Secuencial: el proceso lee en orden todos los registros del archivo comenzando por el principio. archivos especiales de caracteres. sin poder: • Saltar registros.4.).: archivos regulares.Figura 7. por ej. impresoras.2..4. donde: • Los Archivos Regulares son aquellos que contienen información del usuario. archivos especiales de bloques. etc. • • 7. etc. TIPOS DE ARCHIVOS Muchos S. Los Archivos Especiales de Caracteres: • Tienen relación con la e / s.

• Una operación especial (seek) establece la posición de trabajo pudiendo luego leerse el archivo secuencialmente. “Propietario”: propietario actual. “Bandera de acceso aleatorio”: 0 solo acceso secuencial. 1 para no exhibirse en listas. “Banderas de cerradura”: 0 no bloqueado.4. “Contraseña”: contraseña necesaria para acceder al archivo.• Leer en otro orden. 1 para lectura exclusivamente. que varían considerablemente de sistema a sistema. Elementos adicionales llamados atributos. “Bandera de biblioteca”: 0 ya se ha respaldado. 1 necesita respaldo. 7. “Bandera ascii / binario”: 0 archivo en ascii.lectura”: 0 lectura / escritura. “Bandera exclusivo .para . 1 archivo en binario. “Creador”: identificador de la persona que creó el archivo. “Bandera de ocultamiento”: 0 normal. distinto de 0 bloqueado. Algunos de los posibles atributos de archivo son: • • • • • “Protección”: quién debe tener acceso y de qué forma. 1 archivo de sistema. • Acceso Aleatorio: el proceso puede leer los registros en cualquier orden utilizando dos métodos para determinar el punto de inicio de la lectura: • Cada operación de lectura (read) da la posición en el archivo con la cual iniciar. “Bandera temporal”: 0 normal. 1 acceso aleatorio. Abraham Gamarra Moreno .5. “Bandera de sistema”: 0 archivo normal. “Longitud del registro”: número de bytes en un registro. ATRIBUTOS DE ARCHIVO Cada archivo tiene: • • Su nombre y datos. 173 • • • • • • • • Mg. 1 eliminar al salir del proceso.

“Tiempo del último acceso”: fecha y hora del último acceso al archivo. quien hace la llamada debe especificar la cantidad de datos necesarios y proporcionar un buffer para colocarlos. La finalidad es permitir que el sistema traslade los atributos y la lista de direcciones en disco a la memoria principal para un rápido acceso en llamadas posteriores. los atributos y direcciones del disco ya no son necesarios. SISTEMAS OPERATIVOS • • • • • • 174 .4. O. Close (cerrar): cuando concluyen los accesos. eliminan automáticamente un archivo no utilizado durante “n” días. “Tamaño máximo”: tamaño máximo al que puede crecer el archivo. Seek (buscar): especifica el punto donde posicionarse. Delete (eliminar): si el archivo ya no es necesario debe eliminarse para liberar espacio en disco. • • 7. en la posición actual. “Tiempo de creación”: fecha y hora de creación del archivo. Solo puede añadir datos al final del archivo. Write (escribir): los datos se escriben en el archivo. por lo que el archivo debe cerrarse y liberar la tabla de espacio interno. “Longitud de la llave”: número de bytes en el campo llave. Open (abrir): antes de utilizar un archivo. “Tiempo de la última modificación”: fecha y hora de la última modificación al archivo. Ciertos S. “Tamaño actual”: número de bytes en el archivo.• • • • • “Posición de la llave”: ajuste de la llave dentro de cada registro. un proceso debe abrirlo. El tamaño del archivo puede aumentar (agregado de registros) o no (actualización de registros). Append (añadir): es una forma restringida de “write”. OPERACIONES CON ARCHIVOS Las llamadas más comunes al sistema relacionadas con los archivos son: • • Create (crear): el archivo se crea sin datos. Cambia la posición del apuntador a la posición activa en cierto lugar del archivo. Read (leer): los datos se leen del archivo.6.

ya que las modificaciones hechas en las páginas no se verán reflejadas en el disco hasta que dichas páginas sean eliminadas de la memoria. Se utilizan las llamadas al sistema “map” y “unmap”: • “Map”: utiliza un nombre de archivo y una dirección virtual y hace que el S. “Unmap”: elimina los archivos del espacio de direcciones y concluye la operación de asociación. permiten asociar los archivos con un espacio de direcciones de un proceso en ejecución. Abraham Gamarra Moreno 175 . Dificultad para compartir los archivos mapeados evitando inconsistencias. O.5. O. • • 7. La información relativa al modo de protección y la mayoría de las banderas son un ejemplo obvio. Set attributes (establecer atributos): algunos atributos pueden ser determinados por el usuario y modificados luego de la creación del archivo. facilitando la programación. asocie al archivo con la dirección virtual en el espacio de direcciones. En muchos sistemas son a su vez también archivos. • El mapeo de archivos elimina la necesidad de programar la e / s directamente. Rename (cambiar de nombre): permite modificar el nombre de un archivo ya existente.4. para llevar un registro de los archivos. Los principales problemas relacionados son: • Imposibilidad de conocer a priori la longitud del archivo de salida. el que podría superar a la memoria.7.• Get attributes (obtener atributos): permite a los procesos obtener los atributos del archivo. Mg. O. • 7. por lo cual las lecturas o escrituras de las áreas de memoria asociadas al archivo se efectúan también sobre el archivo mapeado. DIRECTORIOS Generalmente son utilizados por los S. ARCHIVOS MAPEADOS A MEMORIA Algunos S.

1. • • • • Figura 7.: Busca en su directorio el nombre del archivo. (b) Atributos en otro lugar El número y organización de directorios varía de sistema en sistema: • 176 Directorio único: el sistema tiene un solo directorio con todos los archivos de todos los usuarios (ver Figura 7. Las direcciones en disco donde se almacenan los datos. Al abrir un archivo el S.5. Una posibilidad es que el directorio contenga por cada archivo referenciado: • • • El nombre. Graba esta información en una tabla de memoria real. O.3 Directorios: (a) Atributos en la entrada del directorio. Sus atributos.3).4). Todas las referencias subsecuentes al archivo utilizarán la información de la memoria principal. Un apuntador a otra estructura de datos donde se encuentran los atributos y las direcciones en disco. SISTEMAS JERÁRQUICOS DE DIRECTORIOS El directorio contiene un conjunto de datos por cada archivo referenciado (ver Figura 7. Otra posibilidad es que cada entrada del directorio contenga: • • El nombre del archivo. Extrae los atributos y direcciones en disco. SISTEMAS OPERATIVOS .7.

• Figura 7. Un directorio por usuario Mg. Abraham Gamarra Moreno 177 . respetando una jerarquía general (ver Figura 7.• Un directorio por usuario: el sistema habilita un solo directorio por cada usuario (ver Figura 7.6).5). Un árbol de directorios por usuario: el sistema permite que cada usuario tenga tantos directorios como necesite.5.4 Un solo directorio compartido por todos los usuarios Figura 7.

Figura 7. 178 SISTEMAS OPERATIVOS . Consta de la ruta de acceso desde el directorio raíz hasta el archivo.6.5. Un árbol arbitrario por usuario 7.2. NOMBRE DE LAS RUTAS DE ACCESO Cuando el sistema de archivos está organizado como un árbol de directorios se necesita una forma de determinar los nombres de los archivos. Los principales métodos para nombres de los archivos son: • Ruta de Acceso Absoluta: Cada archivo tiene una ruta de acceso absoluta.

5. El nombre absoluto de la ruta de acceso siempre funciona. Delete (eliminar): se elimina un directorio.3. éste debe ser abierto. OPERACIONES CON DIRECTORIOS Las llamadas al sistema permitidas para el manejo de los directorios tienen variación de sistema a sistema. Mg. Ejemplo: /usr/ast/mailbox • Ruta de Acceso Relativa: Se utiliza junto con el concepto de directorio de trabajo o directorio activo. Abraham Gamarra Moreno 179 • • • • . Readdir (leer directorio): regresa la siguiente entrada en un directorio abierto. Closedir (cerrar directorio): cuando se ha leído un directorio. Opendir (abrir directorio): se pueden leer los directorios. sin importar el tipo de estructura de directorios que se utilice. que debe estar vacío. éste debe ser cerrado para liberar el espacio correspondiente de la tabla interna. Todos los nombres que no comiencen en el directorio raíz se toman en relación con el directorio de trabajo. Las más comunes son las siguientes: • • • Create (crear): se crea un directorio vacío. 7. sin importar cual sea el directorio de trabajo. Link (ligar): es una técnica que permite que un archivo aparezca en más de un directorio: • Especifica un archivo existente y el nombre de una ruta de acceso. antes de poder leer un directorio. entonces el archivo cuya ruta de acceso absoluta es /usr/ast/mailbox puede llamarse sólo con mailbox. Rename (cambiar de nombre): cambia el nombre de un directorio de manera similar al cambio para archivos.Los componentes de la ruta de acceso se separan mediante algún carácter llamado “separador”. Ejemplo: Si el directorio de trabajo es /usr/ast.

La forma de hacerlo de manera eficiente y confiable. • Si el archivo que se desea desligar. • “Recolección de basura o residuos”: se puede hacer fuera de línea o en línea.1. La administración del espacio en disco. está presente en varios directorios: Solo se elimina la ruta de acceso especificada. 7. con el sistema activo. • Unlink (desligar): se elimina una entrada del directorio: .6. según la implementación. Una técnica para aliviar el problema de la “fragmentación” consiste en realizar periódicamente: • “Condensación”: se pueden “reorganizar” los archivos expresamente o automáticamente según algún criterio predefinido. Se deben tener presentes problemas tales como la “fragmentación” creciente del espacio en disco: • Ocasiona problemas de performance al hacer que los archivos se desperdiguen a través de bloques muy dispersos.Si el archivo que se desea desligar aparece solo en un directorio (el caso normal): Se elimina del sistema de archivos.6. IMPLANTACIÓN DE ARCHIVOS El aspecto clave de la implantación del almacenamiento de archivos es el registro de los bloques asociados a cada archivo. Las demás rutas permanecen. IMPLANTACIÓN DEL SISTEMA DE ARCHIVOS Y SUS RELACIONES CON LA ASIGNACIÓN Y LIBERACIÓN DE ESPACIO Se consideran aspectos tales como: • • • La forma de almacenamiento de archivos y directorios. • 7. Algunos de los métodos utilizados son los siguientes: 180 SISTEMAS OPERATIVOS .• Crea un enlace del archivo ya existente con el nombre especificado en la ruta de acceso.

Se asignan bloques de sectores contiguos en vez de sectores individuales. . Asignación no contigua: Son esquemas de almacenamiento más dinámicos. • • Asignación por bloques: Es más eficiente y reduce la sobrecarga en ejecución. El mantenimiento de la estructura de “listas encadenadas” significa una sobrecarga en tiempo de ejecución. la recuperación de registros lógicamente contiguos puede significar largas búsquedas. Las formas más comunes de implementar la asignación por bloques son: Mg. Los archivos constan de varios sectores que pueden estar dispersos por todo el disco. destacándose los siguientes: Asignación encadenada orientada hacia el sector: El disco se considera compuesto de sectores individuales. Las principales desventajas son: • Debido a la posible dispersión en el disco. Las ampliaciones o reducciones en el tamaño de los archivos se resuelven actualizando la “lista de espacio libre” y no hay necesidad de condensación.Rendimiento excelente respecto de la e/s. Es una mezcla de los métodos de asignación contigua y no contigua. Una “lista de espacio libre” contiene entradas para todos los sectores libres del disco.Asignación contigua o adyacente: Los archivos son asignados a áreas contiguas de almacenamiento secundario. Produce una gran fragmentación de los discos. Los principales defectos son: • • Se debe conocer el tamaño máximo del archivo al crearlo. Los apuntadores de la estructura de lista consumen espacio en disco. Abraham Gamarra Moreno 181 . Las principales ventajas son: • Facilidad de implantación. El sistema trata de asignar nuevos bloques a un archivo eligiendo bloques libres lo más próximos posible a los bloques del archivo existentes. Los sectores que pertenecen a un archivo común contienen apuntadores de uno a otro formando una “lista encadenada”. ya que solo se precisa el número del bloque de inicio para localizar un archivo.

Un apuntador al bloque siguiente (Figura 7. Encadenamiento de bloques de índice. Figura 7. Encadenamiento de bloques o lista ligada Las entradas en el directorio de usuarios apuntan al primer bloque de cada archivo. Transformación de archivos orientada hacia bloques. Frecuentemente el tamaño de un bloque se corresponde con el de una pista completa del disco. Cada bloque contiene varios sectores. Cada uno de los bloques de longitud fija que forman un archivo contiene dos partes: • • Un bloque de datos. Encadenamiento de bloques Localizar un registro determinado requiere: 182 SISTEMAS OPERATIVOS .7.7).• • • Encadenamiento de bloques.

se encadena una serie de bloques de índices.* Buscar en la cadena de bloques hasta encontrar el bloque apropiado. * Cada entrada contiene un identificador de registros y un apuntador a ese registro. 183 Mg. * Si es necesario utilizar más de un bloque de índices para describir un archivo. Encadenamiento de bloques de índices Los apuntadores son colocados en varios bloques de índices separados: * Cada bloque de índices contiene un número fijo de elementos. Se pueden usar “listas de encadenamiento doble”. con lo que se facilita la búsqueda. La Figura 7. Figura 7. y pueden estar dispersos por todo el disco. Almacenamiento de un archivo como lista ligada o lista enlazada. Abraham Gamarra Moreno . El examen de la cadena desde el principio puede ser lento ya que debe realizarse de bloque en bloque. muestra otra figura para el almacenamiento de un archivo como lista ligada o lista enlazada. * Buscar en el bloque hasta encontrar el registro.8. dado que se deben modificar los apuntadores del bloque precedente. hacia adelante y hacia atrás. La inserción y el retiro son inmediatos.8.

sin importar el tamaño del archivo (ver Figura 7.9). Es suficiente que el dato del directorio contenga el número de bloque inicial para localizar todos los bloques restantes. pero para mejor performance podrían mantenerse en el almacenamiento primario.La gran ventaja es que la búsqueda puede realizarse en los propios bloques de índices.Los bloques de índices pueden mantenerse juntos en el almacenamiento secundario para acortar la búsqueda. Figura 7. La principal desventaja es que las inserciones pueden requerir la reconstrucción completa de los bloques de índices: * Una posibilidad es dejar vacía una parte de los bloques de índices para facilitar inserciones futuras y retardar las reconstrucciones.9 Encadenamiento de bloques de índices 184 SISTEMAS OPERATIVOS .

10). • • Mg.Transformación de archivos orientada hacia bloques Se utilizan números de bloques en vez de apuntadores.Cada entrada al mapa del archivo contiene el número del bloque siguiente de ese archivo.En rigor. Abraham Gamarra Moreno 185 . Si el archivo es grande. una de las direcciones en el nodo-i es la dirección de un bloque en el disco llamado bloque simplemente indirecto: Contiene las direcciones en disco adicionales. Los números de bloques se convierten fácilmente a direcciones de bloques gracias a la geometría del disco. Nodos-i (nodos índices) Se asocia a cada archivo una pequeña tabla. llamada nodo-i (nodo índice): • • Contiene los atributos y direcciones en disco de los bloques del archivo. almacena solo las primeras direcciones en disco: Si el archivo es pequeño. La entrada al mapa del archivo correspondiente a la última entrada de un archivo determinado se ajusta a algún valor “centinela” (“nil”) para indicar que se alcanzó el último bloque de un archivo. Si resulta insuficiente.11). El sistema puede mantener una lista de bloques libres. De ser necesario se pueden utilizar bloques triplemente indirectos (ver Figura 7. La principal ventaja es que las cercanías físicas del disco se reflejan en el mapa del archivo (ver Figura 7. otra dirección en el nodo-i. Las entradas en el directorio del usuario apuntan a la primera entrada al mapa del archivo para cada archivo. Se conserva un mapa del archivo. el bloque doblemente indirecto. Se traslada del disco a la memoria principal al abrir el archivo. toda la información está en el nodo-i. contiene la dirección de un bloque que presenta una lista de los bloques simplemente indirectos: Cada bloque simplemente indirecto apunta a un grupo de bloques de datos. conteniendo una entrada para cada bloque del disco.

Figura 7.10 Transformación de archivos orientada hacia bloques 186 SISTEMAS OPERATIVOS .

• La principal función del sistema de directorios es asociar el nombre del archivo con la información necesaria para localizar los datos. Esquema de un nodo-i 7. O.Figura 7.7. 187 Mg. utiliza información del directorio: • El directorio contiene la información necesaria para encontrar los bloques en el disco. El tipo de información varía según el sistema. Un aspecto íntimamente ligado con esto es la posición de almacenamiento de los atributos: • Una posibilidad es almacenarlos en forma directa dentro del dato del directorio.11. Abraham Gamarra Moreno . IMPLANTACIÓN DE DIRECTORIOS Para abrir un archivo el S.

12 muestra el almacenamiento de directorios en MS-DOS.14 muestra los pasos en la búsqueda de un directorio. DIRECTORIOS EN MS-DOS La Figura 7. Figura 7.13 Una entrada de directorio en UNIX 188 SISTEMAS OPERATIVOS .• Otra posibilidad es almacenar los atributos en el nodo-i en vez de utilizar la entrada del directorio.1. 7. La Figura 7. Un dato de directorio en MS-DOS. Figura 7.13 muestra una entrada de dicrectorio en UNIX.7.12. La figura 7.

Sistemas Operativos Modernos. Tanenbaum A. Argentina: Universidad Nacional Del Nordeste U. Mg. Mexico: Pearson Educación. Segunda Edición. Introducción a los Sistemas Operativos. Abraham Gamarra Moreno 189 . Bibliografía Recomendada • Deitel M.14 Los pasos en la búsqueda de /usr/ast/mbox Resumen Todas las aplicaciones computarizadas necesitan almacenar y recuperar la información de unidades llamadas archivos.N. y para ello deben utilizar los discos y otros medios externos. 1998. • • Nexo La siguiente unidad académica amplia el Sistema de Archivos. Segunda Edición.E. 2001.N. Sistemas Operativos Modernos. Luis la Red Martínez D. España: Addison Wesley Iberoamericana.Figura 7.. 2003. Indicadores de logro El lector explica los fundamentos de los archivos y directorios.

Auto evaluación formativa Escriba programas que encuentren la solución a los siguientes problemas: PROBLEMA UNO Escriba un programa que simule el uso de los archivos. 190 SISTEMAS OPERATIVOS . PROBLEMA DOS Escriba un programa que simule el uso de los directorios.Actividad Analice los aspectos teóricos sobre el Sistema de Archivos.

para lo que se consideraran dos soluciones posibles. Si los directorios realmente contienen direcciones en disco: • Se debe tener una copia de las direcciones en disco en el directorio que accede al archivo compartido al enlazar el archivo.1).2).PARTE 2 8. que podría ser el nodo-i.1. 191 • Mg. Se debe evitar que los cambios hechos por un usuario a través de un directorio no sean visibles por los demás usuarios. Abraham Gamarra Moreno . ARCHIVOS COMPARTIDOS Frecuentemente conviene que los archivos compartidos aparezcan simultáneamente en distintos directorios de distintos usuarios. sino en una pequeña estructura de datos asociada al propio archivo.UNIDAD ACADEMICA 8 SISTEMA DE ARCHIVOS . Los directorios apuntarían solo a esa pequeña estructura de datos. El propio sistema de archivos es una gráfica dirigida acíclica en vez de un árbol (ver Figura 8. • Primera solución: • Los bloques del disco no se enlistan en los directorios. La conexión entre un directorio y un archivo de otro directorio al cual comparten se denomina enlace (Figura 8.

2. (c) Después que el propietario original elimina el archivo. 192 SISTEMAS OPERATIVOS . (b) Después de la creación del enlace. Sistema de archivos con un archivo compartido Figura 8. (a) Situación anterior al enlace.1.Figura 8.

Abraham Gamarra Moreno 193 . en cualquier parte del mundo. Esto no ocurre con los enlaces simbólicos ya que solo el propietario verdadero tiene un apuntador al nodo-i: Los usuarios enlazados al archivo solo tienen nombres de rutas de acceso y no apuntadores a nodo-i. especialmente en accesos a disco. Si el propietario inicial del archivo intenta eliminarlo. • • Los enlaces simbólicos tienen la ventaja de que se pueden utilizar para enlazar archivos en otras máquinas. puesto que se debe leer el archivo que contiene la ruta de acceso. el directorio que enlazo al archivo tendrá una entrada que apunta a un nodo-i no válido. analizarla y seguirla componente a componente hasta alcanzar el nodo-i. El sistema: Puede ver por medio del contador de enlaces en el nodo-i que el archivo sigue utilizándose. Los archivos pueden tener dos o más rutas de acceso. este se destruye. El archivo “link”: Ingresa al directorio del usuario que accede a un archivo de otro directorio y usuario. Aumenta el contador de enlaces del nodo-i: El sistema sabe el número de entradas de directorio que apuntan en cierto momento al archivo. Cuando el propietario elimina un archivo. para el cual dicho archivo ya no existe. en búsquedas genéricas se podría encontrar el mismo archivo por distintas rutas y tratárselo como si fueran archivos distintos. • • Desventajas de la segunda solución: • El principal problema es su costo excesivo. surge un problema para el sistema: Si elimina el archivo y limpia el nodo-i. No puede localizar todas las entradas de directorio asociadas a ese archivo para eliminarlas. Si el nodo-i se reasigna a otro archivo el enlace apuntará al archivo incorrecto. Se precisa un nodo-i adicional por cada enlace simbólico y un bloque adicional en disco para almacenar la ruta de acceso.Segunda solución: • • El enlace se produce haciendo que el sistema cree un nuevo archivo de tipo “link”. La solución podría ser: Eliminar la entrada del directorio inicialmente propietario del archivo. Solo contiene el nombre de la ruta de acceso del archivo al cual se enlaza. Dejar intacto el nodo-i: Se daría el caso que el directorio que posee el enlace es el único que posee una entrada de directorio para un archivo de otro directorio. se debe proMg. Desventajas de la primera solución: • La creación de un enlace: No modifica la propiedad respecto de un archivo. Este criterio se denomina enlace simbólico. debido a lo cual.

porcionar solo la dirección de la red de la máquina donde reside el archivo y su ruta de acceso en esa máquina. 2k o 4k (ver Figura 8. como un sector. lo que puede afectar seriamente al rendimiento. Generalmente se utilizan como solución de compromiso bloques de 1/2 k. esto significa que cada archivo. ocupará todo un cilindro.2. Demora rotacional. como un cilindro.3). con esto se desperdicia espacio de almacenamiento en disco. ADMINISTRACIÓN DEL ESPACIO EN DISCO Existen dos estrategias generales para almacenar un archivo de “n” bytes: • Asignar “n” bytes consecutivos de espacio en el disco: Tiene el problema de que si un archivo crece será muy probable que deba desplazarse en el disco. la pista y el cilindro son los candidatos obvios como unidades de asignación. el sector. implica que cada archivo constará de muchos bloques. con esto su lectura generará muchas operaciones de e / s afectando la performance. inclusive uno pequeño. Transferencia. Dividir el archivo en cierto número de bloques (no necesariamente) adyacentes: Generalmente los sistemas de archivos utilizan esta estrategia con bloques de tamaño fijo. • 8.1. Lo anterior indica que la eficiencia en tiempo y espacio tienen un conflicto inherente. Si se utiliza una unidad de asignación pequeña. 1k. Hay que recordar que el tiempo de lectura de un bloque de disco es la suma de los tiempos de: • • • Búsqueda. 8.2. TAMAÑO DEL BLOQUE: Dada la forma en que están organizados los bloques. 194 SISTEMAS OPERATIVOS . Si se tiene una unidad de asignación grande.

Uso del espacio en disco (%)

Figura 8.3. Representación de la velocidad de lectura y del uso del espacio en disco en función del tamaño del bloque

8.2.2. REGISTRO DE LOS BLOQUES LIBRES:
Se utilizan por lo general dos métodos (ver Figura 8.4): • • La lista de bloques libres como lista ligada. Un mapa de bits.

Lista ligada de bloques de disco: • • Cada bloque contiene tantos números de bloques libres como pueda. Los bloques libres se utilizan para contener a la lista de bloques libres.

Mapa de bits: • • Un disco con “n” bloques necesita un mapa de bits con “n” bits. Los bloques libres se representa con “1” y los asignados con “0” (o viceversa). Generalmente este método es preferible cuando existe espacio suficiente en la memoria principal para contener completo el mapa de bits.

Mg. Abraham Gamarra Moreno

195

Figura 8.4. Registro de los bloques libres.

8.2.3. DISK QUOTAS
Para evitar que los usuarios se apropien de un espacio excesivo en disco, los S. O. multiusuario proporcionan generalmente un mecanismo para establecer las cuotas en el disco (ver Figura 8.5). La idea es que: • Un administrador del sistema asigne a cada usuario una proporción máxima de archivos y bloques. El S. O. garantice que los usuarios no excedan sus cuotas.

Un mecanismo utilizado es el siguiente: • Cuando un usuario abre un archivo: Se localizan los atributos y direcciones en disco. Se colocan en una tabla de archivos abiertos en la memoria principal. Uno de los atributos indica el propietario del archivo; cualquier aumento del tamaño del archivo se carga a la cuota del propietario. Una segunda tabla contiene el registro de las cuotas para cada uno de los usuarios que tengan un archivo abierto en ese momento, aún cuando el archivo lo haya abierto otro usuario. Cuando se escribe una nueva entrada en la tabla de archivos abiertos: Se introduce un apuntador al registro de la cuota del propietario para localizar los límites.

196

SISTEMAS OPERATIVOS

Cuando se añade un bloque a un archivo: Se incrementa el total de bloques cargados al propietario. Se verifica este valor contra los límites estricto y flexible (el primero no se puede superar, el segundo sí). También se verifica el número de archivos.

Figura 8.5. Mecanismo para establecer las cuotas en el disco.

8.3. CONFIABILIDAD DEL SISTEMA DE ARCHIVOS
Es necesario proteger la información alojada en el sistema de archivos, efectuando los resguardos correspondientes. De esta manera se evitan las consecuencias generalmente catastróficas de la pérdida de los sistemas de archivos. Las pérdidas se pueden deber a problemas de hardware, software, hechos externos, etc.

8.3.1. MANEJO DE UN BLOQUE DEFECTUOSO:
Se utilizan soluciones por hardware y por software. La solución en hardware: • • Consiste en dedicar un sector del disco a la lista de bloques defectuosos. Al inicializar el controlador por primera vez:
197

Mg. Abraham Gamarra Moreno

- Lee la “lista de bloques defectuosos”. - Elige un bloque (o pista) de reserva para reemplazar los defectuosos. - Registra la asociación en la lista de bloques defectuosos. - En lo sucesivo, las solicitudes del bloque defectuoso utilizarán el de repuesto.

La solución en software: • Requiere que el usuario o el sistema de archivos construyan un archivo con todos los bloques defectuosos. Se los elimina de la “lista de bloques libres”. Se crea un “archivo de bloques defectuosos”: - Esta constituido por los bloques defectuosos. - No debe ser leído ni escrito. - No se debe intentar obtener copias de respaldo de este archivo.

• •

8.3.2. RESPALDOS BACKUP):

(COPIAS

DE

SEGURIDAD

O

DE

Es muy importante respaldar los archivos con frecuencia. Los respaldos pueden consistir en efectuar copias completas del contenido de los discos (flexibles o rígidos). Una estrategia de respaldo consiste en dividir los discos en áreas de datos y áreas de respaldo, utilizándolas de a pares (ver Figura 8.6): • Se desperdicia la mitad del almacenamiento de datos en disco para respaldo. Cada noche (o en el momento que se establezca), la parte de datos de la unidad 0 se copia a la parte de respaldo de la unidad 1 y viceversa.

198

SISTEMAS OPERATIVOS

Se obtiene una copia diaria solo de aquellos archivos modificados desde la última copia total. Si el sistema falla antes de escribir en los bloques modificados. Puede requerir una gran cantidad de cintas de respaldo dedicadas a los respaldos diarios entre respaldos completos.3.3. la que debe ser actualizada cada vez que se obtienen copias de los archivos y cada vez que los archivos son modificados. se copian solo aquellos archivos modificados desde la última vez que dichos archivos fueron copiados. Abraham Gamarra Moreno 199 . Se debe mantener en el disco información de control como una “lista de los tiempos de copiado” de cada archivo.: una vez por mes o por semana). llamada copia total. CONSISTENCIA DEL SISTEMA DE ARCHIVOS: Muchos sistemas de archivos leen bloques. el sistema de archivos puede quedar en un “estado inconsistente”. los modifican y escriben en ellos después. Mg. • • • 8.Figura 8.6 El respaldo de cada unidad en la otra desperdicia la mitad del espacio de almacenamiento Otra estrategia es el vaciado por incrementos o respaldo incremental: • Se obtiene una copia de respaldo periódicamente (por ej. en estrategias mejoradas.

Bloques de directorios. sí en los basados en tablas o listas. La solución consiste en depurar la tabla de bloques libres. Pueden actuar sobre todos o algunos de los discos. Si un bloque no aparece en ninguna de las tablas se trata de una falla llamada bloque faltante: • • No produce daños pero desperdicia espacio en disco. La consistencia del sistema de archivos no asegura la consistencia interna de cada archivo.La inconsistencia es particularmente crítica si alguno de los bloques afectados son: • • • Bloques de nodos-i. • Generalmente los utilitarios utilizan dos tablas (ver Figura 8. Se soluciona añadiendo el bloque a la tabla de bloques libres. Pueden efectuar verificaciones a nivel de bloques y a nivel de archivos. Cada bloque debe estar referenciado en una de ellas. La mayoría de los sistemas dispone de un programa utilitario que verifica la consistencia del sistema de archivos: • • • • Se pueden ejecutar al arrancar el sistema o ha pedido.7): • • • Tabla de bloques en uso. Generalmente pueden verificar también el sistema de directorios y / o de bibliotecas. • 200 SISTEMAS OPERATIVOS . Bloques de la lista de bloques libres. También podría detectarse la situación de falla debida a un bloque referenciado dos veces en la tabla de bloques libres: • Esta falla no se produce en los sistemas de archivos basados en mapas de bits. Tabla de bloques libres. respecto de su contenido.

. (c) Bloque duplicado en la lista de bloques libres. Si uno de los archivos se borra.Copie en el bloque libre el contenido del bloque conflictivo.Actualice las tablas afectando el bloque copia a alguno de los archivos. (d) Bloque de datos duplicado. (a) Consistente (b) Bloque faltante. Abraham Gamarra Moreno . • Figura 8.Asigne un bloque libre.7 Estados del sistema de archivos. Otro error posible es que un bloque esté en la tabla de bloques en uso y en la tabla de bloques libres: • Se soluciona eliminándolo de la tabla de bloques libres.Agregue el bloque conflictivo a la tabla de bloques libres. . el bloque aparecería en la tabla de bloques libres y también en la de bloques en uso. Las verificaciones de directorios incluyen controles como: • Número de directorios que apuntan a un nodo-i con los contadores de enlaces almacenados en los propios nodos-i.Una falla muy grave es que el mismo bloque de datos aparezca referenciado dos o más veces en la tabla de bloques en uso: • • Como parte del mismo o de distintos archivos. . en un sistema consistente de archivos deben coincidir. 201 Mg. . Una solución es que el verificador del sistema de archivos: .Informe al usuario para que verifique el daño detectado y la solución dada.

entonces. • • • También se pueden hacer verificaciones heurísticas. DESEMPEÑO DEL SISTEMA DE ARCHIVOS El acceso al disco es mucho más lento que el acceso a la memoria: • Los tiempos se miden en milisegundos y en nanosegundos respectivamente. pero el nodo-i indica que solo existe un enlace. Uno de los directorios apunta hacia un nodo-i no utilizado. el contador del nodo-i tomará el valor 0. • • Otro tipo de error es potencialmente catastrófico: • Si dos entradas de un directorio se enlazan a un archivo. La solución es forzar que el contador de enlaces del nodo-i sea igual al número de entradas del directorio. No se trata de un error serio pero produce desperdicio de espacio en disco con archivos que no se encuentran en ningún directorio.. Debido al valor 0 el sistema de archivos lo señala como no utilizado y libera todos sus bloques.4. por ej. pero algunos modos son válidos aunque extraños: . al eliminar cualquiera de estas entradas de directorio. 8.: Se prohíbe el acceso al propietario y todo su grupo. si el valor correcto es 0. por ej.La verificación debería detectar e informar de estas situaciones.Una posible falla es que el contador de enlaces sea mayor que el número de entradas del directorio: • Aunque se eliminaran todos los archivos de los directorios el contador sería distinto de cero y no se podría eliminar el nodo-i. escribir y ejecutar el archivo. el archivo debe eliminarse.Ej. Se debe reducir el número de accesos a disco. cuyos bloques se podrían asignar entonces a otros archivos. .Se debería informar como sospechosos aquellos directorios con excesivas entradas.: • Cada nodo-i tiene un modo. SISTEMAS OPERATIVOS • 202 . . pero se permite a los extraños leer. Se soluciona haciendo que el contador de enlaces en el nodo-i tome el valor correcto. más de mil.

Un caché es una colección de bloques que pertenecen desde el punto de vista lógico al disco. se satisface la solicitud sin un acceso a disco. sin volverse a escribir en el disco. Abraham Gamarra Moreno . Cuando hay que cargar un bloque en un caché totalmente ocupado: Hay que eliminar algún bloque y volverlo a escribir en el disco en caso de que haya sido modificado luego de haberlo traído del disco. ¿Es esencial el bloque para la consistencia del sistema de archivos?: Si es esencial (generalmente lo será si no es bloque de datos) y ha sido modificado. En caso negativo. 203 • Mg. pero que se mantienen en memoria por razones de rendimiento. como un bloque parcialmente ocupado que se está escribiendo. En caso afirmativo. debe escribirse en el disco de inmediato: Se reduce la probabilidad de que una falla total del sistema haga naufragar al sistema de archivos.La técnica más común para reducir los accesos a disco es el bloque caché o buffer caché: • Se utiliza el término ocultamiento para esta técnica (del francés “cacher”: ocultar). se lee en el caché y se modifica. Se debe elegir con cuidado el orden de escritura de los bloques críticos. • • • Se debe considerar la posibilidad de una falla total del sistema y su impacto en la consistencia del sistema de archivos: • Si un bloque crítico. como un bloque de un nodo-i. se lee para que ingrese al caché y luego se copia al lugar donde se necesite. Se plantea una situación muy parecida a la paginación y se resuelve con algoritmos similares. una falla total del sistema dejará al sistema de archivos en un estado inconsistente. Se deben tener en cuenta los siguientes factores: • ¿Es posible que el bloque modificado se vuelva a necesitar muy pronto?: Los bloques que se vayan a utilizar muy pronto. • Uno de los algoritmos más comunes para la administración del caché es el siguiente: • Verificar todas las solicitudes de lectura para saber si el bloque solicitado se encuentra en el caché. deberían permanecer un “largo tiempo”.

se puede mejorar colocando los nodos-i a la mitad del disco.8 (a) Nodos-i colocados al principio del disco. consiste en tener una llamada al sistema que fuerza una actualización general a intervalos regulares de algunos segundos (por ej. Los nodos-i deben estar a mitad del disco y no al principio. Otra solución consiste en escribir los bloques modificados (del caché) al disco. Requiere más e / s que otros tipos de cachés. • Figura 8. preferentemente en el mismo cilindro. próximos entre sí. 204 SISTEMAS OPERATIVOS .8): • Se deben colocar los bloques que probablemente tengan un acceso secuencial. reduciendo a la mitad el tiempo promedio de búsqueda entre el nodo-i y el primer bloque del archivo. tan pronto como haya sido escrito (el caché): • • Se dice que se trata de cachés de escritura. 30). La solución de algunos S. esto reduce a la mitad el tiempo promedio de búsqueda. Una técnica importante para aumentar el rendimiento de un sistema de archivos es la reducción de la cantidad de movimientos del brazo del disco (mecanismo de acceso .Figura 8. implica largas búsquedas.• No es recomendable mantener los bloques de datos en el caché durante mucho tiempo antes de rescribirlos. (b) Disco dividido en grupos de cilindros. cada uno con sus propios bloques y nodos-i. O.

pérdida de cintas o discos. por ej.8. • • La mayoría de estas causas se pueden enfrentar con el mantenimiento de los respaldos (back-ups) adecuados. errores de telecomunicación. Para diseñar un sistema seguro contra intrusos: Mg. revoluciones. etc. legales y políticos.5. de administración. razón por la que los sistemas de archivos deben protegerla. SEGURIDAD Los sistemas de archivos generalmente contienen información muy valiosa para sus usuarios.. 8. La frontera entre seguridad y mecanismos de protección no está bien definida. como incendios. terremotos. Abraham Gamarra Moreno 205 . Respecto del problema de los intrusos. mal montaje de cintas o discos. Errores de hardware o de software. entrada incorrecta de datos. roedores. Activos: desean hacer cambios no autorizados a los datos. discos o cintas ilegibles. Dos de las más importantes facetas de la seguridad son: • • La pérdida de datos.1. Los intrusos. se los puede clasificar como: • • Pasivos: solo desean leer archivos que no están autorizados a leer. debería haber copias en un lugar alejado de los datos originales. errores en los programas. Algunas de las causas más comunes de la pérdida de datos son: • Actos y hechos diversos. ejecución incorrecta de programas. esto incluye aspectos técnicos. Se consideraran mecanismos de protección a los mecanismos específicos del sistema operativo utilizados para resguardar la información de la computadora. etc. como fallas en la cpu.5. Errores humanos. etc. EL AMBIENTE DE SEGURIDAD Se entenderá por seguridad a los problemas generales relativos a la garantía de que los archivos no sean leídos o modificados por personal no autorizado. guerras. inundaciones.

Implica aspectos legales y morales. Utilizaba fallas se seguridad del Unix y de los programas Finger y Sendmail de Internet. Conocidos (técnicamente capacitados) husmeando. Arreglar las cosas para que la víctima utilice la versión modificada.• Hay que tener en cuenta el tipo de intrusos contra los que se desea tener protección. cuyo objetivo es intentar penetrar el sistema de seguridad para descubrir sus falencias y proponer soluciones. • Algunos tipos de intrusos son los siguientes: • • • • Curiosidad casual de usuarios no técnicos. Espionaje comercial o militar. • Además debe considerarse la posibilidad de ataques al estilo del gusano de Internet: • Fue liberado por Robert Tappan Morris el 02/11/88 e hizo que se bloquearan la mayoría de los sistemas Sun y Vax de Internet (fue descubierto y condenado). Intentos deliberados por hacer dinero. • También debe señalarse la posibilidad del ataque del caballo de Troya: • Modificar un programa normal para que haga cosas adversas además de su función usual. Otro aspecto del problema de la seguridad es la privacía: • Protección de las personas respecto del mal uso de la información en contra de uno mismo. • • Una forma de probar la seguridad de un sistema es contratar un grupo de expertos en seguridad. 206 SISTEMAS OPERATIVOS . Hay que ser consciente de que la cantidad de esfuerzo que se pone en la seguridad y la protección depende claramente de quién se piensa sea el enemigo. Constaba de un programa arrancador y del gusano propiamente dicho. conocido como el equipo tigre o equipo de penetración.

2. dado que los errores en donde se niega el acceso válido se reportan más rápido que los errores en donde se permite el acceso no autorizado. Comúnmente los virus se ejecutan e intentan reproducirse cada vez que se ejecuta el programa que los aloja.Verificar el permiso.5.Otro aspecto importante de la seguridad consiste en no subestimar los problemas que puede causar el personal. No utilizar copias “piratas”. Mg. Un virus difiere de un gusano en lo siguiente: Un virus está a cuestas de un programa existente. ya que pensar que el intruso no conocerá la forma de funcionamiento del sistema es un engaño.5. Son un enorme problema para muchos usuarios. Efectuar controles rigurosos y frecuentes con programas antivirus actualizados. • • • • • 8. Los virus y los gusanos intentan diseminarse y pueden crear un daño severo. Abraham Gamarra Moreno 207 . VIRUS Los virus computacionales: • • • Constituyen una categoría especial de ataque. Frecuentemente los problemas con los virus son más fáciles de evitar que de curar: Utilizar software original adquirido en comercios respetables. Generalmente se propagan a través de copias ilegítimas de programas. Un gusano es un programa completo en sí mismo. PRINCIPIOS DEL DISEÑO PARA LA SEGURIDAD El diseño del sistema debe ser público.3. El estado predefinido debe ser el de no acceso. Son fragmentos de programas que se añaden a programas legítimos con la intención de infectar a otros. Trabajar con metodología y disciplina rigurosa en el intercambio de discos y en las copias a través de redes de comunicación de datos. Verificar la autorización actual : • El sistema no debe: . 8.

No aceptarían fácilmente su propia culpa. Un proceso se ejecuta en alguno de los dominios de protección: 208 SISTEMAS OPERATIVOS . bases de datos. segmentos de memoria.9): • Cada pareja determina: Un objeto y un subconjunto de las operaciones que se pueden llevar a cabo en él. procesos. 8. uniforme e integrado hasta las capas más bajas del sistema: • • Dotar de seguridad a un sistema inseguro es casi imposible.1. terminales. La seguridad no es una característica que se pueda añadir fácilmente. El mecanismo de protección debe ser simple. MECANISMOS DE PROTECCIÓN 8.Abandonar esta información para su uso posterior. Figura 8. tales como la cpu. • El sistema tampoco debe: Verificar el permiso al abrir un archivo y no después de abrirlo. Se quejarían en caso de problemas. archivos. Es posible que un objeto se encuentre en varios dominios con “distintos” derechos en cada dominio. DOMINIOS DE PROTECCIÓN Muchos objetos del sistema necesitan protección. pues un acceso habilitado permanecería como válido aunque haya cambiado la protección del archivo. etc.. Cada objeto se referencia por un nombre y tiene habilitadas un conjunto de operaciones sobre él. El esquema de seguridad debe ser sicológicamente aceptable: • Los usuarios no deben sentir que la protección de sus archivos les implica demasiado trabajo: Podrían dejar de proteger sus archivos. impresoras. derechos. Dar a cada proceso el mínimo privilegio posible. Un dominio es un conjunto de parejas (objeto. Un derecho es el permiso para realizar alguna de las operaciones.6. unidades de disco. lo que implica un esquema de “protección de grano fino”.Determinar que el acceso está permitido. .6.

lleva un registro de los objetos que pertenecen a cada dominio es mediante una matriz (ver Figura 8. Figura 8.9 Tres dominios de protección En algunos S.10 Un proceso en MULTICS con cuatro anillos.• • Existe una colección de objetos a los que puede tener acceso. Abraham Gamarra Moreno . provoca una alternancia de dominio. O. Los procesos pueden alternar entre los dominios durante la ejecución. O.10). los dominios se llaman anillos (ver Figura 8. O. Cada objeto tiene cierto conjunto de derechos. Figura 8. Las columnas son los objetos. 209 Mg. Una llamada al S. Cada anillo es un dominio de protección independiente Una forma en la que el S.11): • • Los renglones son los dominios.

el grupo del propietario y los demás usuarios. La lista de control de acceso (ACL: access control list): • Asocia a cada objeto una lista ordenada con: Todos los dominios que pueden tener acceso al objeto.6. escribir. Una forma de implementar las ACL consiste en: • Asignar tres bits (r. grabación (w). LISTAS PARA CONTROL DE ACCESO Las “matrices de protección” son muy grandes y con muchos lugares vacíos: • • Desperdician espacio de almacenamiento. La forma de dicho acceso (ej: lectura (r). Permitir que el propietario de cada objeto pueda modificar su ACL en cualquier momento: Permite prohibir accesos antes permitidos. x) para cada archivo. w. para: El propietario. • 210 SISTEMAS OPERATIVOS .2. por ej. ejecución (x)). Figura 8.: leer. ejecutar. Existen métodos prácticos que almacenan solo los elementos no vacíos por filas o por columnas.• Cada elemento de la matriz contiene los derechos correspondientes al objeto en ese dominio.11 Una matriz de protección 8.

Sistemas Operativos Modernos. 2001. • • Actividad Analice los aspectos teóricos adicionales sobre el Sistema de Archivos. Abraham Gamarra Moreno 211 .N. Auto evaluación formativa Escriba programas que encuentren la solución a los siguientes problemas: PROBLEMA UNO Escriba un programa que simule la administración de archivos compartidos. Sistemas Operativos Modernos. razón por la que los sistemas de archivos deben protegerla. Es necesario proteger la información alojada en el sistema de archivos. Los sistemas de archivos generalmente contienen información muy valiosa para sus usuarios. 2003. efectuando los resguardos correspondientes..Resumen Frecuentemente conviene que los archivos compartidos aparezcan simultáneamente en distintos directorios de distintos usuarios. seguridad y mecanismos de protección. Bibliografía Recomendada • Deitel M. España: Addison Wesley Iberoamericana.N. Segunda Edición. Luis la Red Martínez D. Introducción a los Sistemas Operativos. PROBLEMA DOS Escriba un programa que simule el uso del registro de los bloques libres Mg. Argentina: Universidad Nacional Del Nordeste U.E. Indicadores de logro El lector explica los fundamentos de la confiabilidad. Segunda Edición. 1998. Mexico: Pearson Educación. Tanenbaum A.

PROBLEMA TRES Escriba un programa que simule el uso de la consistencia del sistema de archivos. PROBLEMA CUATRO Escriba un programa que simule el uso de los mecanismos de protección. 212 SISTEMAS OPERATIVOS .

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->