Escolar Documentos
Profissional Documentos
Cultura Documentos
FACULTAD DE INGENIERA
SISTEMAS OPERATIVOS
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. Generacin Cero (dcada de 1940): ...............................................................................12 1.2.2. Primera generacin (1945-1955): bulbos y conexiones ..................................................13 1.2.3. Segunda generacin (1955-1965): transistores y sistemas de procesamiento por lotes (batch) 13 1.2.4. Tercera generacin (1965-1980): circuitos integrados y multiprogramacin ................13 1.2.5. Cuarta generacin (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 monolticos: ......................................................................................................17 1.4.2. Sistemas con capas: .........................................................................................................18 1.4.3. Mquinas virtuales: .........................................................................................................20 1.4.4. Modelo cliente - servidor.................................................................................................21 1.5. MS 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 BIBLIOGRAFA RECOMENDADA ...........................................................................................................27 NEXO ...................................................................................................................................................28 ACTIVIDAD ..........................................................................................................................................28 AUTO EVALUACIN FORMATIVA..........................................................................................................28 UNIDAD ACADEMICA 2 ....................................................................................................................29 PLANIFICACION DE PROCESOS....................................................................................................29 2.1. CONCEPTOS DE PLANIFICACIN .................................................................................29 2.1.1. COLAS DE PLANIFICACIN ........................................................................................31 2.1.2. Planificadores..................................................................................................................33 2.2. PLANIFICACIN DE LA UCP...........................................................................................35 2.2.1. Ciclo de rfagas de UCP y de E/S ...................................................................................35 2.2.2. Planificador de la ucp......................................................................................................37 2.2.3. Estructura de planificacin .............................................................................................37 2.2.4. Cambio de contexto .........................................................................................................38 2.2.5. Despachador....................................................................................................................39 2.3. ALGORITMOS DE PLANIFICACIN...............................................................................39 2.3.1. Planificacin servicio por orden de llegada ...............................................................41 2.3.2. Planificacin Primero el trabajo ms breve ...............................................................42 2.3.3. Planificacin por prioridades..........................................................................................46
2 SISTEMAS OPERATIVOS
2.3.4. Planificacin circular...................................................................................................... 48 2.3.5. Planificacin de colas de mltiples niveles ..................................................................... 52 2.3.6. Planificacin de colas de mltiples niveles con realimentacin ..................................... 53 2.4. PLANIFICACIN DE PROCESADORES MLTIPLES................................................... 55 RESUMEN ............................................................................................................................................ 56 INDICADORES DE LOGRO ..................................................................................................................... 56 BIBLIOGRAFA RECOMENDADA ........................................................................................................... 56 NEXO................................................................................................................................................... 57 ACTIVIDAD .......................................................................................................................................... 57 AUTO EVALUACIN 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. Suspensin y reanudacin ............................................................................................... 65 3.1.7. El ncleo del sistema operativo ....................................................................................... 66 3.1.8. Resumen de funciones del ncleo. ................................................................................... 67 3.2. PROCESOS CONCURRENTES ASINCRNICOS. .......................................................... 68 3.2.1. Procesamiento en paralelo .............................................................................................. 68 3.2.2. Una estructura para indicar el paralelismo: cobegin/coend........................................... 69 3.2.3. Exclusin mutua .............................................................................................................. 70 3.2.4. Secciones crticas ............................................................................................................ 72 3.2.5. Primitivas de exclusin mutua......................................................................................... 73 3.2.6. Implementacin de las primitivas de exclusion mutua .................................................... 74 3.2.7. Algoritmos de exclusin mutua: desarrollo intuitivo....................................................... 75 3.2.8. Algoritmo de Dekker........................................................................................................ 80 RESUMEN ............................................................................................................................................ 85 INDICADORES DE LOGRO ..................................................................................................................... 85 BIBLIOGRAFA RECOMENDADA ........................................................................................................... 85 NEXO................................................................................................................................................... 85 ACTIVIDAD .......................................................................................................................................... 85 AUTO EVALUACIN 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. SEMFOROS ...................................................................................................................... 93 4.2.1. Sincronizacin de procesos con semforos ..................................................................... 94 4.2.2. Bloqueos mutuos y bloqueos indefinidos ......................................................................... 96 4.2.3. La relacin productor - consumidor................................................................................ 98 4.2.4. Semforos contadores.................................................................................................... 101 4.3. PROGRAMACIN CONCURRENTE ............................................................................. 101 4.4. PROBLEMAS CLSICOS. ............................................................................................... 102 4.4.1. El problema de los filsofos comelones......................................................................... 102 4.4.2. El barbero dormiln ...................................................................................................... 106 RESUMEN .......................................................................................................................................... 109 INDICADORES DE LOGRO ................................................................................................................... 110 BIBLIOGRAFA RECOMENDADA ......................................................................................................... 110
Mg. Abraham Gamarra Moreno 3
NEXO .................................................................................................................................................110 ACTIVIDAD ........................................................................................................................................110 AUTO EVALUACIN FORMATIVA........................................................................................................110 UNIDAD ACADEMICA 5 ..................................................................................................................113 ADMINISTRACIN DE LA MEMORIA: ALMACENAMIENTO REAL..................................113 5.1. INTRODUCCIN AL ALMACENAMIENTO REAL......................................................113 5.2. JERARQUA DE ALMACENAMIENTO .........................................................................114 5.3. ESTRATEGIAS DE ADMINISTRACIN DEL ALMACENAMIENTO.........................115 5.4. ASIGNACIN CONTIGUA DE ALMACENAMIENTO VERSUS NO CONTIGUA.....116 5.5. ASIGNACIN CONTIGUA DE ALMACENAMIENTO DE UN SOLO USUARIO.......116 5.6. MULTIPROGRAMACIN DE PARTICIN FIJA ..........................................................117 5.6.1. Multiprogramacin de Particin Fija: Traduccin y Carga Absolutas ........................117 5.6.2. Multiprogramacin de Particin Fija: Traduccin y Carga Relocalizables.................118 5.6.3. Proteccin en los Sistemas de Multiprogramacin .......................................................119 5.6.4. Fragmentacin en la Multiprogramacin de Particin Fija .........................................120 5.7. MULTIPROGRAMACIN DE PARTICIN VARIABLE ..............................................121 5.7.1. Combinacin de agujeros (reas libres)........................................................................122 5.7.2. Compresin o Compactacin de Almacenamiento ........................................................122 5.7.3. Estrategias de Colocacin del Almacenamiento............................................................123 RESUMEN ..........................................................................................................................................127 INDICADORES DE LOGRO ....................................................................................................................127 BIBLIOGRAFA RECOMENDADA .........................................................................................................127 NEXO .................................................................................................................................................128 ACTIVIDAD ........................................................................................................................................128 AUTO EVALUACIN FORMATIVA........................................................................................................128 UNIDAD ACADEMICA 6 ..................................................................................................................131 ADMINISTRACIN DE LA MEMORIA: ALMACENAMIENTO VIRTUAL...........................131 6.1. INTRODUCCIN A LA ORGANIZACIN DEL ALMACENAMIENTO VIRTUAL ...131 6.2. CONCEPTOS BSICOS DE ALMACENAMIENTO VIRTUAL ....................................132 6.3. ORGANIZACIN DEL ALMACENAMIENTO DE NIVELES MLTIPLES ................134 6.4. TRANSFORMACIN DE BLOQUES ..............................................................................134 6.5. CONCEPTOS BSICOS DE PAGINACIN....................................................................137 6.5.1. Traduccin de Direcciones de Paginacin por Transformacin Directa......................138 6.5.2. Traduccin de Direcciones de Paginacin por Transformacin Asociativa .................141 6.5.3. Traduccin de Direcciones de Paginacin por Combinacin de Transformacin Asociativa / Directa .....................................................................................................................142 6.5.4. Compartimiento de Recursos en un Sistema de Paginacin..........................................144 6.6. SEGMENTACIN.............................................................................................................145 6.6.1. Control de Acceso en Sistemas de Segmentacin ..........................................................148 6.6.2. Traduccin de Direcciones de Segmentacin por Transformacin Directa..................149 6.6.3. Compartimiento en un Sistema de Segmentacin ..........................................................151 6.7. SISTEMAS DE PAGINACIN / SEGMENTACIN .......................................................151 6.7.1. Traduccin Dinmica de Direcciones en Sistemas de Paginacin / Segmentacin ......152 6.7.2. Compartimiento en un Sistema de Paginacin/Segmentacin.......................................154 6.8. ADMINISTRACION DEL ALMACENAMIENTO VIRTUAL ........................................156 6.8.1. Estrategias de Administracin del Almacenamiento Virtual .........................................156 6.8.2. Estrategias de Reposicin (reemplazo) de Pgina ........................................................157 RESUMEN ..........................................................................................................................................163 INDICADORES DE LOGRO ....................................................................................................................164 BIBLIOGRAFA RECOMENDADA .........................................................................................................164 NEXO .................................................................................................................................................164 ACTIVIDAD ........................................................................................................................................164
4 SISTEMAS OPERATIVOS
AUTO EVALUACIN FORMATIVA ....................................................................................................... 164 UNIDAD ACADEMICA 7.................................................................................................................. 167 SISTEMA DE ARCHIVOS - PARTE 1 ............................................................................................ 167 7.1. INTRODUCCIN.............................................................................................................. 167 7.2. FUNCIONES DEL SISTEMA DE ARCHIVOS ................................................................ 168 7.3. EL SISTEMA DE ARCHIVOS .......................................................................................... 169 7.4. ARCHIVOS ....................................................................................................................... 170 7.4.1. Nombre de los Archivos................................................................................................. 170 7.4.2. Estructura de un Archivo............................................................................................... 170 7.4.3. Tipos de Archivos .......................................................................................................... 172 7.4.4. Acceso a un Archivo ...................................................................................................... 172 7.4.5. Atributos de Archivo...................................................................................................... 173 7.4.6. Operaciones con Archivos............................................................................................. 174 7.4.7. Archivos Mapeados a Memoria..................................................................................... 175 7.5. DIRECTORIOS ................................................................................................................. 175 7.5.1. Sistemas Jerrquicos de Directorios ............................................................................. 176 7.5.2. Nombre de las Rutas de Acceso..................................................................................... 178 7.5.3. Operaciones con Directorios......................................................................................... 179 7.6. IMPLANTACIN DEL SISTEMA DE ARCHIVOS Y SUS RELACIONES CON LA ASIGNACIN Y LIBERACIN DE ESPACIO ............................................................................. 180 7.6.1. Implantacin de Archivos.............................................................................................. 180 7.7. IMPLANTACIN DE DIRECTORIOS ............................................................................ 187 7.7.1. Directorios en MS-DOS................................................................................................. 188 RESUMEN .......................................................................................................................................... 189 INDICADORES DE LOGRO ................................................................................................................... 189 BIBLIOGRAFA RECOMENDADA ......................................................................................................... 189 NEXO................................................................................................................................................. 189 ACTIVIDAD ........................................................................................................................................ 190 AUTO EVALUACIN FORMATIVA ....................................................................................................... 190 UNIDAD ACADEMICA 8.................................................................................................................. 191 SISTEMA DE ARCHIVOS - PARTE 2 ............................................................................................ 191 8.1. ARCHIVOS COMPARTIDOS .......................................................................................... 191 8.2. ADMINISTRACIN DEL ESPACIO EN DISCO ............................................................ 194 8.2.1. Tamao del bloque: ....................................................................................................... 194 8.2.2. Registro de los bloques libres: ...................................................................................... 195 8.2.3. Disk quotas .................................................................................................................... 196 8.3. CONFIABILIDAD DEL SISTEMA DE ARCHIVOS ....................................................... 197 8.3.1. Manejo de un bloque defectuoso: .................................................................................. 197 8.3.2. Respaldos (copias de seguridad o de backup):............................................................. 198 8.3.3. Consistencia del sistema de archivos: ........................................................................... 199 8.4. DESEMPEO DEL SISTEMA DE ARCHIVOS .............................................................. 202 8.5. SEGURIDAD..................................................................................................................... 205 8.5.1. El Ambiente de Seguridad ............................................................................................. 205 8.5.2. Virus .............................................................................................................................. 207 8.5.3. Principios del Diseo Para la Seguridad ...................................................................... 207 8.6. MECANISMOS DE PROTECCIN ................................................................................. 208 8.6.1. Dominios de Proteccin ................................................................................................ 208 8.6.2. Listas Para Control de Acceso ...................................................................................... 210 RESUMEN .......................................................................................................................................... 211 INDICADORES DE LOGRO ................................................................................................................... 211 BIBLIOGRAFA RECOMENDADA ......................................................................................................... 211 ACTIVIDAD ........................................................................................................................................ 211 AUTO EVALUACIN FORMATIVA ....................................................................................................... 211
Mg. Abraham Gamarra Moreno 5
SISTEMAS OPERATIVOS
PRESENTACION
Todos los computadores ejecutan sus programas sobre un Sistema Operativo, este sistema explota los recursos del hardware, de uno o ms procesadores, ofrece un conjunto de servicios a los usuarios del sistema, gestiona la memoria secundaria y los dispositivos de E/S. Existen dos puntos de vista para conocer el funcionamiento de los Sistemas Operativos; el primero muestra al sistema operativo como una mquina virtual, donde el usuario utiliza el Sistema Operativo para administrar todos los recursos que existen en el sistema de cmputo. El segundo punto de vista es conocer a los Sistemas Operativos a travs del analisis de sus algoritmos de implementacin, el cul nos permite realizar y modificar la implementacin de los Sistemas Operativos, sobre todo los de cdigo liberado. Este libro que se pone a disposicin de los estudiantes sigue el segundo punto de vista, donde se realiza un anlisis de cmo se implementan los Sistemas Operativos en la administracin de procesos, administracin de la memoria y la administracin de los sistemas de archivos.
El autor.
SISTEMAS OPERATIVOS
UNIDAD ACADEMICA 1
INTRODUCCION A LOS SISTEMAS OPERATIVOS
1.1. QU ES UN SISTEMA OPERATIVO?
Una de las definiciones ms comnmente aceptadas expresa: Un Sistema Operativo (S. O.) es un grupo de programas de proceso con las rutinas de control necesarias para mantener continuamente operativos dichos programas. El objetivo primario de un Sistema Operativo es optimizar todos los recursos del sistema para soportar los requerimientos. A los efectos de situar a los S. O. en el conjunto del software para computadoras, podemos clasificar a este de la siguiente manera: Programas de sistema: Controlan la operacin de la computadora en s. Programas de aplicacin: Resuelven problemas para los usuarios.
En este contexto, el Sistema Operativo es el programa fundamental de todos los programas de sistema. El S. O. protege y libera a los programadores de la complejidad del hardware, colocndose un nivel de software por sobre el hardware para: Controlar todas las partes del sistema.
9
El esquema tpico de un sistema de cmputos incluye: Programas de aplicacin: Sistema bancario, reservaciones en una lnea area, juegos, etc. Programas de sistema: Compiladores, editores, intrpretes de comandos y el Sistema Operativo. Hardware: Lenguaje de mquina, microprogramacin y los dispositivos fsicos.
Las principales caractersticas del microprograma son: Se trata de software que generalmente se localiza en la memoria de solo lectura. Busca las instrucciones de lenguaje de mquina para ejecutarlas como una serie de pequeos pasos. El conjunto de instrucciones que interpreta define al lenguaje de mquina. En ciertas mquinas se implanta en el hardware y no es en realidad una capa distinta.
Respecto del lenguaje de mquina es preciso sealar que: Generalmente posee entre 50 y 300 instrucciones, sirviendo la mayora para desplazar datos, hacer operaciones aritmticas y comparar valores. Los dispositivos de e / s (entrada / salida) se controlan al cargar valores en registros del dispositivo especiales.
Una de las principales funciones del S. O. es ocultar toda esta complejidad y brindar al programador un conjunto ms conveniente de instrucciones para trabajar. El S. O. se ejecuta en modo central o modo de supervisin, con mxima prioridad y generalmente con proteccin por hardware. Los compiladores, editores y dems programas se ejecutan en modo usuario. El S. O. es la serie de programas, dispuestos ya sea en el software o en la memoria fija (microcdigo), que hacen al hardware utilizable.
10
SISTEMAS OPERATIVOS
Segn Deitel1 los S. O. ponen el poder computacional bsico del hardware convenientemente a disposicin del usuario, pero consumen parte de ese poder computacional para funcionar. Los S. O. son, en primer lugar, administradores de recursos, siendo el recurso primario el hardware del sistema (ver Figura 1.1).
Las principales caractersticas de los S. O. son: Definir la Interfaz del Usuario. Compartir el hardware entre usuarios. Permitir a los usuarios compartir los datos entre ellos. Planificar recursos entre usuarios. Facilitar la entrada / salida.
Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Mg. Abraham Gamarra Moreno
1
11
Los principales recursos administrados por los S. O. son: Procesadores. Almacenamiento. Dispositivos de e / s. Datos.
Los S. O. son una interfaz con: Operadores. Programadores de aplicaciones. Programadores de sistemas (administradores del S. O.). Programas. Hardware. Usuarios.
El S. O. debe presentar al usuario el equivalente de una mquina extendida o mquina virtual que sea ms fcil de programar que el hardware subyacente.
LOS
SISTEMAS
OPERATIVOS:
Los S. O. han estado relacionados histricamente con la arquitectura de las computadoras en las cuales se ejecutan, razn por la cual su historia puede analizarse segn las generaciones y sus principales caractersticas1.
12
SISTEMAS OPERATIVOS
(1945-1955):
BULBOS
En los aos cincuenta comienzan como transicin entre trabajos, haciendo la misma ms simple.
1.2.3. SEGUNDA GENERACIN (1955-1965): TRANSISTORES Y SISTEMAS DE PROCESAMIENTO POR LOTES (BATCH)
En los aos sesenta aparecen los S. O. para sistemas compartidos con: o Multiprogramacin: varios programas de usuarios se encuentran al mismo tiempo en el almacenamiento principal, cambiando el procesador rpidamente de un trabajo a otro. o Multiprocesamiento: varios procesadores se utilizan en un mismo sistema para incrementar el poder de procesamiento. Posteriormente aparece la independencia de dispositivo: o El programa del usuario especifica las caractersticas de los dispositivos que requieren los archivos. o El S. O. asigna los dispositivos correspondientes segn los requerimientos y las disponibilidades.
o Almacenamiento de trabajos de entrada y de salida en dispositivos transitorios rpidos (discos), para disminuir el impacto de los perifricos ms lentos. Son sistemas de modos mltiples, es decir que deben soportar sistemas de propsitos generales; son grandes y complejos pero muy poderosos. Interponen una capa de software entre el usuario y el hardware. Aparecen los lenguajes de control de trabajos, necesarios para especificar el trabajo y los recursos requeridos. Soportan timesharing (tiempo compartido), variante de la multiprogramacin con usuarios conectados mediante terminales en lnea, permitiendo la operacin en modo interactivo o conversacional. Aparecen los sistemas de tiempo real, que requieren tiempos de respuesta muy exigentes, especialmente para usos industriales o militares. Se difunden las computadoras de rango medio.
14
SISTEMAS OPERATIVOS
o Los usuarios no son conscientes del lugar donde se ejecutan sus programas o donde se encuentran sus archivos, ya que lo debe administrar el S. O. automticamente. o Deben permitir que un programa se ejecute mediante varios procesadores a la vez, maximizando el paralelismo. Aparicin de emuladores de terminal para el acceso a equipos remotos desde computadoras personales (PC). Gran nfasis en la seguridad, en especial por el desarrollo de los sistemas de comunicaciones de datos. El S. O. crea un ambiente de trabajo segn el concepto de mquina virtual, que lo asla del funcionamiento interno de la mquina. Proliferacin de sistemas de bases de datos, accesibles mediante redes de comunicacin.
1.3.1. PROCESOS
Es el concepto central de todos los S. O. Es bsicamente un programa en ejecucin. Consta del programa ejecutable, sus datos y pila, contador y otros registros, adems de la informacin necesaria para ejecutar el programa. La informacin de control relacionada con los procesos se almacena en la tabla de procesos: o Es administrada por el S. O. o Posee un arreglo de estructuras, una por cada proceso existente en ese momento.
2
Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003. Mg. Abraham Gamarra Moreno
15
o Un espacio de direccin. o Los datos pertinentes de la tabla de procesos. Un proceso puede crear procesos hijo y estos nuevos procesos hijo, conformando un rbol de procesos.
1.3.2. ARCHIVOS:
Una de las funciones principales del S. O. es brindar independencia de dispositivo. Muchos S. O. soportan el concepto de directorio como una forma de agrupar archivos. Los directorios se estructuran jerrquicamente, por lo que a cada archivo le corresponde una ruta de acceso. Existen distintos esquemas de seguridad de archivos en los distintos S. O.
Cada procedimiento tiene una interfaz bien definida en trminos de parmetros y resultados.
Para ejecutar los servicios del S. O. (llamadas al sistema)2: (ver Figura 1.3). o Se solicitan colocando los parmetros en lugares bien definidos (registros o pilas).
17
o Se ejecuta una instruccin especial de trampa: llamada al ncleo o llamada al supervisor. o La instruccin cambia la mquina del modo usuario al modo ncleo (o modo supervisor)2. o Se transfiere el control al S. O. o El S. O. examina los parmetros de la llamada para determinar cul de ellas se desea realizar. o El S. O. 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. o La llamada al sistema termina y el control regresa al programa del usuario.
El primer sistema con este esquema fue el THE (Holanda - Dijkstra -1968)2: (ver Tabla 1.1). THE: Technische Hogeschool Eindhoven. Capa 0: o Trabaja con la asignacin del procesador. o Alterna entre los procesos cuando ocurren las interrupciones o expiran los cronmetros. Proporciona la multiprogramacin bsica.
Capa 1: o Administra la memoria. o Asegura que las pginas (porciones de memoria) requeridas de los procesos lleguen a memoria cuando fueran necesarias.
18
SISTEMAS OPERATIVOS
5 - Operador 4 - Programas del Usuario 3 - Control de Entrada - Salida 2 - Comunicaciones Operador - Proceso 1 - Administracin de la Memoria y del Disco 0 - Asignacin del Procesador y Multiprogramacin Capa 2: o Administra la comunicacin entre cada proceso y la consola del operador. o Por sobre esta capa, cada proceso tiene su propia consola de operador. Capa 3: o Controla los dispositivos de e / s y almacena en buffers los flujos de informacin entre ellos. o Por sobre la capa 3 cada proceso puede trabajar con dispositivos abstractos de e / s en vez de con dispositivos reales. Capa 4: o Aloja los programas del usuario. o Los programas. del usuario no tienen que preocuparse por el proceso, memoria, consola o control de e / s. Capa 5: o Localiza el proceso operador del sistema. Una generalizacin mas avanzada del concepto de capas se presento con Multics (MIT, Bell Labs y General Electric): Multics: multiplexed information and computing service.
19
Presenta una estructura en anillos concntricos, siendo los interiores los privilegiados. Un procedimiento de un anillo exterior, para llamar a un procedimiento de un anillo interior, debe hacer el equivalente a una llamada al sistema.
Las mquinas virtuales instrumentan copias exactas del hardware simple, con su modo ncleo / usuario, e / s, interrupciones y todo lo dems que posee una mquina real. Pueden ejecutar cualquier S. O. que se ejecute en forma directa sobre el hardware. Las distintas mquinas virtuales pueden ejecutar distintos S. O. y en general as lo hacen. Soportan perifricos virtuales. Un ejemplo de S. O. representativo de esta estructura (VM/370 de IBM2), se muestra en la Figura 1.4.
20
SISTEMAS OPERATIVOS
Las VM generalmente utilizaran, entre otros, el S. O. CMS: Conversational Monitor System. Cuando un programa CMS ejecuta una llamada al sistema: La llamada es atrapada por el S. O. en su propia mquina virtual; no pasa directamente al VM/370. CMS proporciona las instrucciones de e / s en hardware para la lectura del disco virtual o lo necesario para efectuar la llamada. VM/370 atrapa estas instrucciones de e / s y las ejecuta sobre el hardware verdadero.
Se fracciona el S. O. en partes, cada una controlando una faceta: servicio a archivos, a procesos, a terminales, a memoria, etc., cada parte pequea y ms fcilmente controlable. Los servidores se ejecutan como procesos en modo usuario: No tienen acceso directo al hardware. Se aslan y acotan ms fcilmente los problemas.
21
Si un cliente se comunica con un servidor mediante mensajes: No necesita saber si el mensaje se atiende localmente o mediante un servidor remoto, situado en otra mquina conectada. Enva una solicitud y obtiene una respuesta.
Algunas funciones del S. O., por ejemplo el cargado de comandos en los registros fsicos del dispositivo de e / s, presentan problemas especiales y distintas soluciones: Ejecucin en modo ncleo, con acceso total al hardware y comunicacin con los dems procesos mediante el mecanismo normal de mensajes. Construccin de un mnimo de mecanismos dentro del ncleo manteniendo las decisiones de poltica relativas a los usuarios dentro del espacio del usuario.
Otras mejoras posteriores al UNIX han separado el kernel en ms mdulos, por ejemplo en el sistema operativo AIX de IBM se lo dividi en dos partes. El MACH de Carnegie-Mellon redujo el kernel a un conjunto pequeo de funciones bsicas trasladando todo lo no esencial a los niveles del sistema o incluso al del usuario.
24
SISTEMAS OPERATIVOS
Drivers. Executive: Sobre el cual son implementados todos los servicios de alto nivel.
Figura 1.10. La arquitectura de Windows NT. El modo ncleo de la lnea de Windows NT est compuesto por subsistemas capaces de pasar peticiones de E/S a los drivers apropiados usando el gestor de E/S. Dos subsistemas crean la capa del modo usuario de Windows 2000: el subsistema de Entorno (ejecuta aplicaciones escritas para distintos tipos de sistemas operativos), y el subsistema Integral (maneja funciones especficas de sistema de parte del subsistema de Entorno). El modo ncleo en Windows 2000 tiene acceso total al hardware y a los recursos del sistema del ordenador. El modo ncleo
26 SISTEMAS OPERATIVOS
impide a los servicios del modo usuario y las aplicaciones acceder a reas crticas del sistema operativo a las que no deberan tener acceso. El Executive se relaciona con todos los subsistemas del modo usuario. Se ocupa de la entrada/salida, la gestin de objetos, la seguridad y la gestin de procesos. El ncleo se sita entre la Capa de Abstraccin de Hardware y el Executive para proporcionar sincronizacin multiprocesador, hilos y programacin y envo de interrupciones, y envo de excepciones. El ncleo tambin es responsable de la inicializacin de los drivers de dispositivos al arrancar. Hay tres niveles de drivers en el modo ncleo: drivers de alto nivel, drivers intermedios y drivers de bajo nivel. El Modelo de Drivers de Windows (en ingls Windows Driver Model, WDM) se encuentra en la capa intermedia y fue diseado principalmente para mantener la compatibilidad en binario y en cdigo fuente entre Windows 98 y Windows 2000. Los drivers de ms bajo nivel tambin son un legado de los drivers de dispositivos de Windows NT que controlan directamente un dispositivo o puede ser un bus hardware PnP.
Resumen
Un Sistema Operativo (S. O.) es un grupo de programas de proceso con las rutinas de control necesarias para mantener continuamente operativos dichos programas. El objetivo primario de un Sistema Operativo es optimizar todos los recursos del sistema para soportar los requerimientos.
Indicadores de logro
El lector explica los fundamentos de los Sistemas Operativos.
Bibliografa Recomendada
Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
27
Nexo
La siguiente unidad acadmica analiza la planificacin de procesos.
Actividad
Amplie la informacin sobre la arquitectura de Windows NT. Investigue sobre la arquitectura o estructura del sistema operativo LINUX.
28
SISTEMAS OPERATIVOS
UNIDAD ACADEMICA 2
PLANIFICACION DE PROCESOS3
Un proceso es un programa que se est ejecutando y hoy en da los sistemas operativos tienen varios procesos en ejecucin; por lo que se requiere realizar la planificacin de la ejcucin de estos procesos.
Silberschatz A, Peterson J, Galvin P. Sistemas Operativos. USA: Editorial Addison Wesley Iberoamericana, 3ra Edicin; 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 despus el P1 uno tras otro, costara 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 slo se efectan clculos durante dos minutos, mientras que los otros dos representan tiempo inactivo. As, nuestra utilizacin de la UCP es slo del 50%.
Figura 2.1. Dos procesos, P0 y P1, listos para su ejecucin. 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 ejecucin. Ahora el tiempo transcurrido para la ejecucin de ambos procesos es slo dos minutos, y no hay tiempo inactivo de la UCP de manera que hemos mejorado su utilizacin del 50 al 100%, incrementando tambin la productividad. Observe que el proceso P0 no termina antes, pero ahora el proceso P1 finaliza en dos minutos.
30
SISTEMAS OPERATIVOS
Este ejemplo es un caso extremo y es poco probable que ocurra en la prctica, pero ilustra el concepto de la multiprogramacin.
Figura 2.4). Si se trata de un dispositivo dedicado, como una unidad de cinta, la cola del dispositivo nunca tendr ms 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 representacin comn para analizar la planificacin de procesos es el diagrama de colas, como se muestra en la Figura 2.5. Cada rectngulo representa una cola, y hay dos tipos de colas: la cola de procesos listos y un conjunto de colas de dispositivo. Los crculos 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
Un proceso nuevo se coloca inicialmente en la cola de procesos listos y all espera hasta que se selecciona para su ejecucin 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 podra ser extrado de la UCP por la fuerza, como resultado de una interrupcin, 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 contina con este ciclo hasta que termina, y es entonces cuando sale del sistema.
32 SISTEMAS OPERATIVOS
2.1.2. PLANIFICADORES
En el transcurso de su vida, un proceso transita entre las distintas colas de planificacin, y el sistema operativo de alguna manera debe seleccionar procesos de estas colas. Esta actividad de seleccin es realizada por el planificador correspondiente. En un sistema por lotes, con frecuencia se presentan ms procesos que los que se pueden ejecutar de inmediato; estos procesos se envan a un spooler en un dispositivo de almacenamiento masivo (un disco, normalmente), donde se conservan para su posterior ejecucin. El planificador a largo plazo (o planificador de trabajos) selecciona procesos de este depsito y los carga en memoria para su ejecucin. El planificador a corto plazo (o planificador de la UCP) selecciona uno de los procesos listos para ejecucin y le asigna la UCP. La principal diferencia entre estos dos planificadores es la frecuencia de su ejecucin. El planificador a corto plazo debe seleccionar con mucha frecuencia un nuevo proceso para la UCP, y el proceso quiz se ejecute nica mente durante unos milisegundos antes de esperar una solicitud de E/S; en muchos casos, este planificador de la UCP se ejecuta por lo menos una vez cada 10 milisegundos. Debido al breve lapso de tiempo entre ejecuciones, el planificador de la UCP debe ser muy rpido. Si cuesta un milisegundo decidir la ejecucin de un proceso de 10 milisegundos, entonces 1/(10 + 1) = 9% de la UCP se usa (se desperdicia) simplemente para que la planificacin funcione. Por otra parte, el planificador a largo plazo se ejecuta con una frecuencia mucho menor. Pueden transcurrir minutos entre la creacin de nuevos procesos
Mg. Abraham Gamarra Moreno 33
en el sistema. El planificador a largo plazo controla el grado de multiprogramacin (el nmero de procesos en memoria); si el grado de multiprogramacin es estable, entonces la tasa promedio de creacin de procesos debe ser igual a la tasa promedio de salida para los procesos que dejan el sistema, de modo que slo hay que invocar al planificador a largo plazo cuando un proceso sale del sistema. Debido al mayor intervalo de tiempo entre ejecuciones, el planificador a largo plazo puede emplear ms tiempo para decidir qu proceso se debe seleccionar para su ejecucin. Tambin puede ser ms importante que el planificador a largo plazo efecte una seleccin cuidadosa. Por lo general, la mayora de los procesos pueden describirse como limitados por la UCP o limitados por E/S. Un proceso limitado por E/S es aquel que emplea ms tiempo en realizar E/S que en efectuar clculos. Por otra parte, un proceso limitado por la UCP es el que genera solicitudes de E/S con poca frecuencia, invirtiendo la mayor parte de su tiempo en efectuar clculos que los procesos limitados por E/S. Es importante que el planificador a largo plazo seleccione una buena mezcla de procesos limitados por la UCP y limitados por E/S. Si todos los procesos estn limitados por E/S, la cola de procesos listos estar casi vaca y el planificador a corto plazo tendr poco que hacer. Si todos los procesos estn limitados por la UCP, la cola de espera de E/S casi siempre permanecer vaca, y una vez ms se desequilibrar el sistema. El sistema con el mejor rendimiento tendr una combinacin 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 funcin sea mnima. Por ejemplo, los sistemas de tiempo compartido muchas veces no cuentan con un planificador a largo plazo, y colocan cada nuevo proceso en la memoria para que lo manipule el planificador a corto plazo. La estabilidad de estos sistemas depende de una limitacin fsica (como el nmero de terminales disponibles) o de que las caractersticas de los usuarios se ajusten automticamente. Si el rendimiento baja hasta niveles inaceptables, algunos usuarios abandonarn y se dedicarn a otra cosa. Algunos sistemas operativos, como los de tiempo compartido, pueden presentar un nivel intermedio adicional de planificacin. El diagrama de este planificador a mediano plazo se presenta en la Figura 2.6. 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 multiprogramacin. Ms tarde el proceso se volver a introducir en la memoria y continuar su ejecucin a partir del punto donde se qued. A este esquema comnmente se le denomina intercambio (swapping). El planificador a mediano plazo intercambia el proceso, sacndolo y volvindolo a introducir ms tarde. Los intercambios pueden ser necesarios para mejorar la mezcla de procesos, o porque un cambio en los requisitos de memoria ha comprometido en exceso la memoria disponible, lo que requiere que se libere la memoria. Los intercambios se analizan con mayor detalle en el captulo de Administracin de memoria.
34 SISTEMAS OPERATIVOS
35
36
SISTEMAS OPERATIVOS
37
1. Cuando un proceso cambia del estado de ejecucin a estado de espera (por ejemplo, solicitud de E/S, peticin de esperar la terminacin de uno de los procesos hijo). 2. Cuando un proceso cambia del estado de ejecucin al estado listo (por ejemplo, cuando ocurre una interrupcin). 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 opcin en trminos de planificacin: se debe seleccionar un nuevo proceso para su ejecucin (si existe en la cola de procesos listos). Sin embargo, esto no se aplica a los casos 2 y 3. Cuando la planificacin tiene lugar nicamente en las situaciones 1 y 4, decimos que el esquema de planificacin es no apropiativo; de lo contrario decimos que es apropiativo. En la planificacin 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.
38
SISTEMAS OPERATIVOS
2.2.5. DESPACHADOR
Otro componente que participa en la funcin de planificacin de la UCP es el despachador. El despachador es el mdulo que realmente entrega el control de la UCP al proceso seleccionado por el planificador a corto plazo. Esta funcin implica: Cambiar de contexto Cambiar a modo usuario Saltar a la posicin adecuada del programa del usuario para reiniciar el programa Obviamente, el despachador debe ser lo ms rpido posible.
rridos esperando entrar en la memoria, esperando en la cola de procesos listos, ejecutndose en la UCP y efectuando la E/S. Tiempo de espera. El algoritmo para la planificacin de la UCP no afecta realmente a la cantidad de tiempo durante el cual un proceso se ejecuta o lleva a cabo E/S. El algoritmo afecta nicamente a la cantidad de tiempo que el proceso espera en la cola de procesos listos, de modo que en vez de tener en cuenta el tiempo de retorno, podemos considerar slo el tiempo de espera para cada proceso. Tiempo de respuesta. En un sistema interactivo, es posible que el tiempo de retorno no sea el mejor criterio. 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. Por esto, otra medicin es el tiempo transcurrido desde la presentacin de una solicitud hasta que se produce la primera respuesta. Esta medicin, llamada tiempo de respuesta, es la cantidad de tiempo para comenzar a responder, pero no el tiempo necesario para mostrar esa respuesta. El tiempo de retorno generalmente se encuentra limitado por la velocidad del dispositivo de salida.
Es deseable maximizar la utilizacin de la UCP y la productividad, y minimizar los tiempos de retorno, de espera y de respuesta; en la mayora de los casos optimizamos el promedio, pero en ocasiones puede ser deseable optimizar los valores mnimos o mximos, en vez del promedio. Por ejemplo, para garantizar que todos los usuarios obtengan un buen servicio podramos minimizar el mximo tiempo de respuesta. Tambin se ha propuesto que, para sistemas interactivos (como los sistemas de tiempo compartido), es ms importante minimizar la varianza en el tiempo de respuesta que minimizar su promedio. Un sistema con tiempo de respuesta razonable y predecible puede considerarse ms deseable que un sistema que en promedio sea ms rpido, pero muy variable. Sin embargo, es poco lo que se ha hecho respecto a los algoritmos para la planificacin de la UCP que minimicen la varianza. A medida que analicemos los distintos algoritmos para la planificacin de la UCP, ilustraremos su funcionamiento. Una ilustracin precisa podra incluir muchos procesos, y cada uno de ellos una secuencia de centenares de rfagas de UCP y de E/S. Para simplificar las ilustraciones, en nuestros ejemplos consideramos slo una rfaga de UCP (en milisegundos). Nuestra medida de comparacin es el tiempo promedio de espera.
40
SISTEMAS OPERATIVOS
Si los procesos llegan en el orden P1, P2 y P3 y se les da servicio por orden de llegada, obtenemos el resultado que se presenta en la siguiente grfica de Gantt:
El tiempo de espera es 0 milisegundos para el proceso P1, 24 milisegundos para el proceso P2 y 27 milisegundos para el proceso P3, de manera que el tiempo promedio de espera es (0 + 24 + 27)/3 = 17 milisegundos. Sin embargo, si los procesos llegan en el orden P2, P3 y P1, los resultados sern los que se muestran en la siguiente grfica de Gantt:
41
El tiempo promedio de espera es ahora (6 + 0 + 3)/3 = 3 milisegundos, lo que representa una reduccin considerable. Por esto, el tiempo promedio de espera en la poltica FCFS generalmente no es mnimo y puede variar bastante si los tiempos de rfagas de UCP de los procesos varan mucho. Adems, considere el rendimiento de la planificacin FCFS en una situacin dinmica. Suponga que tenemos un proceso limitado por la UCP y varios procesos limitados por E/S. Al pasar los procesos por el sistema, se puede presentar la siguiente situacin: el proceso limitado por la UCP obtendr la UCP y la retendr; durante este tiempo, todos los dems procesos terminarn su E/S y pasarn a la cola de procesos listos, en espera de la UCP. Mientras esperan en la cola de procesos listos, los dispositivos de E/S permanecen inactivos. Finalmente, el proceso limitado por la UCP termina su rfaga de UCP y pasa a un dispositivo de E/S. Todos los procesos limitados por E/S, que tienen rfagas de UCP breves, se ejecutan rpidamente y regresan a las colas de dispositivos de E/S. En este momento la UCP est inactiva. El proceso limitado por la UCP regresar a la cola de procesos listos y se le asignar la UCP. Una vez ms, los procesos limitados por E/S se encuentran en la cola de procesos listos esperando a que termine el proceso limitado por la UCP. Esto se conoce como efecto de convoy, ya que todos los dems procesos esperan a que un proceso de gran tamao salga de la UCP. Este efecto provoca que la UCP y los dispositivos se aprovechen menos que si se permitiera que los procesos ms cortos pasaran antes. El algoritmo de planificacin FCFS es no apropiativo. Una vez que se ha asignado la UCP a un proceso, ste la conserva hasta que desee liberarla, ya sea por terminacin o por solicitud de E/S. El algoritmo FCFS es especialmente problemtico en los sistemas de tiempo compartido, donde es importante que cada usuario reciba una porcin de la UCP a intervalos regulares. Sera desastroso permitir que un proceso retuviera la UCP por un periodo largo.
Usando la planificacin SJF, planificaramos estos procesos de acuerdo con la siguiente grfica de Gantt:
El tiempo de espera es tres milisegundos para el proceso P1, 16 milisegundos para el proceso P2 nueve milisegundos para P3 y 0 para P4. De esta manera, el tiempo promedio de espera es (3 + 16 + 9 + 0)/4 = 7 milisegundos. Si usramos la planificacin FCFS, el tiempo promedio de espera sera de 10.25 milisegundos.
Puede comprobarse que el algoritmo SJF es ptimo, ya que ofrece el mnimo tiempo promedio de espera para un conjunto de procesos dado. La comprobacin muestra que poniendo un proceso breve antes de uno largo se reduce el tiempo de espera del proceso corto ms de lo que aumenta el tiempo de espera del proceso largo (
Figura 2.9). Por tanto, se reduce el tiempo de espera promedio. El problema real con el algoritmo SJF es conocer la longitud de la siguiente solicitud de la UCP. Para la planificacin a largo plazo de (trabajos) en un sistema por lotes, podemos utilizar el tiempo lmite del proceso. De esta manera se motiva a los usuarios a estimar con precisin el tiempo lmite del proceso, ya que un valor menor representa una respuesta ms rpida. (Un valor demasiado bajo ocasionar un error de tipo tiempo lmite excedido y se tendr que ofrecer de nuevo el proceso.) La planificacin SJF se usa frecuentemente en la planificacin de procesos.
43
Aunque el algoritmo SJF es ptimo, no puede implantarse al nivel de la planificacin a corto plazo de la UCP. No hay manera de conocer la longitud de la siguiente rfaga de UCP, pero se puede tratar de efectuar una aproximacin a la planificacin SJF. Aunque no conocemos la longitud de la siguiente rfaga de UCP, podemos predecir su valor, esperando que sea de longitud similar a las anteriores. As, al calcular una aproximacin de la longitud de la siguiente rfaga de UCP podemos elegir el proceso con la rfaga de UCP prevista ms breve. En general, la siguiente rfaga de UCP se predice como un promedio exponencial de las longitudes medidas de las rfagas de UCP anteriores. Sea tn la longitud de la ensima rfaga de UCP, y n+1 nuestro valor previsto para la siguiente rfaga de UCP. Entonces, para , 0<=<=1, se define:
n+1 = t n + (1 ) n
Esta frmula define un promedio exponencial. El valor de tn contiene nuestra informacin ms reciente, y n contiene nuestros datos histricos. El parmetro controla la ponderacin de la historia reciente y antigua para nuestra prediccin. Si =O, entonces n+1 = n, y la historia reciente no tiene efecto (se supone que las condiciones actuales son transitorias); si =1, entonces n+1 = tn y slo tiene importancia la rfaga de UCP ms reciente (se supone que los datos histricos son viejos e irrelevantes). Es ms habitual que = , por lo que la historia reciente y antigua se ponderan de igual manera. La Figura 2.10 muestra un promedio exponencial para = . El valor inicial de 0 puede definirse como una constante o como un promedio global del sistema. Para comprender el comportamiento del promedio exponencial, podemos desarrollar la frmula para n+1 sustituyndolo por n; para encontrar
44
SISTEMAS OPERATIVOS
n +1 = t n + (1 ) t n 1 + +
(1 ) j t n 1 + + (1 )n +1 0
Puesto que tanto como (1 - ) son menores o iguales a 1, cada trmino sucesivo tiene menor peso que su predecesor.
El algoritmo SJF puede ser apropiativo o no apropiativo. La alternativa se plantea cuando un nuevo proceso llega a la cola de procesos listos mientras se est ejecutando otro proceso. El nuevo proceso puede tener una rfaga de UCP menor que lo que resta del proceso que se ejecuta en ese momento. Un algoritmo SJF apropiativa desplazar al proceso que se ejecuta, mientras que un algoritmo SJF no apropiativo permitir que el proceso que se ejecuta termine su rfaga de UCP. La planificacin SJF apropiativa en ocasiones se denomina planificacin primero el que tenga el menor tiempo restante (shortest remaining-time-first).
45
Como ejemplo, considere los cuatro procesos siguientes, donde la longitud de las rfagas de UCP se proporciona en milisegundos: Proceso Instante de llegada Duracin de la rfaga 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 rfaga indicados, entonces la planificacin SJF apropiativa que resulta se muestra en la siguiente grfica de Gantt:
El proceso P1 comienza en el instante 0, ya que es el nico proceso en la cola. El proceso P2 llega en el instante 1. El tiempo restante para el proceso P1 (siete milisegundos) es mayor que el tiempo que requiere el proceso P2 (cuatro milisegundos), por lo que el proceso P1 se expulsa y el proceso P2 se planifica. El tiempo promedio de espera para este ejemplo es ((10 - 1) + (1 - 1) + (17 - 2) + (5 - 3))/4 = 26/4 = 6.5 milisegundos. El resultado de una planificacin SJF no apropiativa sera 8.75 milisegundos.
senso respecto a si 0 es la prioridad ms alta o la ms baja. Algunos sistemas emplean nmeros bajos para representar una prioridad baja; otros utilizan nmeros bajos para representar una prioridad alta. Esta diferencia puede prestarse a confusiones. En este libro supondremos que los nmeros bajos representan prioridades altas. Como ejemplo, considere el siguiente conjunto de procesos, que se supone llegaron en el instante 0, en el orden P1, P2,..., P5 y cuyas longitudes de rfaga de UCP se indican en milisegundos: Proceso Duracin de la rfaga Prioridad P1 P2 P3 P4 P5 10 1 2 1 5 3 1 3 4 2
Usando la planificacin por prioridades, planificaramos estos procesos de acuerdo con la siguiente grfica de Gantt:
El tiempo promedio de espera es de 6.2 milisegundos. Las prioridades pueden definirse interna o externamente. Las prioridades definidas internamente utilizan alguna cantidad o cantidades mensurables para calcular la prioridad del proceso. Por ejemplo, para calcular prioridades se han utilizado los lmites de tiempo, requisitos de memoria, el nmero de archivos abiertos y la tasa de intervalos entre rfagas de E/S y de UCP. Las prioridades externas se fijan empleando criterios ajenos al sistema operativo, como la importancia del proceso, el tipo y cantidad de fondos que se pagan por utilizar el computador, el departamento que patrocina el trabajo y otros factores, con frecuencia de carcter poltico. La planificacin por prioridades puede ser apropiativa o no apropiativa. Cuando un proceso llega a la cola de procesos listos, su prioridad se compara con la del proceso en ejecucin. Un algoritmo apropiativo para la planificacin por prioridades se apropiar de la UCP si la prioridad del proceso recin llegado
Mg. Abraham Gamarra Moreno 47
es mayor que la del proceso en ejecucin. Un algoritmo no apropiativo para la planificacin por prioridades nicamente dejar al nuevo proceso al inicio de la cola de procesos listos. Un serio problema de los algoritmos para la planificacin por prioridades es el bloqueo indefinido o inanicin. Un proceso que est listo para ejecutarse pero no obtiene la UCP puede considerarse como bloqueado, en espera de la UCP. Un algoritmo para la planificacin por prioridades puede dejar a un proceso de baja prioridad esperando indefinidamente a la UCP. En un sistema de computacin con gran carga, un flujo constante de procesos de alta prioridad puede evitar que un proceso de baja prioridad obtenga la UCP. Por lo general suceder una de estas dos cosas: o el programa finalmente se ejecuta (a las 2 AM del domingo, cuando por fin disminuye la carga del sistema) o el sistema de computacin falla y pierde todos los procesos de baja prioridad. (Segn algunos rumores, cuando dieron de baja el computador IBM del MIT en 1973, encontraron un proceso de baja prioridad que se haba enviado en 1967 y que todava no se haba ejecutado.) Una solucin para el problema del bloqueo indefinido de los procesos de baja prioridad es el envejecimiento, tcnica por la cual aumenta gradualmente la prioridad de los procesos que esperan durante mucho tiempo en el sistema. Por ejemplo, si las prioridades varan entre 0 (baja) y 127 (alta), podramos incrementar en uno la prioridad de un proceso en espera cada 15 minutos. Tarde o temprano, incluso un proceso con prioridad inicial 0 podra alcanzar la prioridad ms alta del sistema y ejecutarse. De hecho, no costara ms de 32 horas que un proceso pasara de prioridad 0 a prioridad 127.
en ejecucin es mayor que un cuanto de tiempo, el cronmetro se activar y provocar una interrupcin para el sistema operativo. Se ejecutar un cambio de contexto y el proceso se colocar al final de la cola de procesos listos. El planificador de la UCP seleccionar entonces el siguiente proceso de la cola. Sin embargo, el tiempo promedio de espera es bastante grande en la poltica RR. Considere el siguiente conjunto de procesos que llegan en el instante 0, donde la longitud de la rfaga de UCP se expresa en milisegundos: Proceso Duracin de rfaga P1 P2 P3 24 3 3
Si usamos un cuanto de tiempo de cuatro milisegundos, el proceso P1 obtiene los primeros cuatro milisegundos. Puesto que necesita otros 20 milisegundos, se expulsa tras el primer cuanto de tiempo y la UCP se otorga a P2 el siguiente proceso de la cola. Como el proceso P2 no requiere cuatro milisegundos, sale antes de que termine el cuanto de tiempo. Entonces se proporciona la UCP al siguiente proceso, P3 Una vez que cada proceso ha recibido un cuanto de tiempo, se devuelve la UCP al proceso P1 durante un cuanto de tiempo adicional. El resultado obtenido de la planificacin RR es:
El tiempo promedio de espera es 17/3 = 5.66 milisegundos. En el algoritmo de planificacin RR, la UCP no se asigna a ningn proceso por ms de un cuanto consecutivo de tiempo. Si la rfaga de UCP de un proceso excede de un cuanto, se expulsa y regresa a la cola de procesos listos. El algoritmo de planificacin RR es apropiativo. Si existen n procesos en la cola de procesos listos y el cuanto de tiempo es q, cada proceso recibe 1/n de tiempo de la UCP en trozos de q unidades de tiempo como mximo. Ningn proceso debe esperar ms de (n - 1) x q unidades de tiempo antes de recibir su siguiente cuanto. Por ejemplo, si hay cinco procesos, con un cuanto de tiempo de 20 milisegundos, entonces cada proceso recibir hasta 20 milisegundos cada 100 milisegundos.
49
El rendimiento del algoritmo RR depende en gran medida del tamao del cuanto de tiempo. En un extremo, si el cuanto es muy grande (infinito), la poltica RR es la misma que la FCFS. Si el cuanto de tiempo es muy pequeo digamos un microsegundo), el enfoque RR se llama compartir el procesador, y para los usuarios parece (en teora) que cada uno de los n procesos tiene su propio procesador que se ejecuta a 1/n de la velocidad del procesador real. Este enfoque se utiliz en el computador de Control Data Corporation (CDC) para implantar 10 procesadores perifricos con slo un equipo de hardware y 10 conjuntos de registros. El hardware ejecuta una instruccin para un conjunto de registros y luego pasa al siguiente. Este ciclo contina, dando como resultado 10 procesadores lentos en vez de uno rpido. (En realidad, como el procesador era mucho ms rpido que la memoria y cada instruccin hacia referencia a ella, los procesadores no eran mucho ms lentos de lo que habra sido un solo procesador.)
Sin embargo, en el software tenemos que considerar el efecto del cambio de contexto en el rendimiento de la planificacin RR. Supongamos que tenemos slo un proceso de 10 unidades de tiempo. Si el cuanto de tiempo es de 12 unidades de tiempo, el proceso termina en menos de un cuanto, sin tiempo de procesamiento adicional; pero si el cuanto de tiempo es de seis unidades, el proceso requiere 2 cuantos, produciendo un cambio de contexto. Si el cuanto de tiempo es una unidad, ocurrirn nueve cambios de contexto, lo que har ms lenta la ejecucin del proceso (
Figura 2.11).
Por lo anterior, queremos que el cuanto de tiempo sea grande respecto al tiempo de cambio de contexto. Si el tiempo de cambio de contexto es aproxi50 SISTEMAS OPERATIVOS
madamente 10% del cuanto, entonces en el cambio de contexto se invierte cerca de un 10% del tiempo de la UCP.
El tiempo de retorno tambin depende del tamao del cuanto de tiempo. Como podemos ver en la
Figura 2.12, el tiempo de retorno promedio de un conjunto de procesos no necesariamente mejora al aumentar el cuanto de tiempo. En general, el tiempo de retomo promedio puede mejorar si la mayora de los procesos terminan su siguiente rfaga de UCP en un solo cuanto de tiempo. Por ejemplo, dados tres procesos de 10 unidades de tiempo cada uno y un cuanto de tiempo de una unidad, el tiempo de retorno promedio es 29, pero si el cuanto es 10, el tiempo de retorno promedio se reduce a 20. Si se aade el tiempo de cambio de contexto, el tiempo de retorno promedio aumenta para un cuanto de tiempo ms pequeo, puesto que se requieren ms cambios de contexto.
Por otra parte, si el cuanto de tiempo es demasiado grande, la planificacin RR degenera hasta convertirse en una poltica FCFS. Una regla emprica es
Mg. Abraham Gamarra Moreno 51
que el 80% de las rfagas de UCP deben ser menores que el cuanto de tiempo.
Figura 2.13). Los procesos se asignan en forma permanente a una cola, generalmente a partir de alguna propiedad del proceso, como puede ser el tamao de la memoria o el tipo de proceso. Cada cola tiene su propio algoritmo de planificacin; por ejemplo, pueden emplearse colas distintas para los procesos de primer y segundo planos. La cola de primer plano puede planificarse con un algoritmo RR, mientras que la de segundo plano se planifica con un algoritmo FCFS. Debe existir adems una planificacin entre las colas, la cual generalmente es una planificacin apropiativa de prioridad fija. Por ejemplo, la cola de procesos de primer plano puede tener prioridad absoluta sobre la cola de procesos de segundo plano. Veamos un ejemplo de algoritmo de planificacin de colas de mltiples niveles con cinco colas: Procesos del sistema Procesos interactivos Procesos interactivos de edicin
Procesos por lotes Procesos de estudiantes Cada cola tiene prioridad absoluta sobre las colas de menor prioridad. Por ejemplo, no podra ejecutarse ningn proceso de la cola de procesos por lotes a menos que las colas de procesos del sistema, procesos interactivos y procesos interactivos de edicin estuvieran vacas. Si un proceso interactivo de
52 SISTEMAS OPERATIVOS
edicin entrara en la cola de procesos listos durante la ejecucin de un proceso por lotes, este ltimo se expulsara.
Otra posibilidad es utilizar una porcin de tiempo para las colas. Cada cola recibira cierta porcin del tiempo de la UCP, la cual se planificara entre los procesos de su cola. Por ejemplo, en el caso de las colas de primer y segundo planos, la cola de primer plano puede recibir el 80% del tiempo de la UCP para la planificacin RR de sus procesos, mientras que la cola de segundo plano recibe el 20% de la UCP para distribuirlo entre sus procesos de manera FCFS.
Sin embargo, la planificacin de colas de mltiples niveles con realimentacin permite a un proceso moverse de una cola a otra. La idea es separar los procesos con diferentes caractersticas en cuanto a rfagas de la UCP. Si un proceso utiliza demasiado tiempo de la UCP, se pasar a una cola de menor prioridad. Este esquema deja a los procesos limitados por E/S y a los procesos interactivos en las colas de mayor prioridad. De igual manera, si un proceso espera demasiado tiempo en una cola de menor prioridad se puede mover a una de mayor prioridad. Esta es una forma de envejecimiento que evitara el bloqueo indefinido.
Por ejemplo, considere un planificador de colas de mltiples niveles con realimentacin con tres colas, numeradas del 0 al 2 (
Figura 2.14). El planificador ejecutar primero todos los procesos de la cola 0. Slo cuando sta se encuentre vaca, se ejecutarn los procesos de la cola 1. En forma similar, los procesos de la cola 2 slo se ejecutarn si las colas 0 y 1 estn vacas. Un proceso que llegue a la cola 1 expulsar a un proceso de la cola 2. A su vez, un proceso de la cola 1 ser expulsado por un proceso que llegue a la cola 0.
A los procesos que entran a la cola de procesos listos se les coloca en la cola 0, y se les asigna un cuanto de tiempo de ocho milisegundos. Si no terminan en este lapso, se mueven al final de la cola 1; si la cola 0 est vaca, se asigna un cuanto de tiempo de 16 milisegundos al proceso que se encuentre al inicio de la cola 1. Si no termina, es expulsado y pasa a la cola 2. Los proce54 SISTEMAS OPERATIVOS
sos de esta cola se ejecutan sobre una base FCFS, nicamente cuando estn vacas las colas 0 y 1. Este algoritmo de planificacin da mayor prioridad a cualquier proceso con una rfaga de UCP de ocho milisegundos o menos. Este proceso recibir rpidamente la UCP, terminar su rfaga de UCP y pasar a su siguiente rfaga de E/S. Los procesos que requieren ms de ocho, pero menos de 24 milisegundos, tambin son atendidos con rapidez, aunque con menor prioridad que los procesos ms breves. Los procesos de larga duracin descienden automticamente 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. Por lo general, un planificador de colas de mltiples niveles con realimentacin se define con los siguientes parmetros El nmero de colas El algoritmo de planificacin para cada cola
El mtodo utilizado para determinar cundo promover un proceso a una cola de mayor prioridad El mtodo utilizado para determinar cundo degradar un proceso a una cola de menor prioridad El mtodo utilizado para determinar a cul cola entrar un proceso cuando necesite servicio La definicin de un planificador de colas de mltiples niveles con realimentacin lo convierte en el algoritmo de planificacin de la UCP ms general. Se puede configurar para ajustarse a un sistema especfico que se est diseando, pero por desgracia tambin requiere alguna forma de seleccin de valores para todos los parmetros que definan el mejor planificador. Aunque las colas de mltiples niveles con realimentacin son el esquema ms general, tambin son el ms complejo.
sistema heterogneo). Si los procesadores son diferentes, las opciones son relativamente limitadas. Cada procesador tiene su propia cola y su propio algoritmo de planificacin. Los procesos estn tipificados intrnsecamente por su estructura, y deben ejecutarse en un procesador determinado; un programa escrito en lenguaje ensamblador VAX no puede ejecutarse en un IBM Series/1; hay que ejecutarlo en un VAX. As, los procesos se restringen a ciertos procesadores y cada procesador puede planificarse a s mismo. Si hay varios procesadores idnticos, pueden compartir cargas. Sera posible proporcionar una cola distinta a cada procesador, pero en esta situacin un procesador podra estar inactivo, con una cola vaca, mientras los dems procesadores estuvieran muy activos. Para evitarlo utilizamos una cola comn de procesos listos; todos los procesos entran a esta cola y se planifican en cualquier procesador disponible. Con este esquema puede emplearse una de dos estrategias d planificacin. En una de ellas, cada procesador se planifica a s mismo. Cada procesador examina la cola comn de procesos listos y selecciona un proceso para ejecucin. Si tenemos varios procesadores que tratan de acceder a una estructura de datos comn y actualizarla, hay que programar con cuidado cada procesador. Debemos asegurar que dos procesadores no elijan el mismo proceso, y que no se pierdan procesos de la cola. La otra estrategia evita este problema estableciendo un procesador como planificador para los dems, creando as una estructura amo-esclavo, esto es, el multiprocesamiento asimtrico.
Resumen
El objetivo de la multiprogramacin en los Sistemas Operativos, es que en todo momento se ejecute un proceso para maximizar la utilizacin de la UCP (Unidad Central de Proceso); por lo tanto, se debe utilizar algn algoritmo que nos permita planificar la UCP.
Indicadores de logro
El lector utiliza los algoritmos de planificacin de la UCP.
Bibliografa Recomendada
Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Silberschatz A, Peterson J, Galvin P. Sistemas Operativos. Usa: Editorial Addison Wesley Iberoamericana, 3ra Edicin; 1994.
SISTEMAS OPERATIVOS
56
Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
Nexo
La siguiente unidad acadmica analiza el procesamiento concurrente para un sistema operativo.
Actividad
Realice una prueba de escritorio a los algoritmos de planificacin.
Se supone que los procesos llegaron en el orden P1, P2, P3, P4, P5 todos en el instante 0. a) Dibuje cuatro grficas de Gantt que ilustren la ejecucin de estos procesos utilizando la planificacin FCFS, SJF, una prioridad no apropiativa (un menor nmero de prioridad representa una prioridad mayor) y RR (cuanto = 1). b) Cul es el tiempo de retomo de cada proceso para cada uno de los algoritmos de planificacin del apartado a)? c) Cul es el tiempo de espera de cada proceso para cada uno de los algoritmos de planificacin del apartado a)? d) Cul de los esquemas de planificacin del apartado a) ofrece el menor tiempo promedio de espera (para todos los procesos)?
Mg. Abraham Gamarra Moreno 57
PROBLEMA DOS Suponga que los procesos siguientes llegan para su ejecucin en los momentos indicados. Cada proceso se ejecutar en el tiempo indicado. Al responder a estas preguntas, utilice la planificacin no apropiativa y base todas sus decisiones en la informacin que tenga en el momento de tomar la decisin.
Proceso P1 P2 P3 Instante de llegada 0.0 0.4 1.0 Duracin de la rfaga 8 4 1
a) Cul es el tiempo de retorno promedio para estos procesos con el algoritmo de planificacin FCFS? b) Cul es el tiempo de retorno promedio para estos procesos con el algoritmo de planificacin SJF? c) Supuestamente, el algoritmo de planificacin SJF mejora el rendimiento, pero observe que decidimos ejecutar el proceso P1 en el instante 0 porque no sabamos que pronto llegaran dos procesos ms breves. Calcule cul sera el tiempo de retorno total promedio si la UCP estuviera inactiva durante la primera unidad de tiempo y luego se aplicara la planificacin SJF. Recuerde que los procesos P1 y P2 estn en espera durante este periodo de inactividad, por lo que puede aumentar su tiempo de espera. A este algoritmo se le podra conocer como planificacin con conocimiento del futuro. PROBLEMA TRES Cinco trabajos por lote, A-E, llegan a un centro de cmputo casi al mismo. Tienen tiempo estimados de ejecucin de 10, 6, 2, 4 y 8 minutos. Sus prioridades (determinadas en forma externa) son de 3, 5, 2, 1 y 4, respectivamente, siendo 5 la mxima prioridad. Para cada uno de los siguientes algoritmos de planificacin, determine el tiempo promedio de retorno a cada proceso. Ignore el costo excesivo de la alternancia entre procesos. A. B. Round robin. Planificacin por prioridad.
C. Dar servicio primero al que llego en primer lugar (se ejecuta en el orden 10, 6, 2, 4 y 8). D. En primer lugar el trabajo ms corto.En A, suponga que el sistema es multiprogramado y que cada tarea obtiene la porcin justa de la CPU. Para B y D, suponga que slo se ejecuta un trabajo a la vez, hasta que termina. Todos los trabajos tienen limitaciones de uso de la CPU.
58 SISTEMAS OPERATIVOS
Nota: Usar la columna prioridad sola para la planificacin por prioridades. Calcular el tiempo promedio de espera (considere algoritmos apropiativos) para: E. F. G. Planificacin del trabajo del ms corto primero, SJF Planificacin por prioridades Planificacin circular, quantum=3
59
60
SISTEMAS OPERATIVOS
UNIDAD ACADEMICA 3
PROCESAMIENTO CONCURRENTE PARTE 1
3.1. CONCEPTOS DE PROCESOS 3.1.1. DEFINICIONES DE PROCESO.
El trmino proceso fue utilizado, en principio, por los diseadores del sistema Multics en la dcada de 1960. Desde entonces, el proceso, en alguna medida intercambiada con tarea, se le ha dado muchas definiciones. Las que siguen son algunas de ellas: un programa que se est ejecutando una actividad asincrnica el espritu 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.
61
Si un proceso que se encuentra en estado de ejecucin inicia una operacin de entrada/salida antes de que termine su quantum, el proceso voluntariamente abandona el CPU (es decir, el proceso se bloquea a s mismo hasta la terminacin de la operacin de e ntrada/salida). La nica otra transicin posible en este modelo de tres estados ocurre cuando termina una operacin de entrada/salida (o alguna otra causa por la que est esperando el proceso). El proceso cambia del estado bloqueado al estado listo.
prioridad del proceso apuntadores para localizar la memoria del proceso apuntadores para asignar recursos rea para preservar registros.
El PCB es un almacenamiento central de informacin que permite al sistema operativo localizar toda la informacin clave sobre el proceso. Cuando el sistema operativo cambia la atencin del CPU entre los procesos, utiliza las reas de preservacin del PCB para mantener la informacin que necesita para reiniciar el proceso cuando consiga de nuevo el CPU.
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.
SISTEMAS OPERATIVOS
Un proceso puede crear un nuevo proceso. Si lo hace, el proceso que lo crea se llama proceso padre, y el proceso creado se llama proceso hijo. Tal creacin produce una estructura jerrquica de procesos como la mostrada en la Figura 3.2, en la cual cada hijo tiene un solo padre, pero cada padre puede tener varios hijos. Destruir un proceso implica borrarlo del sistema. Sus recursos son devueltos al sistema, se purga de todas las listas o tablas del sistema, y se borra su bloque de control de proceso. Un proceso suspendido no puede proseguir hasta que otro proceso lo reanude. Las suspensiones suelen durar slo un breve perodo de tiempo. A menudo son realizados por el sistema para sacar temporalmente ciertos procesos durante una situacin de carga pico. Reanudar (o activar) un proceso implica el reiniciarlo en el punto donde fue suspendido. La destruccin de un proceso es mucho ms complicada si ha creado otros procesos. En algunos sistemas, un proceso creado se destruye automticamente al destruir al padre; en otros sistemas, los procesos creados continan independientemente de sus padres, y la destruccin de un padre no tiene ningn efecto sobre los hijos que ha creado. Cambiar la prioridad de un proceso no suele implicar ms que cambiar el valor de la prioridad en el bloque de control de procesos.
Si un sistema est funcionando deficientemente y puede fallar, entonces los procesos que estn en ejecucin debern 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 ms tarde, cuando la carga vuelva a sus niveles normales.
La Figura 3.3 muestra el diagrama de transicin de estado de los procesos modificado para incluir suspensin y reanudacin. Se han aadido dos estados ms: el suspendido listo y el suspendido bloqueado; no hay necesidad de un estado suspen dido de ejecucin. Sobre la lnea de trazos de la figura estn los estados activos; debajo de ella estn los estados suspendidos. Una suspensin puede ser iniciada por el propio proceso o por otro proceso. En un sistema uniprocesador, un proceso en estado de ejecucin puede suspenderse a s mismo; ningn otro proceso puede estar en ejecucin al mismo tiempo para emitir la suspensi n. En un sistema multiprocesador, un proceso en estado de ejecucin puede ser suspendido por otro proceso en el mismo estado que se est ejecutando en un procesador diferente.
66
SISTEMAS OPERATIVOS
Manipulacin de bloques de control de proceso. Soporte de las operaciones de entrada/salida. Soporte para la administracin de memoria principal. Soporte del sistema de archivos. Soporte de un mecanismo de llamada/regreso al procedimiento. Soporte de ciertas funciones contables del sistema.
Los procesos asincrnicos deben interactuar ocasionalmente entre s, y esas interacciones pueden ser complejas. Aqu se trata varios ejemplos de interaccin de procesos.
Estas proposiciones ocurren en pares y suelen denominarse parbegin/parend (para comenzar y finalizar una ejecucin en paralelo), o cobegin/coend (para comenzar o finalizar una ejecucin concurrente). En este trabajo emplearemos cobegin/coend de acuerdo a la sintaxis del Pascal-FC. Su forma general es:
cobegin proposicin 1; proposicin 2; : . proposicin n; coend
Supongase que un programa est ejecutando una sola secuencia de instrucciones cuando se encuentra con la construccin cobegin anterior. Esto determina que la trayectoria de control simple se divida en n trayectorias separadas de control, una por cada proposicin de la construccin 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 ms all del coend. Como ejemplo, considrese el siguiente clculo de una raz de la ecuacin cuadrtica: x := ( -b + (b**2 - 4*a*c) ** 0.5) / (2*a) Esta asignacin puede ser evaluada en un procesador secuencial (poseedor de una instruccin de exponenciacin) de la siguiente manera:
Mg. Abraham Gamarra Moreno 69
1 2 3 4 5 6 8 9
b**2 4*a (4*a)*c (b**2) - (4*a*c) (b**2 - 4*a*c) ** 0.5 - b 7 (-b) + ( (b**2 - 4*a*c)**0.5 ) 2*a (-b+(b**2-4*a*c)**0.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. En un sistema que soporte procesamientos en paralelo, la expresin puede evaluarse de la manera siguiente:
1 cobegin t1:= -b; t2:= b ** 2; t3:= 4 * a; t4:= 2 * a; coend 2 t5:= t3 * c; 3 t5:= t2 - t5; 4 t5:= t5 ** 0.5; 5 t5:= t1 + t5; 6 x:= t5 / t4;
Aqu se evalan en paralelo las cuatro operaciones contenidas dentro de la construccin cobegin/coend; las cinco operaciones restantes deben ser ejecutadas de forma secuencial. Al ejecutar los clculos en paralelo se reduce en gran medida el tiempo real de ejecucin.
70
SISTEMAS OPERATIVOS
Suponga que NOLINEAS tiene un valor de 2345. Suponga ahora que el primer proceso ejecuta las instrucciones LOAD y ADD, dejando as el valor de 2346 en un acumulador. Entonces el proceso pierde el procesador (debido a la terminacin de un quantum) en beneficio del segundo proceso. Este ltimo ejecuta ahora las tres instrucciones, ajustando as NOLINEAS con el valor 2346. Pierde el procesador y lo obtiene de nuevo el primer proceso, el cual contina con la ejecucin de la instruccin STORE, colocando tambin el valor 2346 en NOLINEAS. Debido al acceso incontrolado a la variable compartida NOLINEAS el sistema ha perdido la pista de una de las lneas, el total correcto debera ser 2347. Para ejecutar lo ejemplos que se analizan de aqu en adelante, ubiquese en la carpeta unidad 3, luego en la carpeta PFCWIN, y realice doble click en compilador.exe. Con ese archivo se ejecuta el Pascal Concurrente.La carga de los archivos se realiza con File, Open. La ejecucin con la tecla F9. A continuacin, se muestra el programa pro00 que simula este concepto as como diferentes corridas del mismo. El proceso uno pone 60 lneas mientras que el proceso dos pone 40. Por supuesto, la suma total de lneas debera ser 100, pero observe lo que pasa.
program pro00; var nolineas: integer; (* El proceso uno contar 60 lineas *) process uno;var lin: integer; begin for lin := 1 to 60 do begin nolineas := nolineas + 1end end; (* uno *) (* El proceso dos contar 40 lneas *) process dos;var lin: integer; begin for lin := 1 to 40 do begin nolineas := nolineas + 1end end; (* dos *) (* Programa principal *) begin nolineas := 0; cobegin uno; dos coend; writeln(Total de lneas =,nolineas)
Mg. Abraham Gamarra Moreno 71
end.
La salida en varias ejecuciones es: Total de lneas = Total de lneas = Total de lneas = Total de lneas = Total de lneas = 57 74 78 76 69
NOTA: La salida que se obtiene al ejecutar el programa podra variar en su computador. Este problema puede solucionarse dndole a cada proceso acceso exclusivo a NOLINEAS. Mientras un proceso incrementa la variable compartida, los dems procesos que deseen hacer lo mismo al mismo tiempo deben permanecer a la espera; cuando ese proceso termine de accesar la variable deseada, le ser permitido proceder a uno de los procesos. De esta manera, cada proceso que est accesando el dato compartido impide a todos los dems hacer lo mismo al mismo tiempo. Esto se denomina exclusin mutua.
entre los procesos, y algunas que demandan una adherencia rgida a protocolos estrictos. Estar dentro de una seccin crtica es un estado muy especial asignado a un proceso. El proceso tiene acceso exclusivo a los datos compartidos, y todos los dems procesos que necesitan accesar a esos datos permanecen en espera. Por tanto, las secciones crticas deben ser ejecutadas lo ms rpido posible, un programa no debe bloquearse dentro de su seccin crtica, y las secciones crticas deben ser codificadas con todo cuidado (para evitar, por ejemplo, la posibilidad de incurrir en ciclos infinitos). Si un proceso dentro de una seccin crtica termina, tanto de forma voluntaria como involuntaria, entonces, al realizar su limpieza de terminacin, el sistema operativo debe liberar la exclusin mutua para que otros procesos puedan entrar en sus s ecciones crticas.
entraexclusionmutua; nolineas := nolineas + 1; saledeexclusionmutua end; (* dos *) begin nolineas := 0; cobegin uno; dos coend;end.
end
En el caso de los dos procesos, estas primitivas operan como sigue: cuando proceso uno ejecuta entraexclusionmutua, si proceso dos no est en su seccin crtica, entonces proceso uno entra a su seccin crtica, accesa la variable deseada y despus ejecuta saledeexclusionmutua para indicar que ha abandonado su seccin crtica. Si proceso dos est en su seccin crtica cuando proceso uno ejecuta entraexclusionmutua, entonces proceso uno entra en espera hasta que proceso dos ejecute saledeexclusionmutua. Proceso uno puede, entonces, proceder a entrar en su seccin crtica. Si proceso uno y proceso dos ejecutan entraexclusionmutua simultneamente, entonces le ser permitido proceder a alguno, permaneciendo el otro en espera.
74
No deber hacerse ninguna suposicin en relacin con las velocidades relativas de procesos concurrentes asincrnicos. Los procesos que se encuentren operando fuera de sus secciones crticas no pueden evitar que entren otros procesos en sus propias secciones crticas. No deben postergarse indefinidamente la entrada de los procesos en sus secciones crticas.
Una implementacin elegante de software de la exclusin mutua fue la presentada por primera vez por el matemtico holands Dekker. En la siguiente seccin seguimos el desarrollo de Dijkstra del algoritmo de Dekker.
begin while pnumero = 1 do null; nolineas := nolineas + 1; pnumero := 1end end; (* dos *) begin pnumero := 1; nolineas := 0; cobegin uno; dos coend;writeln(Total de lneas =,nolineas) end.
El proceso uno ejecuta el while-do. Como pnumero es inicialmente 1, el proceso uno entra a su seccin crtica. El proceso dos encuentra pnumero igual a 1 y permanece encerrado en su ciclo de while-do. Cuando el proceso dos obtiene el procesador, simplemente permanece en el ciclo en espera de que pnumero se ajuste a 2, as que proceso dos no entra en su seccin crtica y la exclusin mutua queda garantizada. El proceso uno acaba por terminar la ejecucin dentro de su seccin crtica (ha de suponerse que no hay ciclos infinitos) y ajusta pnumero a 2, permitiendo as que el proceso dos entre en su seccin crtica. La exclusin mutua est garantizada, pero el precio es alto. El proceso uno debe de entrar primero, as es que si el proceso dos est listo para entrar en su seccin crtica, deber tardar bastante. Despus de que el proceso uno entre y salga de su seccin crtica, entonces el proceso dos deber seguir, aun cuando el proceso uno desee reentrar y el proceso dos no est listo. Entonces, los procesos debern entrar y salir de sus secciones crticas en estricta alternancia. Si un proceso requiere hacer esto muchas ms veces que el otro, est restringido a operar a una velocidad ms lenta de la que requiere. El sistema no debe interbloquearse completamente; por lo menos puede proceder un proceso, si ambos intentan entrar simultneamente en sus secciones crticas. Si uno de los proceso termina, entonces el otro no podr continuar. En la primera solucin existe solamente una variable global simple, y esto forzaba la aparicin del problema de sincronizacin bloqueada. As es que, en la segunda versin (pro02), se usan dos variables: p1dentro, la cual es verdadera si el proceso uno est dentro de su seccin crtica, y p2dentro, que es verdadera si proceso dos est dentro de su seccin crtica. Ahora, mientras p2dentro sea verdadera, el proceso uno permanece encerrado en una espera. El proceso dos acaba abandonando su seccin crtica y realiza su propio cdigo de salida de exclusin mutua, ajustando p2dentro en falso. El proceso uno ajusta entonces p1dentro en verdadero y entra en su seccin crtica.
76 SISTEMAS OPERATIVOS
Mientras p1dentro sea verdadera, proceso dos no podr entrar en su seccin crtica. La sutileza de la programacin concurrente vuelve a salir a la superficie, como quiera que el proceso uno y el proceso dos son concurrentes, ambos podran intentar en forma simultnea sus secuencias de cdigo de entrada de exclusin mutua. A continuacin se muestra el listado del programa pro02.
program pro02; (* segunda version de las primitivas de exclusin mutua *) var p1dentro, p2dentro: boolean; nolineas: integer; process uno;var lin: integer; begin for lin := 1 to 50 do begin while p2dentro do null; p1dentro := true; nolineas := nolineas + 1; p1dentro := false end end; (* uno *) process dos;var lin: integer; begin for lin := 1 to 50 do begin while p1dentro do null; p2dentro := true; nolineas := nolineas + 1; p2dentro := falseend end; (* dos *) begin p1dentro := false; p2dentro := false; nolineas := 0; cobegin uno; dos coend;writeln(Total de lneas = ,nolineas) end.
En principio, tanto p1dentro como p2dentro son falsas. El proceso uno podra probar p2dentro y encontrarla falsa; entonces, antes de que el proceso uno pueda ajustar p1dentro en verdadero, el proceso dos podra probar p1dentro y
Mg. Abraham Gamarra Moreno 77
enco ntrarla falsa. En este punto, el proceso uno coloca p1dentro en verdadero y entra a su seccin crtica, y el proceso dos ajusta p2dentro en verdadero y entra a su seccin crtica. Ambos procesos se encuentran en sus secciones crticas al mis mo tiempo, as es que la segunda versin ni siquiera garantiza la exclusin mutua. A continuacin se muestra la corrida del programa pro02. La salida para varias ejecuciones es: Total de lneas = Total de lneas = 91 94
En la segunda versin existe una dificultad, 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 seccin crtica, hay tiempo suficiente para que el otro proceso pruebe su bandera y entre en su seccin crtica. Por tanto, una vez que el proceso intenta la prueba del while, debe tener la seguridad de que el otro proceso no puede ir ms all de su propia prueba del while. La tercera versin intenta resolver esto haciendo que cada proceso ajuste su bandera antes de la ejecucin del while.
program pro03; (* tercer version de primitivas de exclusion mutua *) var p1quiere, p2quiere: boolean; nolineas: integer; process uno;var lin: integer; begin for lin := 1 to 20 do begin p1quiere := true; while p2quiere do null; nolineas := nolineas + 1; p1quiere :=false end end; (* uno *) process dos;var lin: integer; begin for lin := 1 to 20 do begin p2quiere := true; while p1quiere do null; nolineas := nolineas + 1;
78 SISTEMAS OPERATIVOS
p2quiere := falseend end; (* dos *) begin nolineas := 0; cobegin uno; dos coend;writeln(Total de lneas =,nolineas) end.
Se ha solucionado un problema pero se ha creado otro. Si cada proceso ajusta su bandera antes de proceder con la prueba del while, entonces, cada proceso se encontrar con la bandera de la otra ajustada y entrarn para siempre en el ciclo while-do. Este es un ejemplo de un interbloqueo de dos procesos (la corrida de este programa causa que la mquina quede bloqueada). (El programa bloquea la computadora) El problema de la tercera versin es que todos los procesos pueden encerrarse en su ciclo while-do respectivo. Es necesaria una manera de romper estos ciclos. La cuarta versin logra esto al forzar cada proceso de ciclo a ajustar su bandera en falso rep etidamente en perodos breves; esto permitir al otro proceso proceder ms all de su prueba del while, con su bandera todava conectada.
program pro04; (* cuarta version de primitivas de exclusion mutua*) var p1quiere, p2quiere: boolean; nolineas: integer; process uno;var lin: integer; begin for lin := 1 to 20 do begin p1quiere := true; while p2quiere do begin p1quiere := false; sleep(random(10)); p1quiere := true end; nolineas := nolineas + 1; p1quiere := falseend end; (* uno *) process dos;var lin: integer;
Mg. Abraham Gamarra Moreno 79
begin for lin := 1 to 30 do begin p2quiere := true; while p1quiere do begin p2quiere := false; sleep(random(10)); p2quiere := true end; nolineas := nolineas + 1; p2quiere := falseend end; (* dos *) begin nolineas := 0; cobegin uno; dos coend;writeln(Total de lneas =,nolineas) end.
A continuacin se muestra una corrida para este programa. La ejecucin del programa es: Total de lneas = 50
La exclusin mutua queda garantizada y no puede ocurrir el interbloqueo, pero puede presentarse otro problema devastador en potencia, el de postergacin indefinida. Veamos como. Debido a que no pueden hacerse suposiciones acerca de las velocidades relativas de los procesos concurrentes asincrnicos, habr que considerar todas las secuencias de ejecucin posibles. El proceso podra, por ejemplo, proceder en tndem. Cada proceso puede seguir la siguiente secuencia: ajustar su bandera en verdadero, hacer la prueba del while, entrar en el cuerpo del ciclo while, ajustar su bandera en falso, retardarse, ajustar su bandera en verdadero y, luego, repetir la secuencia, comenzando con la prueba del while. En tanto hacen esto, las condiciones de prueba perm anecern verdaderas. Desde luego que la probabilidad de que tal operacin ocurra es muy baja, pero puede ocurrir. Por lo tanto, la cuarta versin es inaceptable. Si un sistema que utiliza este sistema de exclusin mutua estuviera controlando un vue lo espacial, un marcapasos cardaco o un sistema de control de trfico areo, la posibilidad de que ocurra una postergacin indefinida con el consecuente fallo del sistema no es admisible.
El algoritmo de Dekker resuelve la posibilidad de la postergacin indefinida experimentada en la cuarta versin. Veamos como. El proceso uno indica su deseo de entrar en su seccin crtica, al conectar su bandera (ajustarla en verdadero). Entonces proced e con la prueba del while donde verifica si el proceso dos tambin quiere entrar. Si la bandera del proceso dos est desconectada (ajustada en falso), entonces el proceso uno salta el cuerpo del ciclo while y entra en su seccin crtica. Supngase, sin embargo, que cuando el proceso uno realice la prueba del while, descubre que la bandera del proceso dos est conectada. Esto obliga al proceso uno a entrar al cuerpo del ciclo while. Aqu busca la variable pfavorecido, que se utiliza para resolver los conflictos que surgen cuando ambos procesos desean entrar al mismo tiempo en sus secciones crticas. Si el proceso uno es el favorecido, salta el cuerpo del if y ejecuta repetidamente la prueba del while, esperando a que el proceso dos descon ecte su bandera. (Luego veremos que el proceso dos debe acabar haciendo eso.) Si el proceso uno determina que el proceso favorecido es el proceso dos, entonces el proceso uno es forzado a entrar en el cuerpo del if, donde desconecta su propia bandera, entra al ciclo del prximo while y permanece all en tanto el proceso dos siga s iendo el proceso favorecido. Al desconectar su propia bandera, el proceso uno permite al proceso dos entrar en su seccin crtica. El proceso dos acabar abandonando su seccin crtica y ejecutar su cdigo de salida de exclusin mutua. Estas instrucciones ajustan el proceso favorecido de vuelta al proceso uno y desconectan la bandera del proceso dos. El proceso uno puede entrar aho ra al while interno y conectar su propia bandera. El proceso uno realiza ahora el while externo. Si la bandera del proceso dos (que acaba de desconectarse) sigue an desconectada, entonces el proceso uno entra en su seccin crtica. Sin embargo, si el pro ceso dos intent reentrar rpidamente en su seccin crtica, entonces la bandera del proceso dos estar conectada y el proceso uno ser obligado de nuevo a entrar en el cuerpo del while externo.En esta ocasin, sin embargo, el proceso uno est sentado en el asiento del conductor, debido a que ahora es el proceso favorecido (recuerde que cuando el proceso dos abandon su seccin crtica, ajust pfavorecido al primero). As es que el proceso un o salta el cuerpo del if y ejecuta de forma repetida la prueba del while externo, hasta que el proceso dos humildemente, desconecte su bandera, permitiendo entrar en su seccin crtica. A continuacin se muestra el listado del programa que utiliza el algoritmo de Dekker para la exclusin mutua.
program dekker; (* solucin de Dekker al problema de la exclusion mutua *) var favorecido: integer; p1quiere, p2quiere: boolean;
Mg. Abraham Gamarra Moreno 81
nolineas: integer; process uno;var lin: integer; begin for lin := 1 to 20 do begin p1quiere := true; while p2quiere do begin p1quiere := false; while favorecido = 2 do null; p1quiere := true end; nolineas := nolineas + 1; favorecido := 2; p1quiere := falseend end; (* uno *) process dos;var lin: integer; begin for lin := 1 to 20 do begin p2quiere := true; while p1quiere do begin p2quiere := false; while favorecido = 1 do null; p2quiere := true end; nolineas := nolineas + 1; favorecido := 1; p2quiere := falseend end; (* dos *) begin nolineas := 0; favorecido := 1; cobegin uno; dos coend;writeln(Total de lneas = ,nolineas) end.
Considere la siguiente posibilidad interesante. Al salir el proceso uno del ciclo interno de espera, es posible que pierda el procesador, y que el proceso dos complete el ciclo e intente entrar de nuevo en su seccin crtica. El proceso
82 SISTEMAS OPERATIVOS
dos conectar ent onces su bandera primero y entrar en su seccin crtica. Cuando el proceso uno obtenga de nuevo el procesador, conectar su bandera. Como ser el turno del proceso uno, si el proceso dos intenta entrar, desconectar su propia bandera y ser obligado a en trar al ciclo interno de espera, y el proceso uno podr entrar en su seccin crtica. De esta manera, este truco no dar como resultado una postergacin indefinida. Algoritmo de PetersonOtro interesante algoritmo para manejar la exclusin mutua entre dos procesos, es el algoritmo de Peterson (programa ptrson), del cual presentamos el siguiente listado y corrida.
program peterson; (*Algoritmo de Peterson para la exclusin mutua de dos procesos *) var nolineas, turno : integer; band1, band2: boolean; process uno; var lin: integer; begin for lin := 1 to 20 do begin band1:= true; (* anuncia el intento de entrar *) turno:= 2; (* le da prioridad al otro proceso *) while band2 and (turno = 2) do null; nolineas := nolineas + 1; band1:= false end end; process dos; var lin: integer; begin for lin := 1 to 30 do begin band2:= true; (* anuncia el intento de entrar *) turno:= 1; (* le da prioridad al otro proceso *) while band1 and (turno = 1) do null; nolineas := nolineas + 1; band2:= falseend end; begin nolineas := 0; turno := 1; band1 := false; band2 := false; cobegin uno;
Mg. Abraham Gamarra Moreno 83
Los procesos comparten las variables band1, band2 y turno. Inicialmente band1 = band2 = false, y el valor de turno no tiene relevancia (pero debe ser 1 o 2). En el listado de los procesos, se puede apreciar que para entrar en la seccin crt ica, 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). Si ambos procesos tratan de entrar a la vez, se asignar turno como 1 y 2 aproximadamente al mismo t iempo. Slo una de estas asignaciones durar; la otra ocurrir, pero ser reemplazada de inmediato. El valor eventual de turno decide a cual de los dos procesos se le permitir entrar primero en su seccin crtica. Ahora demostraremos que esta solucin es correcta. Necesitamos demostrar: (1) que se conserva la exclusin mutua, (2) que se respeta el requisito de progreso y (3) que se cumple el requisito de espera limitada. Para demostrar la propiedad (1) observamos que cada proceso entra en su seccin crtica nicamente cuando band2 = false o turno = 1 para el proceso uno (band1 = false o turno = 2 para el proceso dos). Observe tambin que, si ambos procesos pueden estar en ejecucin en sus secciones crticas al mismo tiempo, entonces band1 = band2 = true. Estas dos observaciones representan que uno y dos no pueden haber cumplido con xito la condicin del while aproximadamente al mismo tiempo, ya que el valor de turno puede ser 1 o 2, pero no los dos. Por consiguiente, uno de los procesos, digamos uno, debi ejecutar con xito la condicin while, mientras que dos tuvo que ejecutar por lo menos un enunciado adicional (turno=2). S in embargo, como en ese momento band1=true y turno=2, y esta condicin persistir mientras uno se encuentre en su seccin crtica, se concluye que se conserva la exclusin mutua. Para comprobar las propiedades (2) y (3) observamos que se puede evitar que el proceso dos entre en su seccin crtica nicamente cuando se queda en el ciclo while con la condicin band1=true y turno = 1; ste es el nico ciclo. Si uno no est listo para entrar en la seccin crtica, entonces band1= false, y dos puede entrar en su seccin crtica. Si uno ha establecido band1 = true y tambin est ejecutando su enunciado while, entonces turno = 1 o turno = 2. Si turno = 2, entonces uno entrar en la seccin crtica. Empero, una vez que uno sale de su seccin crtica, volver a establecer band1=false, permitiendo que dos entre en su seccin crtica. Si uno vue lve a establecer band1 como true, tambin deber establecer turno=2. Por lo tanto, como dos no cambia el valor de la variable turno mientras ejecuta el ciclo while, dos entrar
84 SISTEMAS OPERATIVOS
en la seccin crtica (progreso) des pus de, como mximo, una entrada de uno (espera limitada).
Resumen
Los procesos son concurrentes si existen al mismo tiempo. Los procesos concurrentes pueden funcionar con total independencia unos de otros, o pueden ser asincrnicos, lo cual significa que requieren una sincronizacin y cooperacin ocasionales. 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).
Indicadores de logro
El lector es capaz de modificar los programas que contienen los algoritmos de exclusin mutua.
Bibliografa Recomendada
Davies G. PASCAL-FC (Version 5): Language Reference Manual. UK: University of Bradford; 1992. Allen Weiss, Mark (2000). Estructuras de Datos en Java, compatible con Java 2. Editorial Addison Wesley. Espaa. Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Silberschatz A, Peterson J, Galvin P. Sistemas Operativos. Usa: Editorial Addison Wesley Iberoamericana, 3ra Edicin; 1994. Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
Nexo
La siguiente unidad acadmica analiza ms algoritmos de exclusin mutua.
Actividad
Analice los aspectos tericos relacionados con los procesos.
85
Mencione las diferencias entre procesamiento concurrente y procesamiento en paralelo. Mencione un ejemplo de exclusin mutua. Mencione un ejemplo de seccin crtica. Exponga 3 razones que justifiquen por qu es apropiado e importante el estudio de la concurrencia. PROBLEMA DOS
El programa pro04 (Cuarto intento), garantiza la exclusin mutua y no puede ocurrir el interbloqueo, pero puede presentar el problema de postergacin indefinida. Demuestre con una corrida del programa (prueba de escritorio) como ocurre esto. PROBLEMA TRES
86
SISTEMAS OPERATIVOS
En el algoritmo de Dekker, es posible que el proceso dos abandone su seccin crtica, ejecute su cdigo de salida de exclusin mutua, ejecute su cdigo de entrada en exclusin mutua y entre en su seccin crtica antes de el proceso uno tenga la oportunidad que ha estado esperando para entrar en su seccin crtica. Puede realmente el proceso dos entrar en su seccin crtica muchas veces antes que el proceso uno tenga su oportunidad?. Si esto es posible, explique cmo podra suceder e indique si se trata de un ejemplo de postergacin indefinida. Si no puede suceder, explique con precisin cmo se evita.
87
UNIDAD ACADEMICA 4
PROCESAMIENTO CONCURRENTE PARTE 2
4.1. EXCLUSION MUTUA DE N-PROCESOS 4.1.1. ALGORITMO DE DIJKSTRA.
Dijkstra fue el primero en presentar una solucin de software para la implementacin de primitivas de exclusin mutua de n-procesos. A continuacin se muestra un programa que utiliza el algoritmo de Dijkstra para la exclusin mutua.
program dijkstra; (* algoritmo de dijkstra para la exclusin mutua *) const nprocs=3; var b, c: array[0..nprocs] of boolean; turno: integer; i, nolineas : integer; procedure lock(pnum: integer); var ok: boolean; j: integer; begin b[pnum] := false;
Mg. Abraham Gamarra Moreno 89
repeat while turno <> pnum do begin c[pnum] := true; if b[turno] then turno := pnum end; (* while *) c[pnum] := false; ok := true; for j := 1 to nprocs do if j <> pnum thenok := ok and c[j] until ok end; (* lock *) procedure unlock(pnum: integer); begin c[pnum] := true; b[pnum] := true; turno := 0 end; (* unlock *) process type terminal(n: integer); var loop: integer; begin for loop := 1 to 20 do begin lock(n); nolineas := nolineas + 1;unlock(n) end end; (* terminal *) var p: array[0..nprocs] of terminal; begin nolineas := 0; for turno := 0 to nprocs do begin b[turno] := true; c[turno] := true end; turno := 0; cobegin for i := 0 to nprocs do p[i](i) coend; writeln(Total de Lneas: ,nolineas)end.
A continuacin se muestran los resultados de la corrida del programa (obsrvese que son 4 procesos que ponen 20 lneas cada uno): Total de Lneas: 80
90
SISTEMAS OPERATIVOS
Al principio, a estas estructuras se les asigna un valor inicial 0 y false, respectivamente. Por conveniencia, definimos la siguiente notacin: n (a,b) < (c,d) si (a < c) o si (a = c) y b < d condicin que determina si el proceso b con el boleto a es favorecido o no para entrar a la seccin crtica con respecto al proceso d con el boleto c. (en el programa bakery esta condicin se implementa por medio de la funcin favorecido). n max(a1 , ... , an) es un (esto se nmero, k, tal implementa en el que k programa > ai para i=1, mediante la funcin ...,n max)
A continuacin se muestra un listado del programa para resolver el mismo problema de exclusin mutua (conteo de lneas) mediante el algoritmo de la panadera de Lamport.
program bakery; (* Exclusin mutua con el algoritmo de la panadera de Lamport *) const nprocs = 5; var
Mg. Abraham Gamarra Moreno 91
boleto: array[1..nprocs] of integer; eleccion: array[1..nprocs] of boolean; lp: integer; nolineas: integer; process type Entrada(esteproc: integer); var otroproc, lp: integer;
function max: integer; var i, largo: integer; begin largo := 0; for i := 1 to nprocs do if boleto[i] > largo then largo := boleto[i]; max := largo + 1 end; (* max *) function favorecido(i, j: integer): boolean; 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; (* favorecido *) begin for lp := 1 to 20 do begin eleccion[esteproc] := true; boleto[esteproc] := max; eleccion[esteproc] := false; for otroproc := 1 to nprocs do begin while eleccion[otroproc] do null; while favorecido(otroproc, esteproc) do null; end; nolineas := nolineas + 1; boleto[esteproc] := 0 end end; (* Entrada *) var turnos: array[1..nprocs] of Entrada; begin nolineas := 0; for lp := 1 to nprocs do
92 SISTEMAS OPERATIVOS
begin boleto[lp] := 0; eleccion[lp] := false; end; cobegin for lp := 1 to nprocs do turnos[lp](lp)coend; writeln(Total de Lneas: ,nolineas:4)end.
A continuacin se muestran los resultados de la corrida del programa: Total de Lneas: 100
4.2. SEMFOROS
Dijkstra extract las nociones clave de la exclusin mutua en su concepto de semforo. Un semforo es una variable protegida cuyo valor puede ser accesado y alterado tan slo por las operaciones wait, signal y una operacin de inicializacin del semforo initial. Los semforos binarios slo pueden tomar los valores 0 y 1. Los semforos contadores pueden tomar valores enteros no negativos. La operacin wait en el semforo S, escrito wait(S), opera de la siguiente manera:
if S > 0 then S:=S - 1 else (espera en S) La operacin signal en el semforo S, escrito signal(S), opera de la siguiente manera: if (uno o ms procesos estn 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 - primero en salir para los procesos que esperan a completar un wait(S). La ejecucin de las instrucciones wait y signal son indivisibles. La exclusin mutua en el semforo, S, es aplicada en wait(S) y signal(S). Si varios procesos intentan ejecutar wait(S) al mismo tiempo, slo uno podr proseguir; los otros permanecern en espera. Los semforos y las operaciones de semforos pueden implementarse en software o hardware. En general, se implementan en el ncleo del sistema operativo, donde se controlan los cambios de estado de un proceso. El programa sem01 que se lista a continuacin, muestra como pueden utilizarse los semforos para aplicar la exclusin mutua.
program sem01; (* solucin por semforos al problema de la exclusin mutua *)
Mg. Abraham Gamarra Moreno 93
var nolineas: integer; mutex: semaphore; (* declaracin del semforo *) process uno; var lin: integer; begin for lin := 1 to 20 do egin wait(mutex); (* Espera por el semforo *) nolineas := nolineas + 1; (* seccin crtica *) signal(mutex) (* libera el semforo *) end end; (* uno *) process dos; var lin: integer; begin for lin := 1 to 20 do begin wait(mutex); nolineas := nolineas + 1; signal(mutex) end end; (* dos *) begin nolineas := 0; initial(mutex,1); (* se inicializa el semforo *) cobegin uno; dos coend; writeln(Total de Lneas = ,nolineas) end.
El proceso uno ejecuta algunas cosas preliminares y despus ejecuta wait(mutex). El semforo ha sido inicializado a cero, de modo que el proceso debe esperar. El proceso dos ejecuta signal(mutex) para sealar que el evento ha ocurrido. Esto permite proceder al proceso uno. Obsrvese que este mecanismo trabaja incluso cuando proceso dos detecta y seala el evento antes de que el proceso uno ejecute wait(mutex); el semforo habr sido incrementado de 0 a 1, as es que wait(mutex), decrementa el semforo de 1 a 0, y proceso uno proseguir sin tener que esperar a que ocurra el evento.
95
Suponga que Uno ejecuta wait(S) y luego Dos ejecuta wait(Q). Cuando Uno ejecuta wait(Q), debe esperar a que Dos ejecute signal(Q). De manera parecida, cuando Dos ejecuta wait(S), debe esperar a que Uno ejecute signal(S). Como estas operaciones de signal no pueden ejecutarse, Uno y Dos estn en bloqueo mutuo. 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. Otro problema relacionado con el bloqueo mutuo es el bloqueo indefinido o inanicin, en que los procesos pueden esperar indefinidamente dentro del semforo. El bloqueo indefinido se puede presentar si aadimos y eliminamos procesos de la lista aso ciada con un semforo en orden LIFO. A continuacin se muestra el listado de un programa sencillo que ilustra el concepto de bloqueo mutuo. La segunda columna de nmeros en el listado del compilador, corresponde a la direccin de memoria de esa instruccin en lenguaje de mquina. Este tipo de listado se presenta para determinar, el punto exacto, de cada proceso en el programa fuente, donde ocurre el bloqueo.
program sem03; (* Proceso de sincronizacin de bloqueo/despertar con semforos *) var S, Q: semaphore;(* declaracin de los semforos *) process Uno;
96 SISTEMAS OPERATIVOS
begin writeln(Entramos al Uno); wait(S); (* Espera por el semforo *) writeln(El Uno toma S y espera por Q);wait(Q); writeln(Uno entra a la seccin crtica ); signal(S); signal(Q); end; (* uno *) process Dos; begin writeln(Entramos al Dos); wait(Q); (* Espera por el semforo *) writeln(El Dos toma Q y espera por S);wait(S); writeln(Dos entra a la seccin crtica ); signal(Q); signal(S); end; (* dos *) begin initial(S,1); initial(Q,1); cobegin Uno;Dos coend;end.
A continuacin se muestran diferentes corridas del programa hasta obtener un bloqueo mutuo.
Entramos al Uno Entramos al Dos El Uno toma S y espera por Q Uno entra a la seccin crtica El Dos toma Q y espera por SDos entra a la seccin crtica 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 seccin crtica El Uno toma S y espera por Q Uno entra a la seccin crtica Program terminated normally Type r and RETURN to rerun r
Mg. Abraham Gamarra Moreno 97
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. El intrprete ofrece un diagnstico de esta condicin de la siguiente forma:
Pascal-FC post-mortem report on sem03 - Interpreter Version P5.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
dor lee los datos de buffer y los imprime. Es posible que los procesos productor y consumidor trabajen bien en tndem, o que sus velocidades de ejecucin sean muy parecidas. Si cada vez que el productor deposita un dato en buffer, el consumidor lo lee y lo imprime de inmediato, entonces la salida impresa representar fielmente la corriente de nmeros generada por el productor. Pero supngase que las velocidades de los procesos son dispares. Si el consumidor est operando con ms rapidez que el productor, el consumidor puede leer e imprimir datos antes de que el productor los deposite. Si el productor est operando ms rpido q ue el consumidor, el productor podra sobreescribir los datos previos antes de que el consumidor tenga la oportunidad de leerlos e imprimirlos; un productor muy veloz podra hacer esto muchas veces, con lo cual muchos resultados se perderan. Como es evidente, 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. La aplicacin de tal comportamiento se conoce como sincronizacin de procesos. El siguiente programa (pcsem) muestra un programa concurrente que utiliza las operaciones de semforos para implementar una relacin productor - consumidor. Los procesos utilizan la variable compartida buffer. El productor va poniendo en el arreglo los nmeros del 65 al 90 (cdigo ASCII de las letras A-Z) mientras que el consumidor los va tomando e imprimiendo. Aqu hemos utilizado tres semforos: mutex se utiliza para aplicar el acceso de exclusin mutua a la variable compart ida buffer; listos controla la sincronizacin de los procesos para determinar si existen datos en el buffer; espacios controla en la sincronizacin la existencia de espacio en el buffer.
program pcsem; (* Solucin al problema del Productor - Consumidor mediante el uso de semforos*) const buffmax = 5; var buffer: array[0..buffmax] of integer; sigentra, sigsale: integer; (* apuntadores a buffer para el manejo de la cola*) espacios, listos: semaphore; mutex: semaphore; procedure pon(ch: integer); begin (* el buffer es una cola circular *) buffer[sigentra] := ch; sigentra := (sigentra + 1) mod (buffmax + 1) end; (* pon *) procedure toma(var ch: integer); beginch := buffer[sigsale];
Mg. Abraham Gamarra Moreno 99
sigsale := (sigsale + 1) mod (buffmax + 1) end; (* toma *) process productor; var local: integer; begin for local := 65 to 90 do begin wait(espacios); (* Espera que haya espacio *) wait(mutex); (* Entrada a la seccin crtica *) pon(local); (* Seccin crtica *) write(chr(local)); signal(mutex); (* Sale de seccin crtica *) signal(listos) (* Avisa que ya hay un dato listo *)end end; (* productor *) process consumidor; var local: integer; begin repeat begin wait(listos); (* Espera que haya datos listos *) wait(mutex); (* Entra en la seccin crtica *) toma(local); (* Seccin crtica *) signal(mutex); (* sale de la seccin crtica *) signal(espacios); (* Avisa que hay un espacio *) write(chr(local+32)); enduntil local = 90; writeln end; (* consumidor *) begin initial(espacios,buffmax + 1); initial(listos,0); initial(mutex,1); sigentra := 0; sigsale := 0; cobegin productor;consumidor coend end.
A continuacin se muestran diferentes corridas de este programa. Las letras maysculas corresponden al dato y el momento en que el productor pone en el buffer el dato. Las letras minsculas indican el dato y el momento en que el consumidor tom el dato.
La salida es:AaBCbDcEFdGeHfIgJhKiLjMkNlmOnPoQpRqSrTsUtVuWvXwYxZyz AaBbCcDEdFeGfHgIhJiKjLkMlNmOnPoQpRSqTrUsVtWuXYvwZxyz ABaCbDcEdFeGfHgIhJiKjLkMlNmOnPoQpRqSrTsUtVuWvXYwZxyz
AaBCbDcEdFeGfHgIhJKLijMNkOlPmQnRoSpTqUrVWsXtYuZvwxyz
100 SISTEMAS OPERATIVOS
Tal vez, la ms importante de estas construcciones sea el monitor, sugerida por Dijkstra, despus por Brinch Hansen, y luego refinada por Hoare. Este tema no ser tratado en el presente libro. Los recursos en Pascal-FC brindan algunos de los comportamientos del protected record del lenguaje Ada. Los recursos son similares a los monitores en que ellos proporcionan una exclusin mutua, garantizada por el compilador, del acceso a datos encapsulados; pero las condiciones de sincronizacin se realizan por barrera (barriers) en los procedimientos, en lugar de las variables de condicin. Este tema no ser tratado en el presente libro.
101
blema de sincronizacin clsico, pero no por su importancia prctica sino porque es un ejemplo de una gran clase de problemas de control de concurrencia.Una solucin sencilla consiste en representar cada palillo con un semforo. Un filsofo trata de coger el palillo ejecutando una operacin wait en ese semforo; suelta sus palillos ejecutando signal en los semforos correspondientes. As, los datos compartidos son: var palillo:array [0..4] of semforo; donde todos los elementos de palillo reciben un valor inicial de 1. A continuacin se presenta un programa que simula esta situacin.
program Filo01; (* Filosofos comelones - semforos versin 1 *) const N = 5; var palillo : array [1..N] of semaphore; (* binario *) I : integer; process type filosofos(numero : integer); begin repeat writeln(Pensando el ,numero); sleep(random(5)); (* PENSANDO *) wait(palillo[numero]); wait(palillo[(numero mod N) + 1]); writeln(Comiendo el ,numero); sleep(random(5)); (* COMIENDO *) signal(palillo[numero]); signal(palillo[(numero mod N) + 1]); forever end; (* filosofos *) var procfil: array[1..N] of filosofos; begin for I := 1 to N do initial(palillo[I],1); cobegin for I := 1 to N doprocfil[I](I); coendend.
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
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 solucin garantiza que dos vecinos no pueden comer simultneamente, hay que rechazarla porque existe la posibilidad de crear un bloqueo mutuo. Suponga que los cinco filsofos tienen hambre al mismo tiempo y cada uno coge el palillo que est a su izquierda; todos los elementos del arreglo palillo sern iguales a cero. Cuando cada filsofo trata de coger el palillo a su derecha, su ejecucin se aplazar eternamente. A continuacin se presentan varias posibles soluciones, con diferentes algoritmos y con diferentes elementos del lenguaje para la sincronizacin de procesos. Se aclara que cualquier solucin satisfactoria para este problema debe eliminar la posibilidad de que uno de ellos muera de hambre. Una solucin libre de bloqueos mutuos no la elimina necesariamente. Permitir que cuatro filsofos como mximo, se sienten a comer al mismo tiempo.
program Filo02; (* Filsofos comelones - semforos versin 2 *) const N = 5; var
104 SISTEMAS OPERATIVOS
palillo : array [1..N] of semaphore; (* binario *) sillaslibre : semaphore; (* general *) I : integer; process type filosofos(numero : integer); begin repeat writeln(Pensando el ,numero:2); sleep(random(5)); (* PENSANDO *) wait(sillaslibre); wait(palillo[numero]); wait(palillo[(numero mod N) + 1]); writeln(Comiendo el ,numero:2); sleep(random(5)); (* COMIENDO *) signal(palillo[numero]); signal(palillo[(numero mod N) + 1]); signal(sillaslibre) forever end; (* filosofos *) var procfil: array[1..N] of filosofos; begin for I := 1 to N do initial(palillo[I],1); initial(sillaslibre,N - 1); cobegin for I := 1 to N doprocfil[I](I); coendend.
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
105
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
es que no hay forma de leer el valor activo de un semforo; en esta solucin, un cliente que entra en la peluquera debe contar el nmero de clientes que esperan. Si es menor que el nmero de sillas, l se queda; en caso contrario, se va. Cuando el barbero abre su negocio por la maana, ejecuta el procedimiento Barbero, lo que establece un bloqueo en el semforo clientes hasta que alguien llega; despus se va a dormir. Cuando llega el primer cliente, l ejecuta Cliente, que inicia procurando que mutex entre a una regin crtica. Si otro cliente llega poco tiempo despus, el segundo no podr hacer nada, hasta que el otro haya liberado a mutex. El cl iente verifica entonces si el nmero de clientes que esperan es menor que el nmero de sillas. Si esto no ocurre, libera mutex y sale sin cortarse el pelo. Si existe una silla disponible, el cliente incrementa la variable entera enespera. Luego realiza un signal en el semforo clientes, con lo que despierta al barbero. En este momento, tanto el cliente como el barbero estn despiertos. Cuando el cliente libera a mutex, el barbero lo retiene, ordena algunas cosas e inicia el corte de pelo. Al terminar el corte, el cliente sale del procedimiento y deja la peluquera. No existe un ciclo para el cliente, puesto que el corte de pelo es una operacin idempotente. Sin embargo, s existe un ciclo para el barbero, ya que intenta continuar con el s iguiente cliente. Si existe otro cliente presente, el barbero hace otro corte de pelo. Si no, el barbero se va a dormir.
program pelucas; (* Problema del barbero dormilon *) const sillas = 4; NC = 15; varclientes, barberos, mutex: semaphore; (* declaracin de los semforos *) enespera:integer; process Barbero; begin repeat wait(clientes); wait(mutex); enespera := enespera - 1; writeln(Corta el pelo); signal(barberos); signal(mutex); until enespera = 0 end; (* Barbero *) process type Cli(n:integer); begin
Mg. Abraham Gamarra Moreno 107
wait(mutex); if (enespera < sillas) then begin enespera := enespera + 1; signal(clientes); signal(mutex); writeln(Toma asiento el,n:2); wait(barberos); end else begin writeln(Encuentra lleno el ,n:2);signal(mutex); end; end; (* Cli *) var Cliente:array [0..NC] of Cli; i:integer; begin enespera := 0; initial(barberos,1); initial(clientes,0); initial(mutex,1); cobegin Barbero; for i:=0 to NC do Cliente[i](i); coend;end.
La ejecucin 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
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
Resumen
Dijkstra fue el primero en presentar una solucin de software para la implementacin de primitivas de exclusin mutua de n-procesos. Lamport desarroll una solucin que es particularmente aplicable a los sistemas de procesamiento distribuido. Dijkstra extract las nociones clave de la exclusin mutua en su concepto de semforo. Un semforo es una variable protegida cuyo valor puede ser accesado y alterado tan slo por las operaciones wait, signal y una operacin de inicializacin del semforo initial. Los semforos binarios slo pueden tomar los valores 0 y 1. Los semforos contadores pueden tomar valores enteros no negativos.
Mg. Abraham Gamarra Moreno 109
Indicadores de logro
El lector es capaz de explicar y modificar los algoritmos de exclusin mutua de n procesos y es capaz de modificar los programas con semforos y los problemas clsicos de concurrencia.
Bibliografa Recomendada
Davies G. PASCAL-FC (Version 5): Language Reference Manual. UK: University of Bradford; 1992. Allen Weiss, Mark (2000). Estructuras de Datos en Java, compatible con Java 2. Editorial Addison Wesley. Espaa. Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Silberschatz A, Peterson J, Galvin P. Sistemas Operativos. Usa: Editorial Addison Wesley Iberoamericana, 3ra Edicin; 1994. Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
Nexo
La siguiente unidad acadmica trata de la administracin de la memoria, para el almacenamiento real.
Actividad
Pruebe los programas de los ejemplos anteriores y realice un anlisis de su implementacin.
110
SISTEMAS OPERATIVOS
PROBLEMA DOS A travs de una prueba de escritorio muestre como se obtiene la exclusin mutua en el problema de los filsofos comelones. PROBLEMA TRES A travs de una prueba de escritorio muestre como se obtiene la exclusin mutua en EL BARBERO DORMILON.
111
112
SISTEMAS OPERATIVOS
UNIDAD ACADEMICA 5
ADMINISTRACIN DE LA MEMORIA: ALMACENAMIENTO REAL
5.1. INTRODUCCIN AL ALMACENAMIENTO REAL
La organizacin y administracin de la memoria principal, memoria primaria o memoria real de un sistema ha sido y es uno de los factores ms importantes en el diseo de los S. O. Los trminos memoria y almacenamiento se consideran equivalentes. Los programas y datos deben estar en el almacenamiento principal para: Poderlos ejecutar. Referenciarlos directamente.
Se considera almacenamiento secundario o almacenamiento auxiliar al generalmente soportado en discos. La parte del S. O. que administra la memoria se llama administrador de la memoria: Lleva un registro de las partes de memoria que se estn utilizando y de aquellas que no. Asigna espacio en memoria a los procesos cuando estos la necesitan.
113
Un nivel adicional es el cach o memoria de alta velocidad, que posee las siguientes caractersticas: Es ms rpida y costosa que la memoria principal. Impone al sistema un nivel ms de traspaso: Los programas son traspasados de la memoria principal al cach antes de su ejecucin.
114
SISTEMAS OPERATIVOS
Los programas en la memoria cach ejecutan mucho ms rpido que en la memoria principal.
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 ejecucin mucho ms rpida en la cach.
ADMINISTRACIN
DEL
Estn dirigidas a la obtencin del mejor uso posible del recurso del almacenamiento principal. Se dividen en las siguientes categoras: Estrategias de bsqueda: - Estrategias de bsqueda por demanda. - Estrategias de bsqueda anticipada. Estrategias de colocacin. Estrategias de reposicin.
Las estrategias de bsqueda estn relacionadas con el hecho de cundo obtener el siguiente fragmento de programa o de datos para su insercin en la memoria principal. En la bsqueda por demanda el siguiente fragmento de programa o de datos se carga al almacenamiento principal cuando algn programa en ejecucin lo referencia. Se considera que la bsqueda anticipada puede producir un mejor rendimiento del sistema. Las estrategias de colocacin estn relacionadas con la determinacin del lugar de la memoria donde se colocar (cargar) un programa nuevo. Las estrategias de reposicin estn relacionadas con la determinacin de qu fragmento de programa o de datos desplazar para dar lugar a los programas nuevos.
115
DE
ALMACENAMIENTO
En la asignacin contigua cada programa ocupa un bloque contiguo y sencillo de localizaciones de almacenamiento. En la asignacin no contigua un programa se divide en varios bloques o segmentos que pueden almacenarse en direcciones que no tienen que ser necesariamente adyacentes, por lo que es ms compleja pero ms eficiente que la asignacin continua.
El tamao de los programas est limitado por la cantidad de memoria principal. Los sistemas de un solo usuario desperdician gran cantidad de recursos computacionales debido a que (ver Figura 5.3): Cuando ocurre una peticin de e / s la cpu normalmente no puede continuar el proceso hasta que concluya la operacin de e / s requerida.Los perifricos de e / s frenan la ejecucin de los procesos ya que comparativamente la cpu es de magnitud ms rpida que los dispositivos de e / s.
116
SISTEMAS OPERATIVOS
117
Alojan un proceso cada una.La cpu se cambia rpidamente entre los procesos creando la ilusin de simultaneidad.
Los trabajos se traducan con ensambladores y compiladores absolutos para ser ejecutados solo dentro de una particin especfica (ver Figura 5.4).
El S. O. resulta de implementacin relativamente sencilla pero no se optimiza la utilizacin de la memoria, tal como se muestra en la Figura 5.5.
118
SISTEMAS OPERATIVOS
Figura 5.5.
Delineados con dos registros. Indicados el lmite inferior o superior y el tamao de la particin o regin.
Figura 5.7. Proteccin del almacenamiento con asignacin contigua de un solo proceso de usuario.
Figura 5.8. Proteccin del almacenamiento con asignacin contigua en sistemas de multiprogramacin.
LA
MULTIPROGRAMACIN
DE
La fragmentacin de almacenamiento ocurre en todos los sistemas independientemente de su organizacin de memoria. En los S. O. de multiprogramacin de particin fija la fragmentacin se produce cuando:
120
SISTEMAS OPERATIVOS
Los trabajos del usuario no llenan completamente sus particiones designadas. Una particin permanece sin usar porque es demasiado pequea para alojar un trabajo que est en espera.
No hay lmites fijos de memoria, es decir que la particin de un trabajo es su propio tamao. Se consideran esquemas de asignacin contigua, dado que un programa debe ocupar posiciones adyacentes de almacenamiento. 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. En sucesivos pasos los agujeros son cada vez ms numerosos pero ms pequeos, por lo que se genera un desperdicio de memoria principal.
121
La tcnica de compresin 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. Esta tcnica se denomina recogida de residuos (ver Figura 5.11).
122
SISTEMAS OPERATIVOS
Principales desventajas de la compresin Consume recursos del sistema (ver Figura 5.12). El sistema debe detener todo mientras efecta la compresin, lo que puede afectar los tiempos de respuesta. Implica la relocalizacin (reubicacin) de los procesos que se encuentran en la memoria: La informacin de relocalizacin debe ser de accesibilidad inmediata. Una alta carga de trabajo significa mayor frecuencia de compresin que incrementa el uso de recursos.
123
Estrategia de peor ajuste: Consiste en colocar un programa en el agujero en el que quepa de la peor manera, es decir en el ms grande posible: El agujero restante es tambin grande para poder alojar a un nuevo programa relativamente grande (Figura 5.15).
SISTEMAS OPERATIVOS
124
MULTIPROGRAMACIN CON INTERCAMBIO DE ALMACENAMIENTO En el esquema de intercambio los programas del usuario no requieren permanecer en la memoria principal hasta su terminacin (Figura 5.16).
125
Figura 5.16.
Una variante consiste en que un trabajo se ejecuta hasta que ya no puede continuar: Cede el almacenamiento y la cpu al siguiente trabajo. La totalidad del almacenamiento se dedica a un trabajo durante un breve perodo de tiempo. Los trabajos son intercambiados, dndose que un trabajo puede ser intercambiado varias veces antes de llegar a su terminacin.
Es un esquema razonable y eficiente para un nmero relativamente reducido de procesos de usuarios. Los sistemas de intercambio fueron los predecesores de los sistemas de paginacin.
126 SISTEMAS OPERATIVOS
El rendimiento de los sistemas de intercambio mejora al reducir el tiempo de intercambio: Manteniendo al mismo tiempo varias imgenes de usuario o imgenes de memoria en la memoria principal. Retirando una imagen de usuario de la memoria principal solo cuando es necesario su almacenamiento para una nueva imagen. Incrementando la cantidad de memoria principal disponible en el sistema.
Las imgenes de usuario (imgenes de memoria) retiradas del almacenamiento principal se graban en el almacenamiento secundario (discos).
Resumen
La organizacin y administracin de la memoria principal, memoria primaria o memoria real de un sistema ha sido y es uno de los factores ms importantes en el diseo de los S. O. 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. El almacenamiento principal es ms costoso y menor que el secundario pero de acceso ms rpido.
Indicadores de logro
El lector explica los fundamentos del almacenamiento en la memoria real.
Bibliografa Recomendada
Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Luis la Red Martnez D. Sistemas Operativos Modernos. Argentina: Universidad Nacional Del Nordeste U.N.N.E.; 2001. Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
127
Nexo
La siguiente unidad acadmica trata de la administracin de la memoria virtual.
Actividad
Realice un anlisis de los aspectos tericos de la administracin de la memoria real.
con el mtodo del primero que se ajuste ?. Repita ahora la pregunta con el mejor en ajustarse y el peor en ajustarse. PROBLEMA TRES Consideremos un sistema de intercambio en el que la memoria consta de los siguientes tamaos de espacios en orden de memoria: 10K, 4K, 35K, 18K, 7K, 9K, 12K y 15K. Cul 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 ms alta de la memoria. 19K con el mtodo del primero que se ajuste?. Repita ahora la pregunta con el mejor en ajustarse y el peor en ajustarse.
129
130
SISTEMAS OPERATIVOS
UNIDAD ACADEMICA 6
ADMINISTRACIN DE LA MEMORIA: ALMACENAMIENTO VIRTUAL
6.1. INTRODUCCIN A LA ALMACENAMIENTO VIRTUAL ORGANIZACIN 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 computacin. Los mtodos ms comunes de implementacin son mediante: Tcnicas de paginacin. Tcnicas de segmentacin. Una combinacin de ambas tcnicas.
Las direcciones generadas por los programas en su ejecucin no son, necesariamente, aquellas contenidas en el almacenamiento primario (memoria real), ya que las direcciones virtuales suelen seleccionarse dentro de un nmero mucho mayor de direcciones que las disponibles dentro del almacenamiento primario. La evolucin en las organizaciones de almacenamiento puede resumirse como sigue: Real: Sistemas dedicados a un solo usuario.
131
Real: Sistemas de multiprogramacin en memoria real: Multiprogramacin en particin fija: Absoluta y Relocalizable (reubicable). Multiprogramacin en particin variable.
Virtual: Multiprogramacin en almacenamiento virtual: Paginacin pura, Segmentacin pura y Combinacin paginacin / segmentacin.
BSICOS
DE
ALMACENAMIENTO
La clave del concepto de memoria (almacenamiento) virtual esta en la disociacin: De las direcciones a las que hace referencia un programa. De las direcciones disponibles en la memoria real (almacenamiento primario).
Los principales conceptos son los siguientes: Direcciones virtuales: Son las referidas por un proceso en ejecucin. Direcciones reales: Son las disponibles dentro del almacenamiento primario. Espacio de direcciones virtuales (v) de un proceso: Es el nmero de direcciones virtuales a que puede hacer referencia el proceso. Espacio de direcciones reales de un computador: Es el nmero de direcciones reales disponibles en el ordenador.
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, mientras el proceso est en ejecucin. La traduccin de direcciones deber hacerse rpidamente para no degradar al sistema. Existen varios medios para asociar las direcciones virtuales con las reales (ver Figura 6.1).
132 SISTEMAS OPERATIVOS
Figura 6.1. Transformacin de tems del espacio de direcciones virtuales al espacio de direcciones reales.
Los mecanismos de traduccin dinmica de direcciones (dat) convierten las direcciones virtuales en reales al ejecutarse el proceso. Las direcciones contiguas dentro del espacio de direcciones virtuales de un proceso no tienen por qu ser contiguas dentro del almacenamiento real, a esto se denomina contigidad artificial (ver Figura 6.2).
133
Se utiliza un esquema de almacenamiento de dos niveles (ver Figura 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. Segundo nivel: almacenamiento auxiliar, 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 ms limitado almacenamiento real.
Cuando se va a ejecutar un proceso su cdigo y datos se pasan al almacenamiento principal. El almacenamiento real es compartido por varios procesos: Cada proceso puede tener un espacio de direcciones virtuales mucho mayor que el almacenamiento real. Solo se mantiene al mismo tiempo una pequea parte de los programas y datos de cada proceso en el almacenamiento real.
134
SISTEMAS OPERATIVOS
Cuanto mayor sea el bloque menor ser la fraccin del almacenamiento real que debe dedicarse a contener la informacin del mapa. Con bloques grandes: Se reduce la sobrecarga de almacenamiento del mecanismo de transformacin.
135
- Se incrementa el tiempo de transferencia entre los almacenamientos secundario y primario. Consumen ms almacenamiento real pudiendo limitar el nmero de procesos que pueden compartirlo. Los bloques pueden ser de tamao: - Igual: se denominan pginas y la organizacin de almacenamiento virtual asociada se denomina paginacin. Diferente: se denominan segmentos y la organizacin de almacenamiento virtual asociada se denomina segmentacin. Se pueden combinar ambas tcnicas: segmentos de tamao variable compuestos de pginas de tamao fijo.
Las direcciones son bidimensionales, es decir que una direccin virtual v se indica por un par ordenado (b,d), donde: b: nmero del bloque donde reside. d: desplazamiento a partir del inicio del bloque.
La traduccin de una direccin virtual v = (b,d) a la direccin real r considera lo siguiente (ver Figura 6.4 y Figura 6.5): Cada proceso tiene su tabla de mapa de bloques mantenida por el sistema en el almacenamiento real. Un registro especial del procesador llamado registro origen de la tabla de bloques se carga con la direccin real a de la tabla de mapa de bloques: - Contiene una entrada para cada bloque del proceso. - Las entradas se mantienen en orden secuencial para el bloque 0, bloque 1, etc. - Se aade el bloque nmero b a la direccin base a de la tabla de bloques para formar la direccin real de la entrada de la tabla de mapa de bloques para el bloque b: Contiene la direccin real b para el bloque b y el desplazamiento d se aade a la direccin de inicio del bloque, b , para formar la direccin real deseada: r = b + d.
136
SISTEMAS OPERATIVOS
La transformacin de bloques se efecta en forma dinmica mientras se ejecuta un proceso, por lo cual, si la implementacin no es eficiente, su sobrecarga puede causar una degradacin del rendimiento que podra eliminar en parte las ventajas de la utilizacin del almacenamiento virtual.
Comienzan en direcciones del almacenamiento real que son mltiplos enteros del tamao fijo de la pgina. Podr colocarse una nueva pgina dentro de cualquier marco de pgina o celda de pgina disponible.
La traduccin dinmica de direcciones incluye: Un proceso en ejecucin hace referencia a una direccin virtual v = (p,d) (ver Figura 6.6).
Un mecanismo de transformacin de pginas busca la pgina p en la tabla de pginas y determina si la pgina p se encuentra en el marco de pgina p . La direccin de almacenamiento real se forma por la concatenacin de p y d.
La tabla de mapa de pginas debe indicar si se encuentra o no en el almacenamiento primario la pgina referenciada: En caso afirmativo dnde est en la memoria real. En caso negativo dnde puede estar en el almacenamiento secundario.
La direccin de almacenamiento primario a, donde comienza el marco de pagina p (suponiendo un tamao de pgina p), est dada por: a = (p) (p); se supone marcos de pgina numerados 0, 1, 2, etc. (ver Figura 6.7, Figura 6.8 y Figura 6.9).
138
SISTEMAS OPERATIVOS
La direccin base de la tabla de mapa de pginas es b. El nmero de pgina es p. La direccin en el almacenamiento primario de la entrada en la tabla de mapa de pginas para la pgina p es b + p: Indica que el marco de pgina p corresponde a la pgina virtual.p se concatena con el desplazamiento d par formar la direccin real r.
Esto es un ejemplo de transformacin directa debido a que la tabla de mapa de pginas contiene una entrada por cada una de las pginas del almacenamiento virtual de este proceso.
139
Figura 6.9. Correspondencia entre las direcciones de almacenamiento virtual y las direcciones de almacenamiento real en un sistema de paginacin.
La direccin virtual que se est traduciendo y la direccin base de la tabla de mapa de pginas son mantenidas en un registro de alta velocidad del control del procesador. La tabla de mapa de pginas transformada directamente suele mantenerse en el almacenamiento primario: Las referencias a esta tabla requieren un ciclo completo de almacenamiento primario, que generalmente es la parte ms larga de un ciclo de ejecucin de instrucciones.
140
SISTEMAS OPERATIVOS
Se requiere otro ciclo de ejecucin de almacenamiento primario para la transformacin de pginas, lo que puede ocasionar degradacin equivalente a un 50%, para lo cual una solucin sera tener la tabla completa de mapa de pginas de transformacin directa en la cach de muy alta velocidad.
141
Un programa en ejecucin hace referencia a la direccin virtual v = (p,d). Cada entrada en el almacenamiento asociativo se busca de forma simultnea para la pgina p: Se obtiene p como el marco de pgina correspondiente a la pgina p. Se concatena p con d formando la direccin real r.
Cada una de las clulas del almacenamiento asociativo se registra de manera simultnea: Hace costoso el almacenamiento asociativo.Implementar la transformacin asociativa pura resulta demasiado costoso, tal lo ocurrido con la implementacin de la transformacin directa pura utilizando cach.
142
SISTEMAS OPERATIVOS
Las entradas de pgina contenidas en este mapa reducido corresponden solo a las pginas referenciadas recientemente: Se presupone que una pgina recientemente referenciada tendr posibilidades de serlo de nuevo prximamente. 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 pgina completo.
Un programa hace referencia a la direccin virtual v = (p,d). El mecanismo de traduccin de direcciones intenta encontrar la pgina p en el mapa de pgina asociativo parcial: Si p se encuentra all: El mapa asociativo devuelve p como el nmero de marco de pgina correspondiente a la pgina virtual p. Luego p se concatena con el desplazamiento d para formar la direccin real r que corresponde a la direccin virtual v=(p,d).
143
Si p no se encuentra en el mapa de pagina parcial: Se utiliza un mapa directo convencional. La direccin b del registro de origen de la tabla de pginas se aade a p para localizar la entrada apropiada a la pgina p en la tabla de mapa de pginas de transformacin directa del almacenamiento primario. La tabla indica que p es el marco de pgina correspondiente a la pgina virtual p. Luego p se concatena con el desplazamiento d para formar la direccin real r correspondiente a la direccin virtual v = (p,d).
144
SISTEMAS OPERATIVOS
6.6. SEGMENTACIN
En los sistemas de segmentacin un programa y sus datos pueden ocupar varios bloques separados de almacenamiento real (ver Figura 6.14). Los bloques: No necesitan ser de igual tamao. Los bloques separados no necesitan ser adyacentes.
Deben estar compuestos de posiciones contiguas de almacenamiento.Se complica la proteccin de bloques de memoria de un proceso de usuario. Es ms difcil limitar el rango de acceso de cualquier programa.
145
Un esquema posible de proteccin es el uso de claves de proteccin del almacenamiento (ver Figura 6.15): Las claves estn bajo el control estricto del S. O. Un programa de usuario, a quien corresponde una cierta clave en la cpu, solo puede hacer referencia a los otros bloques del almacenamiento con igual clave de proteccin.
Una direccin virtual es un par ordenado v=(s,d) (ver Figura 6.16): s es el nmero del segmento del almacenamiento virtual en el cual residen los elementos referidos. d es el desplazamiento en el segmento s en el cual se encuentra el elemento referido.
Un proceso solo puede ejecutarse si su segmento actual (como mnimo) est en el almacenamiento primario. Los segmentos se transfieren del almacenamiento secundario al primario como unidades completas. Un nuevo segmento puede ser colocado en una serie disponible de posiciones contiguas del almacenamiento primario de tamao suficiente para alojar al segmento.
146 SISTEMAS OPERATIVOS
Figura 6.15. Proteccin de alamcenamiento como claves en sistemas de multiprogramacin de asignacin no contigua de almacenamiento.
147
Modo 0 1 2 3 4 5
Lectura Escritura Ejecucin Explicacin N N S S S S N N N N S S N S N S N S No hay permiso de acceso Solo ejecucin Solo lectura Lectura / ejecucin Lectura / escritura pero no ejecucin Acceso no limitado
148
SISTEMAS OPERATIVOS
Modo Aplicacin 0 1 2 3 4 5 Seguridad Un programa disponible a los usuarios, que no pueden copiarlo ni modificarlo, pero s ejecutarlo Recuperacin de informacin Un programa puede ser copiado o ejecutado, pero no puede ser modificado Protege los datos contra un intento errneo de ejecutarlos Este acceso se concede a los usuarios de confianza
149
Se considerar la traduccin de direcciones de segmentacin con la tabla completa de mapa de segmentos en la cach. Un proceso en ejecucin hace referencia a la direccin virtual v = (s,d): El segmento nmero s se aade a la direccin base b en el registro origen de la tabla de mapa de segmentos formando la direccin de memoria real b + s, de la entrada para el segmento s de la tabla de mapa de segmentos, que contiene la direccin del almacenamiento primario s , donde comienza el segmento. El desplazamiento d se aade a s formando la direccin real r = d + s , correspondiente a la direccin virtual v = (s,d).
Un bit de residencia, r, indica si en la actualidad el segmento se encuentra o no en el almacenamiento primario. Si el segmento se encuentra en el almacenamiento primario s es la direccin en este almacenamiento donde comienza el segmento. Si el segmento no se encuentra en el almacenamiento primario a es la direccin en el almacenamiento secundario de donde debe recuperarse antes que el proceso pueda continuar. Se compara cada referencia a un segmento con los bits de proteccin para determinar si se permite la operacin que se est intentando. Si el segmento buscado no est en el almacenamiento primario se genera un fallo de prdida de segmento: El S. O. obtiene el control y carga el segmento referido desde la direccin a del almacenamiento secundario. Se comprueba si el desplazamiento d es menor o igual a la longitud del segmento l : - Si no es as se genera un fallo de desbordamiento de segmento y el S. O. obtiene el control y termina la ejecucin del proceso. - Si el desplazamiento est en el rango del segmento se comprueban los bits de proteccin para asegurarse si se permite la operacin que se est intentando: Si es as entonces la direccin base del segmento, s, en el almacenamiento primario se aade al desplazamiento d formando la direccin de memoria real r = s + d, que corresponde a la direccin del almacenamiento virtual v = (s,d). Si la operacin intentada no se permite se genera un fallo de proteccin de segmento y el S. O. obtiene el control y termina la ejecucin del proceso.
150 SISTEMAS OPERATIVOS
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.18).
151
Figura 6.19. Traduccin de direcciones virtuales con combinacin de transformacin asociativa/directa dentro de un sistema de paginacin y segmentacin.
152
SISTEMAS OPERATIVOS
Las pginas de referencia ms reciente tienen entradas en un almacenamiento asociativo. Se realiza una bsqueda asociativa para intentar localizar (s,p) en el almacenamiento asociativo: Si se encuentra (s,p), entonces el marco de pgina p en el cual reside dicha pgina en la memoria real, se concatena al desplazamiento d para formar la direccin de memoria real r correspondiente a la direccin virtual v= (s,p,d). Si no se encuentra (s,p), entonces: - La direccin base b de la tabla de segmentos se aade al nmero de segmento s formando la direccin b + s de la entrada de la tabla de mapa de segmentos para el segmento s de la memoria real. - La entrada de la tabla de mapa de segmentos indica la direccin base s de la tabla de pginas para el segmento s. El nmero de pgina p se aade a s formando la direccin p + s de la entrada en la tabla de pginas para la pgina p del segmento s: Indica que p es el nmero del marco correspondiente a la pgina virtual p. Luego p se concatena con el desplazamiento d formando la direccin real r que corresponde a la direccin virtual v=(s,p,d). Si el segmento s no se encuentra en el almacenamiento primario se produce un fallo de prdida de segmento, cuyo caso el S. O. localiza el segmento en el almacenamiento secundario, crea una tabla de pginas para el segmento y carga la pgina apropiada en el almacenamiento primario, pudiendo producir reemplazos de pginas. Si el segmento s est en el almacenamiento primario y si la referencia a la tabla de mapa de pginas indica que la pgina deseada no se encuentra en el almacenamiento primario, se produce un fallo de prdida de pgina, en tal caso el S. O. obtiene el control, localiza la pgina en el almacenamiento secundario y la carga, pudiendo reemplazar otra pgina. Si una direccin de almacenamiento virtual est ms all del final del segmento se genera un fallo de desbordamiento de segmento, el que debe ser atendido por el S. O. Si los bits de proteccin indican que la operacin que se va a ejecutar en la direccin virtual referida no se permite, se genera un fallo de proteccin de segmento, el que tambin debe ser atendido por el S. O. Si se utiliza un mecanismo de transformacin directa pura, manteniendo el mapa completo dentro del almacenamiento primario, la referencia promedio de almacenamiento virtual requerira:
Mg. Abraham Gamarra Moreno 153
Un ciclo de almacenamiento para acceder a la tabla de mapa de segmentos. Un segundo ciclo de almacenamiento para hacer referencia a la tabla de mapa de pginas. Un tercer ciclo de almacenamiento para referenciar al elemento deseado del almacenamiento real.
Cada referencia a un elemento comprende tres ciclos de almacenamiento: El sistema correra casi a 1 / 3 de su velocidad nominal. La traduccin de direcciones insumira 2 / 3 del tiempo.
Con la utilizacin de registros asociativos (por ej. 16 registros), se logran velocidades de ejecucin del 90 % o ms de la velocidad total de procesamiento de sus procesadores de control. La Figura 6.20 indica la estructura detallada de tablas requerida por un sistema con paginacin/segmentacin.La estructura de tablas de procesos, de mapas de segmentos y de mapas de pginas puede consumir un porcentaje importante del almacenamiento primario cuando se ejecutan un gran nmero de procesos. La traduccin procede mucho ms rpido si todas las tablas estn en el almacenamiento primario, lo que resta espacio para los procesos.
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 pginas (ver Figura 6.21). El compartimiento requiere una administracin cuidadosa por parte del S. O., ya sea en sistemas de paginacin, segmentacin o paginacin / segmentacin, pues se debe considerar qu sucedera si una nueva pgina reemplazara a otra pgina compartida por muchos procesos.
154
SISTEMAS OPERATIVOS
155
6.8. ADMINISTRACION DEL ALMACENAMIENTO VIRTUAL 6.8.1. ESTRATEGIAS DE ADMINISTRACIN DEL ALMACENAMIENTO VIRTUAL
Las diferentes organizaciones de almacenamiento virtual generalmente implementadas son: Paginacin. Segmentacin. Segmentacin y paginacin.
Las estrategias para la administracin de sistemas de almacenamiento virtual condicionan la conducta de los sistemas de almacenamiento virtual que operan segn esas estrategias. Se consideran las siguientes estrategias:
156 SISTEMAS OPERATIVOS
Estrategias de bsqueda: Tratan de los casos en que una pgina o segmento deben ser trados del almacenamiento secundario al primario. Las estrategias de bsqueda por demanda esperan a que se haga referencia a una pgina o segmento por un proceso antes de traerlos al almacenamiento primario. Los esquemas de bsqueda anticipada intentan determinar por adelantado a qu pginas o segmentos har referencia un proceso para traerlos al almacenamiento primario antes de ser explcitamente referenciados.
Estrategias de colocacin: Tratan del lugar del almacenamiento primario donde se colocar una nueva pgina o segmento. Los sistemas toman las decisiones de colocacin de una forma trivial ya que una nueva pgina puede ser colocada dentro de cualquier marco de pgina disponible.
Estrategias de reposicin: Tratan de la decisin de cul pgina o segmento desplazar para hacer sitio a una nueva pgina o segmento cuando el almacenamiento primario est completamente comprometido.
DE
REPOSICIN
(REEMPLAZO)
DE
El principio de optimizacin. Reposicin de pginas al azar. Primero en entrar - primero en salir. Menos recientemente usada. Menos frecuentemente usada. No usada recientemente. Segunda Oportunidad.
157
El principio de optimizacin indica que para obtener un rendimiento ptimo, la pgina que se va a reponer (reemplazar) es una que no se va a utilizar en el futuro durante el perodo de tiempo ms largo. El problema es que no es factible predecir el futuro. Reposicin de Pgina al Azar Consiste en escoger al azar la pgina que va a ser reemplazada. Todas las pginas del almacenamiento principal deben tener la misma probabilidad de ser reemplazadas. Debe poder seleccionar cualquier pgina, incluyendo la que va a ser referenciada a continuacin (peor seleccin). Este esquema es raramente usado. Reposicin de Pgina por el Sistema de Primero en Entrar Primero en Salir (FIFO) Se registra el momento en que cada pgina ingresa al almacenamiento primario. Para reemplazar una pgina, se selecciona aquella que ha estado ms tiempo almacenada. Se presenta el inconveniente de que se pueden reemplazar pginas muy usadas, que sern llamadas de nuevo al almacenamiento primario casi de inmediato. Se puede presentar la llamada anomala FIFO: Belady, Nelson y Shedler descubrieron que con la reposicin FIFO, ciertos patrones de referencias de pginas causan ms fallos de pginas cuando se aumenta el nmero de marcos (celdas) de pginas asignados a un proceso: en esto consiste la anomala FIFO. Esta anomala contradice a la intuicin (ver Figura 6.22).
158
SISTEMAS OPERATIVOS
Reposicin de Pgina Menos Recientemente Usada (LRU) Esta estrategia selecciona para ser reemplazada la pgina que no ha sido usada durante el mayor perodo de tiempo. Se basa en la heurstica de que el pasado reciente es un buen indicador del futuro prximo. Requiere que cada pgina reciba un sello de tiempo cada vez que se referencia: Puede significar una sobrecarga adicional importante. No se implementa frecuentemente. La pgina seleccionada para reemplazo podra ser la prxima en ser requerida, por lo que habra que paginarla de nuevo al almacenamiento principal casi de inmediato. Analicemos ahora un algoritmo LRU en hardware. En una mquina con n marcos para pgina, el hardware LRU puede utilizar una matriz de n x n bits, cuyos datos iniciales son todos 0. En una referencia al marco k, el hardware primero activa todos los bits del rengln k y desactiva despus todos los bits de la columna k. En cualquier instante, el rengln cuyo valor en binario es mnimo es el de uso menos reciente, el rengln con el siguiente valor ms pequeo es el segundo de uso menos reciente, etc. El trabajo de este algoritmo aparece en la figura siguiente para cuatro marcos para pginas con referencias a las pginas en el orden0 1 2 3 2 1 0 3 2 3
Mg. Abraham Gamarra Moreno 159
Despus de hacer referencia a la pgina 0 tenemos la situacin de la Figura 6.23-a). En la misma figura se muestra la referencia a las otras pginas.
Reposicin de Pgina Menos Frecuentemente Usada (LFU) Ac interesa la intensidad de uso que haya tenido cada pgina. La pgina 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 fcilmente para su reposicin la pgina equivocada: Ejemplo: La pgina de uso menos frecuente puede ser la pgina de entrada ms reciente al almacenamiento principal, y por lo tanto existe una alta probabilidad de que sea usada de inmediato. Reposicin de Pgina No Usada Recientemente (NUR) Presupone que las pginas que no han tenido uso reciente tienen poca probabilidad de ser usadas en el futuro prximo y pueden ser reemplazadas por otras nuevas. Es deseable reemplazar una pgina que no ha sido cambiada mientras estaba en el almacenamiento primario.
160
SISTEMAS OPERATIVOS
La estrategia NUR se implementa con la adicin de dos bits de hardware por pgina: Bit referenciado: R = 0 si la pgina no ha sido referenciada. R = 1 si la pgina ha sido referenciada. Bit modificado (tambin llamado bit sucio): M = 0 si la pgina no ha sido modificada. M = 1 si la pgina ha sido modificada. La seleccin de la pgina que ser reemplazada comienza buscando una pgina que no ha sido referenciada, pero si no la encuentra habr que reemplazar una pgina que ha sido referenciada. Si una pgina ha sido referenciada se comprueba si ha sido modificada o no: Si no ha sido modificada se la reemplaza: Su reposicin representa menos sobrecarga que la de una pgina modificada, ya que debera grabarse de nuevo en el almacenamiento secundario. Si no se encuentra una pgina que no ha sido modificada ser reemplazada una pgina modificada.
Con el transcurso del tiempo la mayora de los bits referenciados sern activados: Se pierde la capacidad para distinguir las pginas ms deseables para ser reemplazadas. Para evitarlo se ajustan peridicamente todos los bits referenciados a 0: - Se logra un nuevo inicio. - Se vuelve vulnerable al reemplazo an a las pginas activas, pero solo brevemente, mientras se reajustan los bits.
161
El algoritmo de reposicin (reemplazo) de pginas de la segunda oportunidad Una modificacin simple de FIFO que evita deshacerse de una pgina de uso frecuente inspecciona el bit R de la pgina ms antigua. Si es 0, la pgina es tanto antigua como no utilizada, por lo que reemplaza en forma inmediata. Si el bit es 1, el bit se limpia, la pgina se coloca al final de la lista de pginas y su tiempo de carga se actualiza, como si hubiera llegado en ese momento a la memoria. Despus contina la bsqueda. La operacin de este algoritmo, llamado de la segunda oportunidad, se muestra en la Figura 6.24. En la Figura 6.24(a), vemos las pginas A hasta H, en una lista ligada ordenada segn el tiempo de llegada a la memoria.
Supongamos que ocurre un fallo de pgina en el instante 20. La pgina ms antigua es A, que lleg en el instante 0, al iniciar el proceso. Si A tiene el bit R = 0, se retira de la memoria, ya sea mediante su escritura en el disco (si tiene nueva informacin) o slo se abandona (en caso contrario). Por otro lado, si R = 1, A se coloca al final de la lista y su tiempo de carga cambia al tiempo activo (20). Se limpia entonces el bit R. La bsqueda de una pgina adecuada prosigue con B. Lo que hace la segunda oportunidad es buscar una pgina antigua sin referencias durante el anterior intervalo de tiempo. Si todas las pginas tienen alguna referencia, el algoritmo de la segunda oportunidad deriva en un simple FIFO, En efecto, supongamos que todas las pginas de la Figura 6.24(a) anterior, tienen R = 1. Una a una, el sistema operativo traslada las pginas al final de la lista y limpia el bit R cada vez que aade una. En cierto momento, regresa a la pgina A, la cual tiene R = 0. En ese momento, A se retira de la memoria. As, el algoritmo siempre termina.
162
SISTEMAS OPERATIVOS
El algoritmo de reposicin (reemplazo) de pginas del reloj Aunque la segunda oportunidad es un algoritmo razonable, es ineficiente e innecesario, puesto que desplaza en forma constante las pginas en una lista. Un mejor enfoque es mantener las pginas en una lista circular, con la forma de un reloj, como se muestra en la Figura 6.25. Una manecilla apunta hacia la pgina ms antigua.
Al ocurrir un fallo de pgina, se inspecciona la pgina a la que apunta la manecilla. Si su bit R = O, la pgina se retira de la memoria, se inserta la nueva pgina en su lugar en el reloj y la manecilla avanza una posicin. Si R = 1, este bit se limpia y la manecilla avanza a la pgina siguiente. Este proceso contina hasta encontrar una pgina con R = O. No debe sorprendernos que este algoritmo se llame del reloj. Difiere de la segunda oportunidad slo por la implantacin.
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 computacin.
163
Indicadores de logro
El lector explica los fundamentos de la memora virtual.
Bibliografa Recomendada
Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Luis la Red Martnez D. Sistemas Operativos Modernos. Argentina: Universidad Nacional Del Nordeste U.N.N.E.; 2001. Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
Nexo
La siguiente unidad acadmica trata sobre el Sistema de Archivos.
Actividad
Analice los aspectos tericos sobre la Memoria Virtual.
164
SISTEMAS OPERATIVOS
R M 0 1 1 1 0 0 1 1
(a) Cul pgina es reemplazada por NRU? (b) Cul pgina es reemplazada por FIFO? Cul pgina es reemplazada por LRU? (d) Cul pgina es reemplazada por la segunda oportunidad? PROBLEMA TRES Una computadora tiene tres marcos para pgina. La tabla muestra pginas con el tiempo de carga, el tiempo del ltimo acceso y los bits R y M para cada pgina aparecen en la tabla siguiente (los tiempos se miden mediante las marcas del reloj): Pgina 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) Cmo se da el reemplazo por FIFO y cuantos fallos de pginas se producen para la carga de las 4 pginas? (b) Cmo se da el reemplazo por NUR y cuantos fallos de pginas se producen para la carga de las 4 pginas? (c) Cmo se da el reemplazo por la segunda oportunidad y cuantos fallos de pginas se producen para la carga de las 4 pginas?
PROBLEMA CUATRO Mediante la tabla de pginas de la Figura 6.26, calcule las direcciones fsicas correspondientes a cada una de las siguientes direcciones virtuales: A. 20.
165
B. C.
4100. 8300.
Figura 6.26.
166
SISTEMAS OPERATIVOS
UNIDAD ACADEMICA 7
SISTEMA DE ARCHIVOS - PARTE 1
7.1. INTRODUCCIN
Todas las aplicaciones computarizadas necesitan almacenar y recuperar la informacin: Superando las limitaciones del almacenamiento real. Trascendiendo a la duracin de los procesos que las utilizan o generan. Independizando a la informacin de los procesos permitiendo el acceso a la misma a travs de varios procesos.
Las condiciones esenciales para el almacenamiento de la informacin a largo plazo son: Debe ser posible almacenar una cantidad muy grande de informacin. La informacin debe sobrevivir a la conclusin del proceso que la utiliza. Debe ser posible que varios procesos tengan acceso concurrente a la informacin.
La solucin es el almacenamiento de la informacin en discos y otros medios externos en unidades llamadas archivos: Los archivos deben ser persistentes, es decir que no deben verse afectados por la creacin o terminacin de un proceso.
167
Los archivos son una coleccin de datos con nombre. Pueden ser manipulados como una unidad por operaciones como: open, close, create, destroy, copy, rename, list. Los elementos de datos individuales dentro del archivo pueden ser manipulados por operaciones como: read, write, update, insert, delete.
El Sistema de Archivos es la parte del sistema de administracin del almacenamiento responsable, principalmente, de la administracin de los archivos del almacenamiento secundario. Es la parte del S. O. responsable de permitir compartir controladamente la informacin de los archivos.
Se debe poder estructurar los archivos de la manera ms apropiada a cada aplicacin. Los usuarios deben poder ordenar la transferencia de informacin entre archivos. Se deben proporcionar posibilidades de respaldo y recuperacin para prevenirse contra: La prdida accidental de informacin. La destruccin maliciosa de informacin.
Se debe poder referenciar a los archivos mediante Nombres Simblicos, brindando Independencia de Dispositivos. En ambientes sensibles, el sistema de archivos debe proporcionar posibilidades de Cifrado y Descifrado. El sistema de archivos debe brindar una interfase favorable al usuario:
168 SISTEMAS OPERATIVOS
Debe suministrar una visin lgica de los datos y de las funciones que sern ejecutadas, en vez de una visin fsica. El usuario no debe tener que preocuparse por: Los dispositivos particulares. Dnde sern almacenados los datos. El formato de los datos en los dispositivos. Los medios fsicos de la transferencia de datos hacia y desde los dispositivos.
El sistema de archivos est relacionado especialmente con la administracin del espacio de almacenamiento secundario, fundamentalmente con el almacenamiento de disco. Una forma de organizacin de un sistema de archivos puede ser la siguiente: Se utiliza una raz para indicar en qu parte del disco comienza el directorio raz . El directorio raz apunta a los directorios de usuarios. Un directorio de usuario contiene una entrada para cada uno de los archivos del usuario.
169
Cada entrada de archivo apunta al lugar del disco donde est almacenado el archivo referenciado.
Los nombres de archivos solo necesitan ser nicos dentro de un directorio de usuario dado. El nombre del sistema para un archivo dado debe ser nico para el sistema de archivos. En sistemas de archivo jerrquicos el nombre del sistema para un archivo suele estar formado como el nombre de la trayectoria del directorio raz al archivo.
7.4. ARCHIVOS
Se considerar el punto de vista del usuario.
Secuencia de registros:
SISTEMAS OPERATIVOS
- El archivo es una secuencia de registros de longitud fija, cada uno con su propia estructura interna. rbol : - El archivo consta de un rbol de registros, no necesariamente de la misma longitud. - Cada registro tiene un campo key (llave o clave) en una posicin fija del registro. - El rbol se ordena mediante el campo de clave para permitir una rpida bsqueda de una clave particular.
Figura 7.1. Estructura de archivos: (a) Secuencia de bytes. (b) Secuencia de registros.
171
Leer en otro orden. Acceso Aleatorio: el proceso puede leer los registros en cualquier orden utilizando dos mtodos para determinar el punto de inicio de la lectura: Cada operacin de lectura (read) da la posicin en el archivo con la cual iniciar. Una operacin especial (seek) establece la posicin de trabajo pudiendo luego leerse el archivo secuencialmente.
Algunos de los posibles atributos de archivo son: Proteccin: quin debe tener acceso y de qu forma. Contrasea: contrasea necesaria para acceder al archivo. Creador: identificador de la persona que cre el archivo. Propietario: propietario actual. Bandera exclusivo - para - lectura: 0 lectura / escritura, 1 para lectura exclusivamente. Bandera de ocultamiento: 0 normal, 1 para no exhibirse en listas. Bandera de sistema: 0 archivo normal, 1 archivo de sistema. Bandera de biblioteca: 0 ya se ha respaldado, 1 necesita respaldo. Bandera ascii / binario: 0 archivo en ascii, 1 archivo en binario. Bandera de acceso aleatorio: 0 solo acceso secuencial, 1 acceso aleatorio. Bandera temporal: 0 normal, 1 eliminar al salir del proceso. Banderas de cerradura: 0 no bloqueado, distinto de 0 bloqueado. Longitud del registro: nmero de bytes en un registro.
173
Posicin de la llave: ajuste de la llave dentro de cada registro. Longitud de la llave: nmero de bytes en el campo llave. Tiempo de creacin: fecha y hora de creacin del archivo. Tiempo del ltimo acceso: fecha y hora del ltimo acceso al archivo. Tiempo de la ltima modificacin: fecha y hora de la ltima modificacin al archivo. Tamao actual: nmero de bytes en el archivo. Tamao mximo: tamao mximo al que puede crecer el archivo.
174
Get attributes (obtener atributos): permite a los procesos obtener los atributos del archivo. Set attributes (establecer atributos): algunos atributos pueden ser determinados por el usuario y modificados luego de la creacin del archivo. La informacin relativa al modo de proteccin y la mayora de las banderas son un ejemplo obvio. Rename (cambiar de nombre): permite modificar el nombre de un archivo ya existente.
El mapeo de archivos elimina la necesidad de programar la e / s directamente, facilitando la programacin. Los principales problemas relacionados son: Imposibilidad de conocer a priori la longitud del archivo de salida, el que podra superar a la memoria. Dificultad para compartir los archivos mapeados evitando inconsistencias, ya que las modificaciones hechas en las pginas no se vern reflejadas en el disco hasta que dichas pginas sean eliminadas de la memoria.
7.5. DIRECTORIOS
Generalmente son utilizados por los S. O. para llevar un registro de los archivos. En muchos sistemas son a su vez tambin archivos.
175
Otra posibilidad es que cada entrada del directorio contenga: El nombre del archivo. Un apuntador a otra estructura de datos donde se encuentran los atributos y las direcciones en disco. Al abrir un archivo el S. O.: Busca en su directorio el nombre del archivo. Extrae los atributos y direcciones en disco. Graba esta informacin en una tabla de memoria real. Todas las referencias subsecuentes al archivo utilizarn la informacin de la memoria principal.
Figura 7.3 Directorios: (a) Atributos en la entrada del directorio. (b) Atributos en otro lugar
Directorio nico: el sistema tiene un solo directorio con todos los archivos de todos los usuarios (ver Figura 7.4).
SISTEMAS OPERATIVOS
Un directorio por usuario: el sistema habilita un solo directorio por cada usuario (ver Figura 7.5). Un rbol de directorios por usuario: el sistema permite que cada usuario tenga tantos directorios como necesite, respetando una jerarqua general (ver Figura 7.6).
177
178
SISTEMAS OPERATIVOS
Los componentes de la ruta de acceso se separan mediante algn carcter llamado separador. Ejemplo: /usr/ast/mailbox Ruta de Acceso Relativa: Se utiliza junto con el concepto de directorio de trabajo o directorio activo. Todos los nombres que no comiencen en el directorio raz se toman en relacin con el directorio de trabajo. El nombre absoluto de la ruta de acceso siempre funciona, sin importar cual sea el directorio de trabajo. Ejemplo: Si el directorio de trabajo es /usr/ast, entonces el archivo cuya ruta de acceso absoluta es /usr/ast/mailbox puede llamarse slo con mailbox.
Crea un enlace del archivo ya existente con el nombre especificado en la ruta de acceso. Unlink (desligar): se elimina una entrada del directorio: - Si el archivo que se desea desligar aparece solo en un directorio (el caso normal): Se elimina del sistema de archivos. Si el archivo que se desea desligar, est presente en varios directorios: Solo se elimina la ruta de acceso especificada. Las dems rutas permanecen.
7.6. IMPLANTACIN DEL SISTEMA DE ARCHIVOS Y SUS RELACIONES CON LA ASIGNACIN Y LIBERACIN DE ESPACIO
Se consideran aspectos tales como: La forma de almacenamiento de archivos y directorios. La administracin del espacio en disco. La forma de hacerlo de manera eficiente y confiable.
Se deben tener presentes problemas tales como la fragmentacin creciente del espacio en disco: Ocasiona problemas de performance al hacer que los archivos se desperdiguen a travs de bloques muy dispersos. Una tcnica para aliviar el problema de la fragmentacin consiste en realizar peridicamente: Condensacin: se pueden reorganizar los archivos expresamente o automticamente segn algn criterio predefinido. Recoleccin de basura o residuos: se puede hacer fuera de lnea o en lnea, con el sistema activo, segn la implementacin.
180
SISTEMAS OPERATIVOS
Asignacin contigua o adyacente: Los archivos son asignados a reas contiguas de almacenamiento secundario. Las principales ventajas son: Facilidad de implantacin, ya que solo se precisa el nmero del bloque de inicio para localizar un archivo. - Rendimiento excelente respecto de la e/s. Los principales defectos son: Se debe conocer el tamao mximo del archivo al crearlo. Produce una gran fragmentacin de los discos. Asignacin no contigua: Son esquemas de almacenamiento ms dinmicos, destacndose los siguientes: Asignacin encadenada orientada hacia el sector: El disco se considera compuesto de sectores individuales. Los archivos constan de varios sectores que pueden estar dispersos por todo el disco. Los sectores que pertenecen a un archivo comn contienen apuntadores de uno a otro formando una lista encadenada. Una lista de espacio libre contiene entradas para todos los sectores libres del disco. Las ampliaciones o reducciones en el tamao de los archivos se resuelven actualizando la lista de espacio libre y no hay necesidad de condensacin. Las principales desventajas son: Debido a la posible dispersin en el disco, la recuperacin de registros lgicamente contiguos puede significar largas bsquedas. El mantenimiento de la estructura de listas encadenadas significa una sobrecarga en tiempo de ejecucin. Los apuntadores de la estructura de lista consumen espacio en disco.
Asignacin por bloques: Es ms eficiente y reduce la sobrecarga en ejecucin. Es una mezcla de los mtodos de asignacin contigua y no contigua. Se asignan bloques de sectores contiguos en vez de sectores individuales. El sistema trata de asignar nuevos bloques a un archivo eligiendo bloques libres lo ms prximos posible a los bloques del archivo existentes. Las formas ms comunes de implementar la asignacin por bloques son:
Mg. Abraham Gamarra Moreno 181
Encadenamiento de bloques. Encadenamiento de bloques de ndice. Transformacin de archivos orientada hacia bloques.
Encadenamiento de bloques o lista ligada Las entradas en el directorio de usuarios apuntan al primer bloque de cada archivo. Cada uno de los bloques de longitud fija que forman un archivo contiene dos partes: Un bloque de datos. Un apuntador al bloque siguiente (Figura 7.7).
Cada bloque contiene varios sectores. Frecuentemente el tamao de un bloque se corresponde con el de una pista completa del disco.
* Buscar en la cadena de bloques hasta encontrar el bloque apropiado. * Buscar en el bloque hasta encontrar el registro. El examen de la cadena desde el principio puede ser lento ya que debe realizarse de bloque en bloque, y pueden estar dispersos por todo el disco. La insercin y el retiro son inmediatos, dado que se deben modificar los apuntadores del bloque precedente. Se pueden usar listas de encadenamiento doble, hacia adelante y hacia atrs, con lo que se facilita la bsqueda. La Figura 7.8, muestra otra figura para el almacenamiento de un archivo como lista ligada o lista enlazada.
Encadenamiento de bloques de ndices Los apuntadores son colocados en varios bloques de ndices separados: * Cada bloque de ndices contiene un nmero fijo de elementos. * Cada entrada contiene un identificador de registros y un apuntador a ese registro. * Si es necesario utilizar ms de un bloque de ndices para describir un archivo, se encadena una serie de bloques de ndices.
183
La gran ventaja es que la bsqueda puede realizarse en los propios bloques de ndices.Los bloques de ndices pueden mantenerse juntos en el almacenamiento secundario para acortar la bsqueda, pero para mejor performance podran mantenerse en el almacenamiento primario. La principal desventaja es que las inserciones pueden requerir la reconstruccin completa de los bloques de ndices: * Una posibilidad es dejar vaca una parte de los bloques de ndices para facilitar inserciones futuras y retardar las reconstrucciones. Es suficiente que el dato del directorio contenga el nmero de bloque inicial para localizar todos los bloques restantes, sin importar el tamao del archivo (ver Figura 7.9).
184
SISTEMAS OPERATIVOS
Transformacin de archivos orientada hacia bloques Se utilizan nmeros de bloques en vez de apuntadores. Los nmeros de bloques se convierten fcilmente a direcciones de bloques gracias a la geometra del disco. Se conserva un mapa del archivo, conteniendo una entrada para cada bloque del disco. Las entradas en el directorio del usuario apuntan a la primera entrada al mapa del archivo para cada archivo.Cada entrada al mapa del archivo contiene el nmero del bloque siguiente de ese archivo. La entrada al mapa del archivo correspondiente a la ltima entrada de un archivo determinado se ajusta a algn valor centinela (nil) para indicar que se alcanz el ltimo bloque de un archivo. El sistema puede mantener una lista de bloques libres. La principal ventaja es que las cercanas fsicas del disco se reflejan en el mapa del archivo (ver Figura 7.10). Nodos-i (nodos ndices) Se asocia a cada archivo una pequea tabla, llamada nodo-i (nodo ndice): Contiene los atributos y direcciones en disco de los bloques del archivo. Se traslada del disco a la memoria principal al abrir el archivo.En rigor, almacena solo las primeras direcciones en disco: Si el archivo es pequeo, toda la informacin est en el nodo-i. Si el archivo es grande, una de las direcciones en el nodo-i es la direccin de un bloque en el disco llamado bloque simplemente indirecto: Contiene las direcciones en disco adicionales. Si resulta insuficiente, otra direccin en el nodo-i, el bloque doblemente indirecto, contiene la direccin de un bloque que presenta una lista de los bloques simplemente indirectos: Cada bloque simplemente indirecto apunta a un grupo de bloques de datos. De ser necesario se pueden utilizar bloques triplemente indirectos (ver Figura 7.11).
185
186
SISTEMAS OPERATIVOS
La principal funcin del sistema de directorios es asociar el nombre del archivo con la informacin necesaria para localizar los datos. Un aspecto ntimamente ligado con esto es la posicin de almacenamiento de los atributos: Una posibilidad es almacenarlos en forma directa dentro del dato del directorio.
187
Otra posibilidad es almacenar los atributos en el nodo-i en vez de utilizar la entrada del directorio.
188
SISTEMAS OPERATIVOS
Resumen
Todas las aplicaciones computarizadas necesitan almacenar y recuperar la informacin de unidades llamadas archivos; y para ello deben utilizar los discos y otros medios externos.
Indicadores de logro
El lector explica los fundamentos de los archivos y directorios.
Bibliografa Recomendada
Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Luis la Red Martnez D. Sistemas Operativos Modernos. Argentina: Universidad Nacional Del Nordeste U.N.N.E.; 2001. Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
Nexo
La siguiente unidad acadmica amplia el Sistema de Archivos.
Mg. Abraham Gamarra Moreno 189
Actividad
Analice los aspectos tericos sobre el Sistema de Archivos.
190
SISTEMAS OPERATIVOS
UNIDAD ACADEMICA 8
SISTEMA DE ARCHIVOS - PARTE 2
8.1. ARCHIVOS COMPARTIDOS
Frecuentemente conviene que los archivos compartidos aparezcan simultneamente en distintos directorios de distintos usuarios. El propio sistema de archivos es una grfica dirigida acclica en vez de un rbol (ver Figura 8.1). La conexin entre un directorio y un archivo de otro directorio al cual comparten se denomina enlace (Figura 8.2). 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. Se debe evitar que los cambios hechos por un usuario a travs de un directorio no sean visibles por los dems usuarios, para lo que se consideraran dos soluciones posibles.
Primera solucin: Los bloques del disco no se enlistan en los directorios, sino en una pequea estructura de datos asociada al propio archivo. Los directorios apuntaran solo a esa pequea estructura de datos, que podra ser el nodo-i.
191
Figura 8.2. (a) Situacin anterior al enlace. (b) Despus de la creacin del enlace. (c) Despus que el propietario original elimina el archivo.
192
SISTEMAS OPERATIVOS
Segunda solucin: El enlace se produce haciendo que el sistema cree un nuevo archivo de tipo link. El archivo link: Ingresa al directorio del usuario que accede a un archivo de otro directorio y usuario. Solo contiene el nombre de la ruta de acceso del archivo al cual se enlaza.
Este criterio se denomina enlace simblico. Desventajas de la primera solucin: La creacin de un enlace: No modifica la propiedad respecto de un archivo. Aumenta el contador de enlaces del nodo-i: El sistema sabe el nmero de entradas de directorio que apuntan en cierto momento al archivo. Si el propietario inicial del archivo intenta eliminarlo, surge un problema para el sistema: Si elimina el archivo y limpia el nodo-i, el directorio que enlazo al archivo tendr una entrada que apunta a un nodo-i no vlido. Si el nodo-i se reasigna a otro archivo el enlace apuntar al archivo incorrecto. El sistema: Puede ver por medio del contador de enlaces en el nodo-i que el archivo sigue utilizndose. No puede localizar todas las entradas de directorio asociadas a ese archivo para eliminarlas. La solucin podra ser: Eliminar la entrada del directorio inicialmente propietario del archivo. Dejar intacto el nodo-i: Se dara el caso que el directorio que posee el enlace es el nico que posee una entrada de directorio para un archivo de otro directorio, para el cual dicho archivo ya no existe. Esto no ocurre con los enlaces simblicos 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. Cuando el propietario elimina un archivo, este se destruye.
Desventajas de la segunda solucin: El principal problema es su costo excesivo, especialmente en accesos a disco, puesto que se debe leer el archivo que contiene la ruta de acceso, analizarla y seguirla componente a componente hasta alcanzar el nodo-i. Se precisa un nodo-i adicional por cada enlace simblico y un bloque adicional en disco para almacenar la ruta de acceso. Los archivos pueden tener dos o ms rutas de acceso, debido a lo cual, en bsquedas genricas se podra encontrar el mismo archivo por distintas rutas y tratrselo como si fueran archivos distintos.
Los enlaces simblicos tienen la ventaja de que se pueden utilizar para enlazar archivos en otras mquinas, en cualquier parte del mundo; se debe proMg. Abraham Gamarra Moreno 193
porcionar solo la direccin de la red de la mquina donde reside el archivo y su ruta de acceso en esa mquina.
194
SISTEMAS OPERATIVOS
Figura 8.3. Representacin de la velocidad de lectura y del uso del espacio en disco en funcin del tamao del bloque
Lista ligada de bloques de disco: Cada bloque contiene tantos nmeros 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 mtodo es preferible cuando existe espacio suficiente en la memoria principal para contener completo el mapa de bits.
195
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 tamao 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, an 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 lmites.
196
SISTEMAS OPERATIVOS
Cuando se aade un bloque a un archivo: Se incrementa el total de bloques cargados al propietario. Se verifica este valor contra los lmites estricto y flexible (el primero no se puede superar, el segundo s). Tambin se verifica el nmero de archivos.
- Lee la lista de bloques defectuosos. - Elige un bloque (o pista) de reserva para reemplazar los defectuosos. - Registra la asociacin en la lista de bloques defectuosos. - En lo sucesivo, las solicitudes del bloque defectuoso utilizarn el de repuesto.
La solucin 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 ledo ni escrito. - No se debe intentar obtener copias de respaldo de este archivo.
(COPIAS
DE
SEGURIDAD
DE
Es muy importante respaldar los archivos con frecuencia. Los respaldos pueden consistir en efectuar copias completas del contenido de los discos (flexibles o rgidos). Una estrategia de respaldo consiste en dividir los discos en reas de datos y reas de respaldo, utilizndolas 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
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 peridicamente (por ej.: una vez por mes o por semana), llamada copia total. Se obtiene una copia diaria solo de aquellos archivos modificados desde la ltima copia total; en estrategias mejoradas, se copian solo aquellos archivos modificados desde la ltima vez que dichos archivos fueron copiados. Se debe mantener en el disco informacin de control como una lista de los tiempos de copiado de cada archivo, la que debe ser actualizada cada vez que se obtienen copias de los archivos y cada vez que los archivos son modificados. Puede requerir una gran cantidad de cintas de respaldo dedicadas a los respaldos diarios entre respaldos completos.
La inconsistencia es particularmente crtica si alguno de los bloques afectados son: Bloques de nodos-i. Bloques de directorios. Bloques de la lista de bloques libres.
La mayora 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. Pueden actuar sobre todos o algunos de los discos. Pueden efectuar verificaciones a nivel de bloques y a nivel de archivos. La consistencia del sistema de archivos no asegura la consistencia interna de cada archivo, respecto de su contenido. Generalmente pueden verificar tambin el sistema de directorios y / o de bibliotecas.
Generalmente los utilitarios utilizan dos tablas (ver Figura 8.7): Tabla de bloques en uso. Tabla de bloques libres. Cada bloque debe estar referenciado en una de ellas.
Si un bloque no aparece en ninguna de las tablas se trata de una falla llamada bloque faltante: No produce daos pero desperdicia espacio en disco. Se soluciona aadiendo el bloque a la tabla de bloques libres.
Tambin podra detectarse la situacin 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, s en los basados en tablas o listas. La solucin consiste en depurar la tabla de bloques libres.
200
SISTEMAS OPERATIVOS
Una falla muy grave es que el mismo bloque de datos aparezca referenciado dos o ms veces en la tabla de bloques en uso: Como parte del mismo o de distintos archivos. Si uno de los archivos se borra, el bloque aparecera en la tabla de bloques libres y tambin en la de bloques en uso. Una solucin es que el verificador del sistema de archivos: - Asigne un bloque libre. - Copie en el bloque libre el contenido del bloque conflictivo. - Actualice las tablas afectando el bloque copia a alguno de los archivos. - Agregue el bloque conflictivo a la tabla de bloques libres. - Informe al usuario para que verifique el dao detectado y la solucin dada. Otro error posible es que un bloque est en la tabla de bloques en uso y en la tabla de bloques libres: Se soluciona eliminndolo de la tabla de bloques libres.
Figura 8.7 Estados del sistema de archivos. (a) Consistente (b) Bloque faltante. (c) Bloque duplicado en la lista de bloques libres. (d) Bloque de datos duplicado.
Las verificaciones de directorios incluyen controles como: Nmero de directorios que apuntan a un nodo-i con los contadores de enlaces almacenados en los propios nodos-i; en un sistema consistente de archivos deben coincidir.
201
Una posible falla es que el contador de enlaces sea mayor que el nmero de entradas del directorio: Aunque se eliminaran todos los archivos de los directorios el contador sera distinto de cero y no se podra eliminar el nodo-i. No se trata de un error serio pero produce desperdicio de espacio en disco con archivos que no se encuentran en ningn directorio. Se soluciona haciendo que el contador de enlaces en el nodo-i tome el valor correcto; si el valor correcto es 0, el archivo debe eliminarse.
Otro tipo de error es potencialmente catastrfico: Si dos entradas de un directorio se enlazan a un archivo, pero el nodo-i indica que solo existe un enlace, entonces, al eliminar cualquiera de estas entradas de directorio, el contador del nodo-i tomar el valor 0. Debido al valor 0 el sistema de archivos lo seala como no utilizado y libera todos sus bloques. Uno de los directorios apunta hacia un nodo-i no utilizado, cuyos bloques se podran asignar entonces a otros archivos. La solucin es forzar que el contador de enlaces del nodo-i sea igual al nmero de entradas del directorio.
Tambin se pueden hacer verificaciones heursticas, por ej.: Cada nodo-i tiene un modo, pero algunos modos son vlidos aunque extraos: - Ej.: Se prohbe el acceso al propietario y todo su grupo, pero se permite a los extraos leer, escribir y ejecutar el archivo. - La verificacin debera detectar e informar de estas situaciones. - Se debera informar como sospechosos aquellos directorios con excesivas entradas, por ej., ms de mil.
202
La tcnica ms comn para reducir los accesos a disco es el bloque cach o buffer cach: Se utiliza el trmino ocultamiento para esta tcnica (del francs cacher: ocultar). Un cach es una coleccin de bloques que pertenecen desde el punto de vista lgico al disco, pero que se mantienen en memoria por razones de rendimiento.
Uno de los algoritmos ms comunes para la administracin del cach es el siguiente: Verificar todas las solicitudes de lectura para saber si el bloque solicitado se encuentra en el cach. En caso afirmativo, se satisface la solicitud sin un acceso a disco. En caso negativo, se lee para que ingrese al cach y luego se copia al lugar donde se necesite. Cuando hay que cargar un bloque en un cach totalmente ocupado: Hay que eliminar algn bloque y volverlo a escribir en el disco en caso de que haya sido modificado luego de haberlo trado del disco. Se plantea una situacin muy parecida a la paginacin y se resuelve con algoritmos similares.
Se debe considerar la posibilidad de una falla total del sistema y su impacto en la consistencia del sistema de archivos: Si un bloque crtico, como un bloque de un nodo-i, se lee en el cach y se modifica, sin volverse a escribir en el disco, 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, como un bloque parcialmente ocupado que se est escribiendo, deberan permanecer un largo tiempo. 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, debe escribirse en el disco de inmediato: Se reduce la probabilidad de que una falla total del sistema haga naufragar al sistema de archivos. Se debe elegir con cuidado el orden de escritura de los bloques crticos.
203
No es recomendable mantener los bloques de datos en el cach durante mucho tiempo antes de rescribirlos.
La solucin de algunos S. O. consiste en tener una llamada al sistema que fuerza una actualizacin general a intervalos regulares de algunos segundos (por ej. 30). Otra solucin consiste en escribir los bloques modificados (del cach) al disco, tan pronto como haya sido escrito (el cach): Se dice que se trata de cachs de escritura. Requiere ms e / s que otros tipos de cachs.
Una tcnica importante para aumentar el rendimiento de un sistema de archivos es la reduccin de la cantidad de movimientos del brazo del disco (mecanismo de acceso - Figura 8.8): Se deben colocar los bloques que probablemente tengan un acceso secuencial, prximos entre s, preferentemente en el mismo cilindro. Los nodos-i deben estar a mitad del disco y no al principio, reduciendo a la mitad el tiempo promedio de bsqueda entre el nodo-i y el primer bloque del archivo.
Figura 8.8 (a) Nodos-i colocados al principio del disco, implica largas bsquedas; se puede mejorar colocando los nodos-i a la mitad del disco, esto reduce a la mitad el tiempo promedio de bsqueda. (b) Disco dividido en grupos de cilindros, cada uno con sus propios bloques y nodos-i.
204
SISTEMAS OPERATIVOS
8.5. SEGURIDAD
Los sistemas de archivos generalmente contienen informacin muy valiosa para sus usuarios, razn por la que los sistemas de archivos deben protegerla.
Algunas de las causas ms comunes de la prdida de datos son: Actos y hechos diversos, como incendios, inundaciones, terremotos, guerras, revoluciones, roedores, etc. Errores de hardware o de software, como fallas en la cpu, discos o cintas ilegibles, errores de telecomunicacin, errores en los programas, etc. Errores humanos, por ej., entrada incorrecta de datos, mal montaje de cintas o discos, ejecucin incorrecta de programas, prdida de cintas o discos, etc.
La mayora de estas causas se pueden enfrentar con el mantenimiento de los respaldos (back-ups) adecuados; debera haber copias en un lugar alejado de los datos originales. Respecto del problema de los intrusos, se los puede clasificar como: Pasivos: solo desean leer archivos que no estn autorizados a leer. Activos: desean hacer cambios no autorizados a los datos.
Hay que tener en cuenta el tipo de intrusos contra los que se desea tener proteccin. Hay que ser consciente de que la cantidad de esfuerzo que se pone en la seguridad y la proteccin depende claramente de quin se piensa sea el enemigo.
Algunos tipos de intrusos son los siguientes: Curiosidad casual de usuarios no tcnicos. Conocidos (tcnicamente capacitados) husmeando. Intentos deliberados por hacer dinero. Espionaje comercial o militar.
Otro aspecto del problema de la seguridad es la privaca: Proteccin de las personas respecto del mal uso de la informacin en contra de uno mismo. Implica aspectos legales y morales.
Tambin debe sealarse la posibilidad del ataque del caballo de Troya: Modificar un programa normal para que haga cosas adversas adems de su funcin usual. Arreglar las cosas para que la vctima utilice la versin modificada.
Adems 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 mayora de los sistemas Sun y Vax de Internet (fue descubierto y condenado). Constaba de un programa arrancador y del gusano propiamente dicho. Utilizaba fallas se seguridad del Unix y de los programas Finger y Sendmail de Internet.
Una forma de probar la seguridad de un sistema es contratar un grupo de expertos en seguridad, conocido como el equipo tigre o equipo de penetracin, cuyo objetivo es intentar penetrar el sistema de seguridad para descubrir sus falencias y proponer soluciones.
206 SISTEMAS OPERATIVOS
Otro aspecto importante de la seguridad consiste en no subestimar los problemas que puede causar el personal.
8.5.2. VIRUS
Los virus computacionales: Constituyen una categora especial de ataque. Son un enorme problema para muchos usuarios. Son fragmentos de programas que se aaden a programas legtimos con la intencin de infectar a otros. Un virus difiere de un gusano en lo siguiente: Un virus est a cuestas de un programa existente. Un gusano es un programa completo en s mismo. Los virus y los gusanos intentan diseminarse y pueden crear un dao severo. Generalmente se propagan a travs de copias ilegtimas de programas. Comnmente los virus se ejecutan e intentan reproducirse cada vez que se ejecuta el programa que los aloja. Frecuentemente los problemas con los virus son ms fciles de evitar que de curar: Utilizar software original adquirido en comercios respetables. No utilizar copias piratas. Efectuar controles rigurosos y frecuentes con programas antivirus actualizados. Trabajar con metodologa y disciplina rigurosa en el intercambio de discos y en las copias a travs de redes de comunicacin de datos.
- Determinar que el acceso est permitido. - Abandonar esta informacin para su uso posterior. El sistema tampoco debe: Verificar el permiso al abrir un archivo y no despus de abrirlo, pues un acceso habilitado permanecera como vlido aunque haya cambiado la proteccin del archivo.
Dar a cada proceso el mnimo privilegio posible, lo que implica un esquema de proteccin de grano fino. El mecanismo de proteccin debe ser simple, uniforme e integrado hasta las capas ms bajas del sistema: Dotar de seguridad a un sistema inseguro es casi imposible. La seguridad no es una caracterstica que se pueda aadir fcilmente.
El esquema de seguridad debe ser sicolgicamente aceptable: Los usuarios no deben sentir que la proteccin de sus archivos les implica demasiado trabajo: Podran dejar de proteger sus archivos. Se quejaran en caso de problemas. No aceptaran fcilmente su propia culpa.
Un derecho es el permiso para realizar alguna de las operaciones. Es posible que un objeto se encuentre en varios dominios con distintos derechos en cada dominio. Un proceso se ejecuta en alguno de los dominios de proteccin:
208 SISTEMAS OPERATIVOS
Existe una coleccin de objetos a los que puede tener acceso. Cada objeto tiene cierto conjunto de derechos.
Los procesos pueden alternar entre los dominios durante la ejecucin. Una llamada al S. O. provoca una alternancia de dominio.
Figura 8.10 Un proceso en MULTICS con cuatro anillos. Cada anillo es un dominio de proteccin independiente
Una forma en la que el S. O. lleva un registro de los objetos que pertenecen a cada dominio es mediante una matriz (ver Figura 8.11): Los renglones son los dominios. Las columnas son los objetos.
209
Cada elemento de la matriz contiene los derechos correspondientes al objeto en ese dominio, por ej.: leer, escribir, ejecutar.
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. La forma de dicho acceso (ej: lectura (r), grabacin (w), ejecucin (x)).
Una forma de implementar las ACL consiste en: Asignar tres bits (r, w, x) para cada archivo, para: El propietario, el grupo del propietario y los dems usuarios. Permitir que el propietario de cada objeto pueda modificar su ACL en cualquier momento: Permite prohibir accesos antes permitidos.
210
SISTEMAS OPERATIVOS
Resumen
Frecuentemente conviene que los archivos compartidos aparezcan simultneamente en distintos directorios de distintos usuarios. Es necesario proteger la informacin alojada en el sistema de archivos, efectuando los resguardos correspondientes. Los sistemas de archivos generalmente contienen informacin muy valiosa para sus usuarios, razn por la que los sistemas de archivos deben protegerla.
Indicadores de logro
El lector explica los fundamentos de la confiabilidad, seguridad y mecanismos de proteccin.
Bibliografa Recomendada
Deitel M. Introduccin a los Sistemas Operativos. Espaa: Addison Wesley Iberoamericana, Segunda Edicin; 1998. Luis la Red Martnez D. Sistemas Operativos Modernos. Argentina: Universidad Nacional Del Nordeste U.N.N.E.; 2001. Tanenbaum A. Sistemas Operativos Modernos. Mexico: Pearson Educacin, Segunda Edicin; 2003.
Actividad
Analice los aspectos tericos adicionales sobre el Sistema de Archivos.
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 proteccin.
212
SISTEMAS OPERATIVOS