Sistemas Operativos

UNIVERSIDAD PERUANA LOS ANDES
FACULTAD DE INGENIERA
SISTEMAS OPERATIVOS
MG. ABRAHAM ESTEBAN GAMARRA MORENO
CONTENIDO
CONTENIDO ..........................................................................................................................................2 PRESENTACION ...................................................................................................................................7 UNIDAD ACADEMICA 1 ......................................................................................................................9 INTRODUCCION A LOS SISTEMAS OPERATIVOS ......................................................................9 1.1. QU ES UN SISTEMA OPERATIVO? ...............................................................................9 1.2. HISTORIA DE LOS SISTEMAS OPERATIVOS: GENERACIONES ...............................12 1.2.1. 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
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
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.
Mg. Abraham Gamarra Moreno
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
Presentar al usuario una interfaz o mquina virtual.
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).
Figura 1.1. Recursos administrados por el S.O.
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
Recuperarse de los errores.
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.
1.2. HISTORIA DE GENERACIONES
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.
1.2.1. GENERACIN CERO (DCADA DE 1940):

Carencia total de S. O. Completo acceso al lenguaje de mquina.
12
SISTEMAS OPERATIVOS
1.2.2. PRIMERA GENERACIN CONEXIONES

Carencia de S. O.
(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.
1.2.4. TERCERA GENERACIN (1965-1980): CIRCUITOS INTEGRADOS Y MULTIPROGRAMACIN

Difusin de la multiprogramacin: o Particin de la memoria en porciones, con trabajos distintos en cada una de ellas. o Aprovechamiento del tiempo de espera consecuencia de operaciones de e / s, para utilizar la CPU para otros procesos. Proteccin por hardware del contenido de cada particin de memoria. Aparicin de tcnicas de spooling: o Simultaneous Peripheral Operation On Line: operacin simultnea y en lnea de perifricos.
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.
1.2.5. CUARTA GENERACIN (1980-1990): COMPUTADORAS PERSONALES:

Aparicin de software amigable con el usuario, destinado a usuarios no profesionales y con una interfase grfica muy desarrollada. Desarrollo de sistemas operativos de red y sistemas operativos distribuidos. Sistemas operativos de red: o Los usuarios estn conscientes de la existencia de varias computadoras conectadas. o Cada mquina ejecuta su propio S. O. local. o Son similares a los S. O. de un solo procesador pero con el agregado de controlador de interfaz de la red, su software de bajo nivel y el software para conexin y acceso a archivos remotos, etc. Sistemas operativos distribuidos: o Aparece ante los usuarios como un S. O. de un solo procesador, an cuando de soporte a varios procesadores.
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. CONCEPTOS DE LOS SISTEMAS OPERATIVOS

La interfaz entre el S. O. y los programas del usuario se define como el conjunto de instrucciones ampliadas que proporciona el S. O. y son las llamadas al sistema:2 Crean, eliminan y utilizan objetos del software controlados por el S. O.: Los ms importantes son procesos y archivos.
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
Un proceso (suspendido) consta de:
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.
1.3.3. LLAMADAS AL SISTEMA:

Permiten a los programas comunicarse con el S. O. y solicitarle servicios. A cada llamada le corresponde un procedimiento: o Pone los parmetros de la llamada en un lugar especco para luego ejecutar una instruccin tipo trap de llamada a procedimiento protegido para iniciar el S. O. o Luego de trap el S. O. recupera el control , examina los parmetros y si son vlidos ejecuta el trabajo solicitado. o Luego de terminar, el S. O. coloca un cdigo de estado en un registro indicando si tuvo xito o fracaso y ejecuta una instruccin del tipo return from trap para regresar el control al procedimiento. o El procedimiento regresa al programa llamador con un cdigo de estado como un valor de funcin; dentro de los parmetros pueden regresar valores adicionales.
1.4. ESTRUCTURA DE LOS SISTEMAS OPERATIVOS

Se considera la organizacin interna de los S. O. y conforme a ella se los clasifica de la siguiente manera, destacndose sus principales caractersticas:
1.4.1. SISTEMAS MONOLTICOS:

Es muy comn: no existe estructura propiamente dicha o es mnima. El S. O. es una coleccin de procedimientos que se pueden llamar entre s (ver Figura 1.22).
Figura 1.2. Modelo de estructura simple para un sistema monoltico.
Cada procedimiento tiene una interfaz bien definida en trminos de parmetros y resultados.
Figura 1.3. Forma de llamada al sistema en un sistema monoltico.
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.
1.4.2. SISTEMAS CON CAPAS:

Es una generalizacin del modelo de estructura simple para un sistema monoltico. Consiste en organizar el s. o. como una jerarqua de capas, cada una construida sobre la inmediata inferior.
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
Tabla 1.1. Estructura del S.O. en capas THE
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.
1.4.3. MQUINAS VIRTUALES:

Se separan totalmente las funciones de multiprogramacin y de mquina extendida. Existe un elemento central llamado monitor de la mquina virtual que: Se ejecuta en el hardware. Realiza la multiprogramacin. Proporciona varias mquinas virtuales a la capa superior.
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.
Figura 1.4. La estructura de VM-370 con CMS.
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.
1.4.4. MODELO CLIENTE - SERVIDOR

Una tendencia en los S. O. modernos es la de explotar la idea de mover el cdigo a capas superiores y mantener un ncleo mnimo, de manera similar al VM/370. Implantar la mayora de las funciones del S. O. en los procesos del usuario. La Figura 1.5 muestra la solicitud de un servicio (por ej.: lectura de un bloque de cierto archivo) segn el modelo cliente - servidor2. El proceso del usuario (proceso cliente) enva la solicitud a un proceso servidor: Realiza el trabajo y regresa la respuesta. El ncleo controla la comunicacin entre los clientes y los servidores.
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
Figura 1.5. El modelo cliente servidor.
Se adapta para su uso en los sistemas distribuidos: (ver Figura 1.6).
Figura 1.6. El modelo cliente servidor en un sistema distribuido.
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.
1.5. MS ESTRUCTURAS DE SISTEMAS OPERATIVOS

El sistema operativo se divide lgicamente en pequeos mdulos y se crea una interfase bien definida para estos mdulos. Cada uno de estos mdulos o
piezas deben tener su funcin, sus inputs y outputs cuidadosamente definidos.
1.5.1. EL SISTEMA OPERATIVOS DOS

El sistema operativos DOS no cuenta con una buena divisin de estos mdulos ya que no se encuentra bien particionado permitiendo el acceso directo de los programas de aplicacin a rutinas bsicas de E/S para grabar directamente en el display o en los discos, por ello el sistema es vulnerable a estos programas los que pueden provocar el crash del sistema. La estructura de este sistema puede verse en la Figura 1.7.
Figura 1.7. Estructura del sistema operativo DOS.
1.5.2. EL SISTEMA OPERATIVO UNIX

Otro ejemplo de un sistema operativo que no fue bien construido lo constituye el UNIX. Este sistema se encuentra divido en dos partes una de ellas comprende los programas del sistema y la otra el kernel. El kernel se encuentra divido en drivers de dispositivos y en las interfases (ver Figura 1.8). Lamentablemente este kernel combina demasiada funcionalidad en un solo nivel. Las llamadas al sistema definen la interfase del programador al UNIX. El conjunto de programas de sistema usualmente disponibles definen la interfase del usuario. Ambas definen el contexto al cual el kernel debe dar soporte.
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.
1.6. EL SISTEMA OPERATIVO OS/2

El OS/2 un descendiente directo del MS-DOS fue creado para superar las limitaciones de este ltimo. El OS/2 provee multitasking y operacin en modo dual como as tambin otras nuevas mejoras. En contraposicin a la estructura del MS-DOS la estructura del OS/2 se encuentra diseada en capas que por ejemplo, no permiten el acceso directo del usuario a facilidades de bajo nivel lo que otorga un mayor control al sistema operativo sobre el hardware y un mayor conocimiento de qu recursos est utilizando cada programa de usuario. En la Figura 1.9 podemos ver la estructura en capas del sistema operativo OS/2.
Figura 1.8. Estructura del UNIX.
24
SISTEMAS OPERATIVOS
Figura 1.9. Estructura de capas del OS/2.
1.6.1. ARQUITECTURA DE WINDOWS NT

La familia de los sistemas operativos Windows NT de Microsoft est constituida por versiones como Windows Vista, Windows Server 2003, Windows XP, Windows 2000 y Windows NT. Todos tienen multitarea apropiativa y son sistemas operativos reentrantes que han sido diseados para trabajar tanto con ordenadores con un slo procesador como ordenadores de multiprocesamiento simtrico que en ingls es el Symmetrical Multi Processor o SMP. Para procesar las peticiones de entrada/salida (en ingls Input/Output, I/O) acude a una direccin de paquetes de E/S que utiliza peticiones (IRPs) y E/S asncrona. A partir de Windows XP, Microsoft comenz a desarrollar sistemas operativos que soportaban 64-bits. Antes sus sistemas operativos estaban basados en un modelo de 32-bits. La arquitectura de Windows NT es altamente modular y se basa en dos capas principales (Figura 1.10): Modo usuario: Cuyos programas y subsistemas estn limitados a los recursos del sistema a los que tienen acceso. Modo ncleo: Tiene acceso total a la memoria del sistema y los dispositivos externos. Los ncleos de los sistemas operativos de esta lnea son todos conocidos como ncleos hbridos, aunque hay que aclarar que este trmino est en discusin ya que este ncleo es esencialmente un ncleo monoltico que est estructurado al estilo de un microncleo. La arquitectura dentro del modo ncleo se compone de lo siguiente: Un ncleo hbrido. Una Capa de Abstraccin de Hardware (HAL).
25
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
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.
Auto evaluacin formativa

Supongamos que usted a sido designado para implementar un sistema operativo, cul sera la arquitectura que usted recomendara?; justifique su respuesta.
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.
2.1. CONCEPTOS DE PLANIFICACIN

El objetivo de la multiprogramacin es que en todo momento se ejecute un proceso para maximizar la utilizacin de la UCP (Unidad Central de Proceso). En un sistema monoprocesador nunca habr ms de un proceso en ejecucin. Si hay ms procesos, tendrn que esperar a que la UCP est libre y pueda volver a planificarse. El concepto de multiprogramacin es bastante sencillo: un proceso se ejecuta hasta que tenga que esperar, generalmente a que termine una solicitud de E/S. En un sistema de computacin sencillo, la UCP permanecera inactiva; todo este tiempo de espera se desperdicia sin efectuar ninguna actividad til. Con la multiprogramacin tratamos de emplear productivamente este tiempo. Varios procesos se conservan en memoria a la vez, y cuando uno de ellos tiene que esperar, el sistema operativo le quita la UCP al proceso y se la da a otro; este modelo contina. Cada vez que un proceso tiene que esperar, otro puede utilizar la UCP. Los beneficios de la multiprogramacin son un aumento de la utilizacin de la UCP y una mayor productividad. La productividad es la cantidad de trabajo
3
Silberschatz A, Peterson J, Galvin P. Sistemas Operativos. USA: Editorial Addison Wesley Iberoamericana, 3ra 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
Figura 2.2. Ejecucin de procesos sin multiprogramacin
Figura 2.3. Ejecucin de procesos con multiprogramacin.
Este ejemplo es un caso extremo y es poco probable que ocurra en la prctica, pero ilustra el concepto de la multiprogramacin.
2.1.1. COLAS DE PLANIFICACIN

Conforme los procesos entran en el sistema, se colocan en una cola de trabajos formada por todos los procesos que residen en almacenamiento secundario esperando la asignacin de la memoria principal. Los procesos que residen en la memoria principal y que estn listos y esperando su ejecucin se mantienen en una lista llamada cola de procesos listos; esta lista es generalmente una lista ligada. Un encabezado de la cola de procesos listos contendr apuntadores al primer y ltimo PCB de la lista. Cada PCB tiene un campo apuntador que indica el siguiente proceso en la cola de procesos listos.
Tambin hay otras colas en el sistema. Cuando la UCP se asigna a un proceso, se ejecuta durante un tiempo y despus termina o espera a que ocurra un suceso determinado, como la conclusin de una solicitud de E/S. En este caso, la E/S puede estar dirigida a una unidad de cinta dedicada o a un dispositivo compartido, por ejemplo un disco. Puesto que en el sistema hay varios procesos, el disco puede estar ocupado con la solicitud de E/S de otro proceso, por lo que el proceso tendr que esperar al disco. La lista de procesos que espera a un dispositivo de E/S determinado se denomina cola del dispositivo, y cada dispositivo tiene su propia cola (
Figura 2.4). Si se trata de un dispositivo dedicado, como una unidad de cinta, la cola del dispositivo nunca tendr 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.
Figura 2.4. Cola de procesos listos y varias colas de dispositivo de E/S.
Un proceso nuevo se coloca inicialmente en la cola de procesos listos y all espera hasta que se selecciona para su 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.
Figura 2.5. Representacin de la planificacin de procesos mediante un diagrama de colas.
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
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.
Figura 2.6. Adicin de la planificacin a mediano plazo al diagrama de colas.
2.2. PLANIFICACIN DE LA UCP

La planificacin es una funcin fundamental del sistema operativo. Casi todos los recursos de un computador se planifican antes de usarse. Por supuesto, la UCP es uno de los principales recursos del computador, de modo que su planificacin es parte medular del diseo de los sistemas operativos.
2.2.1. CICLO DE RFAGAS DE UCP Y DE E/S

El xito de la planificacin de la UCP depende de la siguiente propiedad observada de los procesos: la ejecucin de un proceso consiste en un ciclo de ejecucin de la UCP y espera de E/S, y los procesos se alternan entre estos dos estados. La ejecucin del proceso se inicia con una rfaga de UCP; a sta le siguen una rfaga de E/S, otra rfaga de UCP, una ms de E/S, etc. Finalmente, la ltima rfaga de UCP terminar con una solicitud al sistema para que concluya la ejecucin, en vez de otra rfaga de E/S (Figura 2.7). Las duraciones de estas rfagas de UCP se han medido, y, aunque varan considerablemente de un proceso a otro y entre computadores, tienden a presentar una curva de frecuencias similar a la que se muestra en la Figura 2.8. Generalmente la curva se caracteriza como exponencial o hiperexponencial. Hay un gran nmero de rfagas de UCP de corta duracin y un pequeo nmero de rfagas de larga duracin. Un programa limitado por E/S normalmente tendr muchas rfagas de UCP breves, mientras que un programa limitado por la UCP tendr pocas rfagas de muy larga duracin. Esta distribucin puede ser muy importante al seleccionar un algoritmo adecuado para la planificacin de la UCP.
35
Figura 2.7. Secuencia alterna de rfagas de UCP y E/S.
36
SISTEMAS OPERATIVOS
Figura 2.8. Histograma de tiempos de rfaga de la UCP.
2.2.2. PLANIFICADOR DE LA UCP

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

Las decisiones de planificacin de la UCP pueden efectuarse en una de las cuatro circunstancias siguientes:
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.
2.2.4. CAMBIO DE CONTEXTO

Para cambiar la UCP a otro proceso se requiere guardar el estado del proceso anterior y cargar el estado guardado para el nuevo proceso. Esta tarea se conoce como cambio de contexto. El tiempo de cambio de contexto es un puro gasto adicional, y vara de una mquina a otra, dependiendo de la velocidad de la memoria, del nmero de registros y de la existencia de instrucciones especiales (como una sola instruccin para cargar o almacenar todos los registros). Tpicamente se encuentra en el intervalo de uno a cien microsegundos. Los tiempos de cambio de contexto dependen en gran medida del apoyo del hardware; por ejemplo, algunos procesadores ofrecen varios conjuntos de registros, y un cambio de contexto implica nicamente cambiar el apuntador al conjunto actual de registros. Por supuesto, si hay ms procesos activos que conjuntos de registros, el sistema copia los datos usando la memoria, como se mencion antes. Adems, cuanto ms complejo sea el sistema operativo, ms trabajo hay que realizar durante un cambio de contexto. Como veremos en captulos posteriores, las tcnicas avanzadas de administracin de memoria pueden requerir que con cada contexto se cambien otros datos adicionales.
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.
2.3. ALGORITMOS DE PLANIFICACIN

La planificacin de la UCP tiene que ver con el problema de decidir a cul de los procesos que estn en la cola de procesos listos se le asignar la UCP. Se cuenta con varios algoritmos de planificacin de la UCP, algunos de los cuales describiremos en esta seccin. Los distintos algoritmos de planificacin tienen propiedades diferentes y pueden favorecer a un tipo de proceso en lugar de a otro, as que al elegir qu algoritmo se aplicar en una situacin determinada debemos considerar las propiedades de los diversos algoritmos. Para comparar los algoritmos de planificacin de la UCP se han propuesto varios criterios, y las caractersticas que se utilicen para la comparacin pueden representar diferencias considerables en la determinacin del mejor algoritmo; los criterios que se emplean incluyen los siguientes: Utilizacin de la UCP. Queremos que la UCP se mantenga tan ocupada como sea posible. Su utilizacin puede variar del O al 100% y en un sistema real debe fluctuar entre el 40% (para un sistema con poca carga) y el 90% (para un sistema con gran carga de trabajo). Productividad. Si la UCP se encuentra ocupada, se est efectuando algn trabajo. Una medida del trabajo es el nmero de procesos que se completan por unidad de tiempo, llamada productividad. Para procesos largos, esta tasa puede ser un proceso por hora; para transacciones ms breves, la productividad puede ser de 10 procesos por segundo. Tiempo de retorno. Desde el punto de vista de un proceso en particular, el criterio ms importante es cunto tiempo tarda en ejecutarse ese proceso. El intervalo entre el momento de ofrecerlo hasta el momento en que termina es el tiempo de retorno, es decir, la suma de los periodos transcu39
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
2.3.1. PLANIFICACIN SERVICIO POR ORDEN DE LLEGADA

Definitivamente, el algoritmo ms sencillo para la planificacin de la UCP es el algoritmo servicio por orden de llegada (FCFS, first -come, first-served). Con este esquema, el proceso que primero solicita la UCP es el primero al que se le asigna. La poltica FCFS se implanta fcilmente con una cola FIFO: cuando un proceso entra en la cola de procesos listos, su PCB se enlaza al final de la cola; cuando la UCP est libre se asigna el proceso colocado al inicio de la cola de procesos listos, y entonces el proceso en ejecucin se elimina de esa misma cola. El cdigo para la planificacin FCFS es sencillo de escribir y comprender.En la poltica FCFS el tiempo promedio de espera es bastante largo, sin embargo. Considere el siguiente conjunto de procesos que llegan en el instante O, donde la duracin de la rfaga de uci se expresa en milisegundos:
Proceso Duracin de la rfaga P1 P2 P3 24 3 3
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.
2.3.2. PLANIFICACIN PRIMERO EL TRABAJO MS BREVE

Un enfoque distinto para la planificacin de la UCP es el algoritmo primero el trabajo ms breve (SJF, shortest-job-first). (No empleamos el trmino primero el proceso ms breve porque la mayora de las personas y los textos se refieren a este tipo de disciplina de planificacin como primero el trabajo ms breve.) Este algoritmo asocia a cada proceso la longitud de su siguiente rfaga de UCP. Cuando la UCP est disponible, se le asigna al proceso que tiene la rfaga siguiente de UCP menor. Si dos procesos tienen la misma longitud para la siguiente rfaga de UCP se utiliza la planificacin FCFS para romper el empate. Como ejemplo, considere el siguiente conjunto de procesos, donde la longitud de rfaga de UCP se presenta en milisegundos:
Proceso Duracin de la rfaga P1 P2 P3 P4 6 8 7 3
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
Figura 2.9. Comprobacin de que el algoritmo de planificacin SJF es ptimo.
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.
Figura 2.10 Prediccin de la siguiente rfaga de UCP utilizando un promedio exponencial.
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.
2.3.3. PLANIFICACIN POR PRIORIDADES

El algoritmo SJF es un caso especial del algoritmo general para la planificacin por prioridades. Se asocia una prioridad a cada proceso y la UCP se asigna al de mayor prioridad. Los procesos con igual prioridad se planifican en orden FCFS. Un algoritmo SJF es sencillamente un algoritmo de prioridades, donde la prioridad (p) es la inversa de la siguiente rfaga (prevista) de UCP (): p=1/. Si la rfaga de UCP es mayor, la prioridad ser menor y viceversa. Observe que analizamos la planificacin en trminos de una alta prioridad y una baja prioridad. Las prioridades generalmente corresponden a un intervalo fijo de nmeros, como 0 a 7 o 0 a 4095. Sin embargo, no existe ningn con46 SISTEMAS OPERATIVOS
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
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.
2.3.4. PLANIFICACIN CIRCULAR

El algoritmo de planificacin circular (RR, round-robin) est diseado especialmente para sistemas de tiempo compartido. Se define una pequea unidad de tiempo, llamada cuanto de tiempo o porcin de tiempo, que generalmente vara entre 10 y 100 milisegundos. La cola de procesos listos se trata como una cola circular, el planificador de la UCP la recorre asignando la UCP a cada proceso por un intervalo de hasta un cuanto de tiempo. Para poner en prctica la planificacin mantenemos la cola de procesos listos como una cola primero que entra, primero que sale (FIF0). Los nuevos procesos se agregan al final de la cola de procesos listos. El planificador de la UCP toma el primer proceso de la cola, programa un cronmetro para que interrumpa despus de un cuanto de tiempo y despacha el proceso. Entonces suceder una de estas dos cosas: el proceso puede tener una rfaga de UCP menor que un cuanto de tiempo, en cuyo caso el proceso liberar voluntariamente a la UCP y el planificador continuar con el siguiente proceso de la cola de procesos listos. Por otra parte, si la rfaga de UCP del pro ceso
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).
Figura 2.11 Un cuanto de tiempo menor incrementa el nmero de cambios de contexto.
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.
Figura 2.12 El tiempo de retorno promedio vara con el cuanto de tiempo.
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
que el 80% de las rfagas de UCP deben ser menores que el cuanto de tiempo.
2.3.5. PLANIFICACIN DE COLAS DE MLTIPLES NIVELES

Se ha creado otra clase de algoritmos de planificacin para aquellas situaciones donde los procesos se pueden clasificar fcilmente en distintos grupos. Por ejemplo, una divisin habitual consiste en diferenciar los procesos de primer plano (interactivos) de los procesos de segundo plano (por lotes). Estos dos tipos de procesos tienen requisitos de tiempo de respuesta bastante diferentes, por que pueden presentar distintas necesidades de planificacin. Adems, los procesos de primer plano pueden tener una prioridad superior (definida externamente) a la de los procesos de segundo plano.
Un algoritmo de planificacin de colas de mltiples niveles divide la cola de procesos listos en diversas colas (
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
edicin entrara en la cola de procesos listos durante la ejecucin de un proceso por lotes, este ltimo se expulsara.
Figura 2.13 Planificacin de colas de mltiples niveles.
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.
2.3.6. PLANIFICACIN DE COLAS DE MLTIPLES NIVELES CON REALIMENTACIN

En un algoritmo para la planificacin de colas de mltiples niveles normalmente los procesos se asignan de manera permanente a una cola al entrar al sistema y no se mueven a otras colas. Por ejemplo, si hay colas diferentes para los procesos de primer y segundo planos, no cambian de una cola a otra, ya que los procesos no modifican su naturaleza de primer o segundo planos. Esta configuracin tiene la ventaja de provocar poco gasto de procesamiento adicional durante la planificacin, pero es inflexible.
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.
Figura 2.14 Colas de mltiples niveles con realimentacin.
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.
2.4. PLANIFICACIN DE PROCESADORES MLTIPLES

Hasta ahora nuestro anlisis se ha centrado en los problemas de la planificacin de la UCP en un sistema con un solo procesador. Si hay mltiples UCP, el problema de planificacin se vuelve ms complejo. Se han probado varias posibilidades y, como hemos visto en la planificacin de la UCP con un solo procesador, no hay una solucin nica que sea la mejor. A continuacin analizaremos brevemente algunos de los asuntos relacionados con la planificacin de procesadores mltiples. Uno de los factores principales es el tipo de procesadores que entran en juego, los cuales pueden ser idnticos (un sistema homogneo) o distintos (un
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.
El lector utiliza los algoritmos de planificacin de la UCP.
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.

Resuelva los siguientes problemas: PROBLEMA UNO Considere el siguiente conjunto de procesos, cuyas longitudes de rfaga de UCP se expresan en milisegundos:
Proceso P1 P2 P3 P4 P5 Duracin de la rfaga 10 1 2 1 5 Prioridad 3 1 3 4 2
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)?
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.
PROBLEMA CUATRO Se tiene el siguiente conjunto de procesos:

Proceso P1 P2 P3 P4 P5 Duracin de la rfaga 8 2 5 4 9 Prioridad 3 2 3 0 1 Instante de llegada 0 1 3 4 6
Nota: Usar la columna prioridad sola para la 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
3.1.2. ESTADOS DE UN PROCESO

Durante su existencia, un proceso pasa por una serie de estados discretos. Varias circunstancias pueden hacer que un proceso cambie de estado. Se dice que un programa se est ejecutando (es decir, est en estado de ejecucin), si tiene en ese momento el CPU. Un proceso se dice que est listo (es decir, en estado de listo), cuando podra usar un CPU, si hubiera uno di sponible. Se dice que un proceso est bloqueado (es decir, en estado bloqueado), si espera que ocurra algo (como la terminacin de una entrada / salida) para poder ponerse en marcha. Por simplicidad consideraremos un solo CPU, aun cuando hacer la extensin hacia el multiprocesamiento no es difcil. Slo puede estar corriendo un proceso al mismo tiempo, pero puede haber varios procesos listos y varios ms bloqueados. Por tanto, se est ablece una lista de listos para los procesos listos, y una lista de bloqueados, para los bloqueados. La lista de listos se mantiene en orden prioritario, para que el siguiente proceso que reciba el CPU sea el primer proceso de la lista. La l ista de bloqueados no est ordenada, los procesos no se desbloquean (o sea, no quedan listos) en orden prioritario; en lugar de esto, los procesos se desbloquean en el orden en que tienen lugar los eventos que estn esperando.
3.1.3. TRANSICIONES DE ESTADO DE LOS PROCESOS

Cuando un trabajo es admitido en el sistema, se crea un proceso equivalente, y es insertado en la ltima parte de la lista de listos. El proceso se va moviendo gradualmente hacia la cabeza de esta relacin a medida que se completan los procesos anteriore s. Cuando el proceso llega a la cabeza de la lista, y cuando el CPU se encuentre disponible, el proceso recibe el CPU y se dice que hace una transicin de estado, del estado listo al estado de ejecucin (Figura 3.1). La asignacin del CPU al primer proceso de la lista de listos es llamada despacho, y es ejecutado por la entidad del sistema llamado despachador. Mientras el proceso tenga el CPU, se dice que est en ejecucin. Para prevenir que cualquier proceso monopolice el sistema, ya sea de manera accidental o maliciosamente, el sistema operativo ajusta un reloj de interrupcin del hardware para permit ir al usuario ejecutar su proceso durante un intervalo de tiempo especfico o cuantum. Si el proceso no abandona voluntariamente el CPU antes de que expire el intervalo, el reloj genera una interrupcin, haciendo que el sistema operativo recupere el control. El sistema operativo, entonces, hace que el proceso que anteriormente se hallaba en estado de ejecucin pase al de listo, y hace que el primer proceso de la lista de listos pase al estado de ejecucin.
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.
Figura 3.1. Transiciones de Estado de los Procesos.
3.1.4. EL BLOQUE DE CONTROL DE PROCESOS

La manifestacin de un proceso en un sistema operativo es un bloque de control de proceso (PCB = Process Control Block). El PCB es una estructura de datos que contiene cierta informacin importante acerca del proceso, incluyendo: estado actual del proceso identificacin nica del proceso
63
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.
3.1.5. OPERACIONES SOBRE PROCESOS

Los sistemas que administran los procesos deben ser capaces de realizar ciertas operaciones sobre los procesos. Estos incluyen: crear un proceso destruir un proceso suspender un proceso reanudar un proceso cambiar la prioridad de un proceso bloquear un proceso despertar un proceso despachar un proceso.
La creacin de un proceso implica varias operaciones, incluyendo:

64
dar nombre al proceso insertar un proceso en la lista del sistema de procesos conocidos determinar la prioridad inicial del proceso crear el bloque de control de proceso asignar los recursos iniciales del proceso.
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.
Figura 3.2. Jerarqua de Procesos.
3.1.6. SUSPENSIN Y REANUDACIN

En la seccin anterior se introdujeron las nociones de procesos suspendidos y reanudados. Estas operaciones son importantes por varias razones:
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.
3.1.7. EL NCLEO DEL SISTEMA OPERATIVO

Todas las operaciones que implican procesos son controladas por una porcin del sistema operativo, el cual es llamado su ncleo. El ncleo representa, solamente, una pequea porcin del cdigo de todo el sistema operativo, pero se encuentra entre los cdigos de ms amplio uso. Por esta razn, el ncleo suele permanecer en memoria principal, mientras otras porciones del sistema operativo son transportadas de un lado a otro, entre la memoria principal y la secundaria, segn las necesidades. Una de las funciones ms importantes incluidas en el ncleo es el proceso de interrupciones. En los grandes sistemas de mltiples usuarios hay una corriente constante de interrupciones dirigidas al procesador. La rpida respuesta a estas interrupciones es esencial para mantener bien utilizados los recursos del sistema, y para proveer tiempos de respuesta aceptables a los usuarios interactivos.
66
SISTEMAS OPERATIVOS
Figura 3.3. Transiciones de estado de proceso con suspensin y reanudacin.
3.1.8. RESUMEN DE FUNCIONES DEL NCLEO.

Un ncleo de sistema operativo contiene normalmente el cdigo necesario para la realizacin de las siguientes funciones: Manipulacin de interrupciones. Creacin y destruccin de procesos. Cambios de estados de proceso. Despacho Suspensin y reanudacin de procesos. Sincronizacin de procesos. Comunicacin entre procesos.
67
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.
3.2. PROCESOS CONCURRENTES ASINCRNICOS.

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. El asincronismo es un tpico complejo; aqu se exponen la organizacin y administracin de sistemas que soportan procesos concurrentes asincrnicos. Se presentan muchos problemas importantes de asincronismo. Sus soluciones se presentan como programas concurrentes codificados utilizando el lenguaje Pascal concurrente desarrollado inicialmente por Wirth (Pascal-S), extendido por Ben Ari y modificado en la Universidad de Bradford (UK) por G.L. Davies (Pascal-FC).
3.2.1. PROCESAMIENTO EN PARALELO

A medida que disminuyen tanto el tamao como el precio del hardware de las computadoras se ir produciendo una tendencia hacia el multiprocesamiento y la masificacin del paralelismo. Si ciertas operaciones pueden ser ejecutadas en paralelo de forma lgica, entonces las computadoras con mltiples procesadores las ejecutarn fsicamente en paralelo, aunque en el nivel de paralelismo se den miles o, tal vez, millones de actividades concurrentes. El procesamiento en paralelo es interesante por varias razones. La gente parece ms capaz de centrar su atencin en una sola actividad a la vez que de pensar en paralelo. (Intente leer dos libros al mismo tiempo, leyendo una lnea de un libro, una lnea del otro, la segunda lnea del primero, y as sucesivamente.) Es difcil determinar cules actividades pueden ejecutarse o no en paralelo. Los programas en paralelo son mucho ms difciles de depurar que los programas secuenciales; despus de haber arreglado supuestamente un error, puede resultar imposible reconstruir la secuencia de eventos que han ocacionado el error. Por ello, sera en cierto modo inapropiado asegurar que se ha corregido el error.
Los procesos asincrnicos deben interactuar ocasionalmente entre s, y esas interacciones pueden ser complejas. Aqu se trata varios ejemplos de interaccin de procesos.
3.2.2. UNA ESTRUCTURA PARA INDICAR EL PARALELISMO: COBEGIN/COEND

Son muchas las construcciones de lenguajes de programacin para indicar paralelismo que han aparecido en la literatura. Estas implican pares de proposiciones como las siguientes: Una proposicin indicando que la ejecucin secuencial debe ser dividida entre varias secuencias de ejecucin en paralelo (trayectoria de control). Una proposicin indicando que ciertas secuencias de ejecucin en paralelo estn a punto de producirse y se reanudar la ejecucin secuencial.
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:
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.
3.2.3. EXCLUSIN MUTUA

Considrese un sistema con varias terminales de tiempo compartido. Supngase que los usuarios acaban cada lnea, que teclean al sistema con un retorno de carro. Supngase que se desea supervisar continuamente el nmero total de lneas que los usuarios han introducido al sistema desde el comienzo del da, y que cada terminal est supervisada por un proceso diferente. Cada vez que uno de estos procesos recibe una lnea de la terminal de un usuario incrementa en 1 la variable global compartida NOLINEAS. Considrese lo que pasara si dos procesos intentaran incrementar NOLINEAS simultneamente. Supngase que cada proceso tiene su propia copia del cdigo:
LOAD ADD STORE NOLINEAS 1 NOLINEAS
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)
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.
3.2.4. SECCIONES CRTICAS

La exclusin mutua necesita ser aplicada slo cuando un proceso accesa a datos compartidos; cuando los procesos ejecutan operaciones que no estn en conflicto entre s, debe permitirseles proceder de forma concurrente. Cuando un proceso est accesando a datos compartidos se dice que el proceso se encuentra en su seccin crtica (o regin crtica). Esta claro que para prevenir el tipo de problema experimentado en la seccin anterior debe asegurarse que, cuando un proceso est en su seccin crtica, todos los dems procesos (o al menos aquellos que tengan acceso a los mismos datos compartidos) sean excluidos de sus propias secciones crticas. Mientras un proceso se encuentre en su seccin crtica, los dems procesos pueden continuar su ejecucin fuera de sus secciones crticas. Cuando un proceso abandona su seccin crtica, entonces debe permitrsele proceder a otros procesos que esperan entrar en su propia seccin crtica (si hubiera un proceso en espera). La aplicacin de la exclusin mutua es uno de los problemas clave de la programacin concurrente. Se han diseado muchas soluciones para esto: algunas de software y algunas de hardware, ms de bajo nivel y otras de alto nivel; algunas que requieren de cooperacin voluntaria
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.
3.2.5. PRIMITIVAS DE EXCLUSIN MUTUA

El programa concurrente de la Figura 3.4 implementa correctamente el mecanismo contador de lneas de la seccin anterior. Por simplicidad, trataremos tan slo dos procesos concurrentes en los programas presentados en esta y en las prximas secciones. El manejo de n procesos concurrentes es mucho ms complejo. Las construcciones entraexcluisionmutua y saledeexclusionmutua introducidas en la Figura 3.4 encapsulan el cdigo en cada proceso que accesa la variable compartida NOLINEAS, es decir, estas construcciones demarcan las secciones crticas. Estas operaciones se llaman, a veces, primitivas de exclusin mutua; o sea, que invocan las operaciones ms fundamentales inherentes a la exclusin mutua.
program exclusionmutua;var nolineas: integer; process uno; var lin: integer; begin for lin := 1 to 60 do begin entraexclusionmutua; nolineas := nolineas + 1; saledeexclusionmutuaend end; (* uno *) process dos;var lin: integer; begin for lin := 1 to 40 do begin
entraexclusionmutua; nolineas := nolineas + 1; saledeexclusionmutua end; (* dos *) begin nolineas := 0; cobegin uno; dos coend;end.
end
Figura 3.4. Utilizacin de las primitivas de exclusin mutua.
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.
3.2.6. IMPLEMENTACIN DE LAS PRIMITIVAS DE EXCLUSION MUTUA

Se busca una implementacin de entraexclusionmutua cdigo de entrada a exclusin mutua y saledeexclusionmutua cdigo de salida de exclusin mutua que satisfaga las cuatro restricciones siguientes: La solucin se implementa slo en software en una mquina que no tenga instrucciones de exclusin mutua especialmente diseadas. Cada instruccin de lenguaje de mquina se ejecuta de forma indivisible; es decir, una vez iniciada una instruccin, sta se termina sin interrupcin. Si procesadores mltiples tratan de accesar el mismo dato, debemos suponer que una caracterstica del hardware llamada interbloqueo de almacenamiento resuelve todos los conflictos. El interbloqueo de almacenamie nto secuencializa las referencias en conflicto por medio de procesadores separados, esto es, se hace que las referencias sucedan una a la vez. Se da por supuesto que las referencias separadas son servidas en orden aleatorio.
SISTEMAS OPERATIVOS
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.
3.2.7. ALGORITMOS DE EXCLUSIN MUTUA: DESARROLLO INTUITIVO

El programa pro01 muestra un primer intento de especificar el cdigo para forzar la aplicacin de la exclusin mutua, dentro del contexto de un programa concurrente con dos procesos. La construccin cobegin/coend hace que el proceso uno y el proce so dos operen como procesos concurrentes. Cada uno de estos procesos entra en un ciclo, entrando repetidamente en su seccin crtica. En el programa pro01 entraexclusionmutua se implementa por un ciclo while simple, que mantiene el ciclo hasta que pnumero iguala al nmero del proceso; saledeexclusionmutua se implementa por una instruccin simple que ajusta pnumero al nmero del otro proceso.
program pro01; (* primera version de las primitivas de exclusin mutua *) var pnumero: integer; nolineas: integer; process uno;var lin: integer; begin for lin := 1 to 50 do begin while pnumero = 2 do null; nolineas := nolineas + 1; pnumero := 2end end; (* uno *) process dos;var lin: integer; begin for lin := 1 to 50 do
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.
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
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;
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;
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.
3.2.8. ALGORITMO DE DEKKER

En slo unas cuantas lneas de cdigo, el algoritmo de Dekker (Programa dekker) maneja de manera elegante la exclusin mutua de dos procesos sin necesidad de ninguna instruccin especial de hardware.
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;
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.
A continuacin se tiene la corrida del programa anterior.

Total de lneas = 40
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
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;
dos coend;writeln(Total de Lneas: ,nolineas) end.
La salida del programa es: Total de Lneas: 50
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
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).
El lector es capaz de modificar los programas que contienen los algoritmos de exclusin mutua.
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
Pruebe los programas de los ejemplos anteriores y realice un anlisis de su implementacin.

Encuentre la solucin a los siguientes problemas: PROBLEMA UNO Mencione 2 ejemplos de procesos. Justifique su respuesta. Explique la siguiente figura:
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;
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
4.1.2. ALGORITMO DE LAMPORT

Lamport desarroll una solucin que es particularmente aplicable a los sistemas de procesamiento distribuido. El algoritmo usa un sistema de toma de boleto, como el usado en las panaderas muy concurridas, y ha sido apodado el algoritmo de la panadera de Lamport. Nos centraremos nicamente en los aspectos del algoritmo relacionados con un entorno centralizado. Al entrar en la tienda cada cliente recibe un nmero, y se atiende primero al que tenga el nmero menor. Por desgracia, el algoritmo de la panadera no puede garantizar que dos procesos (clientes) no reciban el mismo nmero. En el caso de un empate, primero se atiende el proceso con el nombre menor. Es decir, si Pi y Pj reciben el mismo nmero y si i < j, entonces primero se servir a Pi. Como los nombres de procesos son nicos y ordenados, nuestro algoritmo es completamente determinista.
Las estructuras de datos comunes son: var
boleto: array[1..nprocs] of integer;

eleccion: array[1..nprocs] of boolean;
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
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
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 *)
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.
A continuacin se muestran los resultados de la corrida del programa. Total de Lneas = 40
4.2.1. SINCRONIZACIN DE PROCESOS CON SEMFOROS

Cuando un proceso emite una peticin de entrada/salida, se bloquea a s mismo para esperar a que termine esta operacin. Algunos procesos deben despertar al proceso bloqueado. Tal interaccin es un ejemplo de un protocolo de bloqueo/despertar. En forma ms general,supngase que un proceso desee ser informado de la ocurrencia de un evento. Supngase que otro proceso es capaz de detectar que ese acontecimiento ya ha ocurrido. El siguiente programa (sem02) muestra cmo pueden utilizarse la s operaciones de semforos para implementar
un mecanismo simple de sincronizacin de bloqueo/despertar de dos procesos.

program sem02; (* Proceso de sincronizacin de bloqueo/despertar con semforos *) var mutex: semaphore; (* declaracin del semforo *) process uno; begin writeln(Cosas preliminares de Uno); wait(mutex); (* Espera por el semforo *) writeln(Otras cosas del Uno); end; (* uno *) process dos; begin writeln(Cosas preliminares del Dos); signal(mutex); writeln(Otras cosas del Dos.); end; (* dos *) begin initial(mutex,0); cobegin uno; dos coend;end.
La ejeucin del programa es:

Cosas Cosas Otras Otras preliminares de Uno preliminares del Dos cosas del Dos. cosas del Uno
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
4.2.2. BLOQUEOS MUTUOS Y BLOQUEOS INDEFINIDOS

La implantacin de un semforo con una cola de espera puede dar como resultado una situacin donde dos o ms procesos esperen indefinidamente un suceso que slo puede ocacionar uno de los procesos en espera. El suceso en cuestin consiste en la ejecucin de una operacin signal. Cuando se llega a este estado, se dice que los procesos estn en bloqueo mutuo. Para ilustrarlo, consideremos un sistema que consta de dos procesos, Uno y Dos, cada uno con acceso a dos semforos, S y Q, con valor inicial 1:
Uno wait(S) wait(Q) . . . signal(S) signal(Q) . signal(Q) signal(S) Dos wait(Q) wait(S) . .
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;
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
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
4.2.3. LA RELACIN PRODUCTOR - CONSUMIDOR

En un programa secuencial, cuando un procedimiento llama a otro y le trasmite datos, los procedimientos son parte de un proceso simple y no operan de forma concurrente. Pero cuando un proceso transmite datos a otro, los problemas son mucho ms complejos. Tal transmisin es un ejemplo de comunicacin interprocesos. Considrese la siguiente relacin productor consumidor. Suponga que un proceso, un productor, est generando informacin que utiliza un segundo proceso, un consumidor. Suponga que se comunican por medio de la variable compartida, buffer< /I>. El productor agrega datos en el arreglo buffer, el consumi98 SISTEMAS OPERATIVOS
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];
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
4.2.4. SEMFOROS CONTADORES

Los semforos contadores son particularmente tiles cuando un recurso va a ser asignado desde una bolsa de recursos idnticos. El semforo se inicializa para el nmero de recursos de la bolsa. Cada operacin wait decrementa el semforo en 1, indicando qu e ha extrado otro recurso de la bolsa y est siendo usado por un proceso. Cada operacin signal incrementa el semforo en 1, indicando que un proceso ha devuelto un recurso a la bolsa, y puede ser asignado a otro proceso. Si se intenta una operacin wait cuando el semforo ha sido decrementado hasta cero, el proceso debe esperar hasta que se devuelva algn recurso a la bolsa por medio de una operacin signal.
4.3. PROGRAMACIN CONCURRENTE

Anteriormente se ha presentado algunos algoritmos para la implementacin de las primitivas de exclusin mutua, y se mencionaron los semforos de Dijkstra. Pero estos mtodos tienen varias debilidades: son tan primitivos que es difcil expresar la solucin de problemas de concurrencia ms complejos, y su presencia en los programas concurrentes dificulta an ms el problema de probar la correccin del programa. El uso incorrecto de estas primitivas, ya sea intensionado o accidental, podra corromper la operaci n de un sistema concurrente. Por este motivo, los investigadores se han entregado a la tarea de buscar construcciones de exclusin mutua de ms alto nivel que faciliten expresar los problemas de concurrencia complejos faciliten probar la correccin del programa resulte muy difcil (cuando no imposible) su uso incorrecto o corrupcin por parte del usuario.
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
4.4. PROBLEMAS CLSICOS. 4.4.1. EL PROBLEMA DE LOS FILSOFOS COMELONES

Cinco filsofos pasan su vida pensando y comiendo. Los filsofos comparten una mesa circular rodeada por cinco sillas, una para cada uno de ellos. En el centro de la mesa se encuentra una fuente de arroz, y tambin sobre la mesa hay cinco palillos chinos. Cuando un filsofo piensa, no interacta con sus colegas. Ocasionalmente, un filsofo tiene hambre y trata de coger los dos palillos que estn ms cerca de l (los palillos colocados entre l y sus vecinos de la derecha y de la izquierda). Un filsofo slo puede coger un palillo a la vez y, obviamente, no puede ser el que est en la mano de un vecino. Cuando un filsofo hambriento tiene sus dos palillos al mismo tiempo come sin soltarlos. Cuando termina de comer, coloca ambos palillos sobre la mesa y comienza a pensar otra vez (Figura 4.1).
Figura 4.1. La situacin de los Filsofos comelones.
El problema de los filsofos comelones (comensales) se considera un pro102 SISTEMAS OPERATIVOS
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
Comiendo el Comiendo Pensando Pensando Pensando Comiendo
4 el el el el 4 el 1 2 1 3 5 2 4 5 2 3 5 1 2 2 4 4 5 1 3 5 1 2
Comiendo el Comiendo el Pensando el Comiendo el 3 Pensando el Comiendo el Pensando el 1 Comiendo el Pensando el 4 Comiendo el Pensando el Pensando el Comiendo el 3 Pensando el Comiendo el Pensando el Pensando el Comiendo el Comiendo el Comiendo el Pensando el Pensando el 5 Comiendo el Pensando el 3
Aunque esta 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
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
4.4.2. EL BARBERO DORMILN

Otro de los problemas clsicos de la comunicacin entre procesos ocurre en una peluquera. La peluquera tiene un barbero, una silla de peluquero y n sillas para que se sienten los clientes en espera, si es que los hay. Si no hay clientes presentes, el b arbero se sienta en su silla de peluquero y se duerme. Cuando llega un cliente, ste debe despertar al barbero dormiln. Si llegan ms clientes mientras el barbero corta el cabello de un cliente, ellos se sientan (si hay sillas desocupadas). El problema consiste en programar al barbero y los clientes sin entrar en condiciones de competencia. Esta solucin utiliza tres semforos: clientes, que cuenta el nmero de clientes en espera (sin incluir al cliente de la silla del peluquero, que no est esperando), barberos, el nmero de barberos inactivos y que esperan clientes (0 o 1) y mutex, que se utiliza para la exclusin mutua. Tambin necesitamos una variable, enespera, que tambin cuenta el nmero de clientes que esperan. Esto es en esencia una copia de clientes. La razn para el uso de enespera
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
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
Corta el pelo Corta el pelo Corta el pelo Program terminated normally
Toma asiento el 0 Toma asiento el 2 Toma asiento el 1 Corta el pelo Toma asiento el13 Toma asiento el 3 Encuentra lleno el 11 Encuentra lleno el 15 Corta el pelo Toma asiento el 4 Encuentra lleno el 14 Corta el pelo Toma asiento el 5 Corta el pelo Toma asiento el 6 Corta el pelo Toma asiento el 7 Corta el pelo Toma asiento el12 Encuentra lleno el 8 Corta el pelo Toma asiento el 9 Encuentra lleno el 10 Corta el pelo Corta el pelo Corta el pelo Corta el pelo
Program terminated normally
Resumen
Dijkstra fue el primero en presentar una 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.
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.
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.

Encuentren la solucin a los siguientes problemas: PROBLEMA UNO En el problema del productor- consumidor implementada con semforos, las operaciones wait y signal deben ser atmicas, explique con una corrida que sucedera para este problema si no son atmicas.
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
Libera espacio de memoria asignada a procesos que han terminado.
5.2. JERARQUA DE ALMACENAMIENTO

Los programas y datos tienen que estar en la memoria principal para poder ejecutarse o ser referenciados. Los programas y datos que no son necesarios de inmediato pueden mantenerse en el almacenamiento secundario. El almacenamiento principal es ms costoso y menor que el secundario pero de acceso ms rpido. Los sistemas con varios niveles de almacenamiento requieren destinar recursos para administrar el movimiento de programas y datos entre niveles (ver Figura 5.1).
Figura 5.1. Organizacin jerrquica del almacenamiento.
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.
5.3. ESTRATEGIAS DE ALMACENAMIENTO
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
5.4. ASIGNACIN CONTIGUA VERSUS NO CONTIGUA
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.
5.5. ASIGNACIN CONTIGUA DE ALMACENAMIENTO DE UN SOLO USUARIO

Se consideran S. O. que ya poseen desarrollado el sistema de control de entrada / salida: IOCS: input / output control system (ver Figura 5.2).
Figura 5.2. Asignacin contigua de almacenamiento de un solo usuario.
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
Figura 5.3. Utilizacin de la CPU en un sistema de un solo usuario.
5.6. MULTIPROGRAMACIN DE PARTICIN FIJA

Los sistemas de multiprogramacin permiten que varios procesos usuarios compitan al mismo tiempo por los recursos del sistema: Un trabajo en espera de e / s ceder la cpu a otro trabajo que est listo para efectuar cmputos. Existe paralelismo entre el procesamiento y la e / s. Se incrementa la utilizacin de la cpu y la capacidad global de ejecucin del sistema. Es necesario que varios trabajos residan a la vez en la memoria principal.
5.6.1. MULTIPROGRAMACIN DE PARTICIN FIJA: TRADUCCIN Y CARGA ABSOLUTAS

Las particiones del almacenamiento principal: Son de tamao fijo.
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).
Figura 5.4. Multiprogramacin de particin fija con traduccin y carga absolutas.
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.
5.6.2. MULTIPROGRAMACIN DE PARTICIN FIJA: TRADUCCIN Y CARGA RELOCALIZABLES

Los compiladores, ensambladores y cargadores de relocalizacin: Se usan para producir programas relocalizables que puedan ser ejecutados en cualquier particin disponible de tamao suficiente para aceptarlos (ver Figura 5.6). Son ms complejos que los absolutos. Mejoran la utilizacin del almacenamiento. Confieren ms flexibilidad en el armado de la carga de procesos.
118
SISTEMAS OPERATIVOS
Figura 5.5.
Figura 5.6. Multiprogramacin de particin fija con traduccin y carga relocalizables.
5.6.3. PROTECCIN EN LOS SISTEMAS DE MULTIPROGRAMACIN

Si se utiliza asignacin contigua de memoria la proteccin suele implementarse con varios registros de lmites (ver Figura 5.7 y Figura 5.8). Los extremos superior e inferior de una particin pueden ser:
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.
5.6.4. FRAGMENTACIN EN PARTICIN FIJA
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.
5.7. MULTIPROGRAMACIN DE PARTICIN VARIABLE

Los procesos ocupan tanto espacio como necesitan, pero obviamente no deben superar el espacio disponible de memoria (ver Figura 5.9).
Figura 5.9. Asignacin de particiones iniciales en la multiprogramacin de particin variable.
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
5.7.1. COMBINACIN DE AGUJEROS (REAS LIBRES)

Consiste en fusionar agujeros adyacentes para formar uno sencillo ms grande. Se puede hacer cuando un trabajo termina y el almacenamiento que libera tiene lmites con otros agujeros.
5.7.2. COMPRESIN O COMPACTACIN DE ALMACENAMIENTO

Puede ocurrir que los agujeros (reas libres) separados distribuidos por todo el almacenamiento principal constituyan una cantidad importante de memoria: Podra ser suficiente (el total global disponible) para alojar a procesos encolados en espera de memoria. Podra no ser suficiente ningn rea libre individual (ver Figura 5.10).
Figura 5.10. Agujeros del almacenamiento en la multiprogramacin de particin variable.
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
Figura 5.11. Combinacin de agujeros adyacentes de almacenamiento en la multiprogramacin de particin variable.
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.
5.7.3. ESTRATEGIAS DE COLOCACIN DEL ALMACENAMIENTO

Se utilizan para determinar el lugar de la memoria donde sern colocados los programas y datos que van llegando y se las clasifica de la siguiente manera: Estrategia de mejor ajuste: Un trabajo nuevo es colocado en el agujero en el cual quepa de forma ms ajustada. Debe dejarse el menor espacio sin usar (Figura 5.13). Estrategia de primer ajuste: Un trabajo nuevo es colocado en el primer agujero disponible con tamao suficiente para alojarlo (Figura 5.14).
123
Figura 5.12. Compresin (compactacin) del almacenamiento en la multiprogramacin de particin variable.
Figura 5.13. Estrategia del mejor ajuste.
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
Figura 5.14. Estrategia del primer ajuste.
Figura 5.15. Estrategia del peor ajuste.
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.
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.
El lector explica los fundamentos del almacenamiento en la memoria real.
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.

Encuentre la solucin a los siguientes problemas: PROBLEMA UNO Consideremos un sistema de intercambio en el que la memoria consta de los siguientes tamaos de espacios en orden de memoria: 10K, 4K, 20K, 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 (c) 9K con el mtodo del primero que se ajuste?. Repita ahora la pregunta con el mejor en ajustarse y el peor en ajustarse. PROBLEMA DOS 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) 8K (b) 10K (c) se libera 8K que se esta usando en la parte ms alta de la memoria. (c) 9K
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.
6.2. CONCEPTOS VIRTUAL
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).
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).
Figura 6.2. Contigidad artificial
133
6.3. ORGANIZACIN DEL ALMACENAMIENTO DE NIVELES MLTIPLES

Se deben proporcionar los medios para retener programas y datos en un gran almacenamiento auxiliar para: Permitir que el espacio de direcciones virtuales de un usuario sea mayor que el espacio de direcciones reales. Soportar multiprogramacin de forma efectiva en un sistema con muchos usuarios que compartan el almacenamiento real.
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.
6.4. TRANSFORMACIN DE BLOQUES

Los mecanismos de traduccin dinmica de direcciones deben mantener mapas que ilustren qu direcciones del almacenamiento virtual se encuentran en el almacenamiento real y dnde se encuentran. La informacin se agrupa en bloques: El sistema est informado del lugar del almacenamiento real donde han sido colocados los bloques de almacenamiento virtual.
134
SISTEMAS OPERATIVOS
Figura 6.3. Almacenamiento de dos niveles.
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
Figura 6.4. Formato de la direccin virtual dentro de un sistema de transformacin de bloques.
Figura 6.5. Traduccin de direcciones virtuales con transformacin de bloques.
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.
6.5. CONCEPTOS BSICOS DE PAGINACIN

Frecuentemente se diferencia entre la paginacin pura y la combinacin de paginacin y segmentacin. Las pginas se transfieren del almacenamiento secundario al primario en bloques llamados marcos de pginas: Tienen el mismo tamao que las pginas.
137
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).
Figura 6.6. Formato de la direccin virtual en un sistema de paginacin pura.
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).
6.5.1. TRADUCCIN DE DIRECCIONES DE PAGINACIN POR TRANSFORMACIN DIRECTA

Un proceso en ejecucin hace referencia a la direccin virtual v = (p,d). Antes que un proceso comience su ejecucin, el S. O. carga la direccin de almacenamiento primario de la tabla de mapa de pginas en el registro origen de la tabla de mapa de pginas (Ver Figura 6.10).
138
SISTEMAS OPERATIVOS
Figura 6.7. Almacenamiento real dividido en marcos de pginas.
Figura 6.8. Una entrada en la tabla de mapa de pginas.
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
Figura 6.10. Traduccin de direcciones de pgina por transformacin directa.
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.
6.5.2. TRADUCCIN DE DIRECCIONES DE PAGINACIN POR TRANSFORMACIN ASOCIATIVA

Una forma de acelerar la traduccin dinmica de pginas consiste en colocar la tabla completa de mapa de pginas en un almacenamiento asociativo que tenga un tiempo de ciclo mucho ms rpido que el almacenamiento primario. Una variante es la transformacin asociativa pura (ver Figura 6.11).
141
Figura 6.11. Traduccin de direcciones de pgina por transformacin asociativa pura.
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.
6.5.3. TRADUCCIN DE DIRECCIONES DE PAGINACIN POR COMBINACIN DE TRANSFORMACIN ASOCIATIVA / DIRECTA

Se utiliza un almacenamiento asociativo capaz de mantener solo un pequeo porcentaje del mapa completo de pginas para un proceso (ver Figura 6.12).
142
SISTEMAS OPERATIVOS
Figura 6.12. Traduccin de direcciones de paginacin por combinacin de transformacin asociativa/directa.
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).
6.5.4. COMPARTIMIENTO DE RECURSOS EN UN SISTEMA DE PAGINACIN

En sistemas multiprogramados, especialmente en los de tiempo compartido, es comn que ms de un usuario est ejecutando los mismos programas: Para optimizar el uso de la memoria real se comparten las pginas que pueden ser compartidas: El compartimiento debe ser cuidadosamente controlado para evitar que un proceso modifique datos que otro proceso esta leyendo (ver Figura 6.13). - Los programas se encuentran divididos en reas separadas de procedimiento y datos. Los procedimientos no modificables se llaman procedimientos puros reentrantes. Los datos y procedimientos modificables no pueden ser compartidos. - Los datos no modificables (ej.: tablas fijas) son compartibles. Se debe identificar cada pgina como compartible o no. Habr marcos (celdas) de pginas compartidos por varios procesos. El compartimiento: Reduce la cantidad de almacenamiento primario necesario para la ejecucin eficaz de un grupo de procesos. Puede hacer posible que un sistema determinado mantenga una cantidad mayor de usuarios (procesos).
144
SISTEMAS OPERATIVOS
Figura 6.13. Compartimiento en un sistema de paginacin pura.
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
Figura 6.14. Asignacin no contigua de almacenamiento.
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.
La traduccin dinmica de direcciones utiliza una tabla de mapa de segmentos.
Figura 6.15. Proteccin de alamcenamiento como claves en sistemas de multiprogramacin de asignacin no contigua de almacenamiento.
Figura 6.16. Traduccin de direcciones virtuales en un sistema de segmentacin pura.
147
6.6.1. CONTROL DE ACCESO EN SISTEMAS DE SEGMENTACIN

Se le otorga a cada proceso ciertos derechos de acceso a todos los segmentos y se les niega completamente el acceso a muchos otros. Si un proceso tiene acceso de lectura a un segmento, puede obtener cualquier elemento de informacin contenido en ese segmento. Si un proceso tiene acceso de escritura a un segmento, puede modificar cualquier contenido del segmento y puede introducirle informacin adicional, incluso destruir toda la informacin del segmento. Un proceso con acceso de ejecucin de un segmento puede ejecutarlo como si fuera un programa. Un proceso con acceso de adicin puede escribir informacin adicional al final del segmento, pero no puede modificar la informacin existente. En base a los tipos de control de acceso indicados pueden crearse distintos modos de control de acceso. Ejemplos de combinacin de los accesos de lectura, escritura y ejecucin para producir modos de proteccin tiles se dan en la Tabla 6.1 y en la Tabla 6.2.
Tabla 6.1. Ejemplo de combinacin de accesos.
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
Tabla 6.2. Ejemplo de aplicaciones de la combinacin de accesos.
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
6.6.2. TRADUCCIN DE DIRECCIONES DE SEGMENTACIN POR TRANSFORMACIN DIRECTA

Existen varias estrategias para la implementacin de la traduccin de direcciones de segmentacin: Por transformacin directa, asociativa o combinacin de asociativa / directa. Con cach suficiente para alojar la tabla completa de mapa de segmentos o cach parciales que contengan solo las entradas de los segmentos de referencia ms reciente (ver Figura 6.17).
Figura 6.17. Entrada de tabla de mapa de segmentos.
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.
6.6.3. COMPARTIMIENTO EN UN SISTEMA DE SEGMENTACIN

Una de las ventajas de la segmentacin sobre la paginacin es que se trata ms de un hecho lgico que fsico: En un sistema de segmentacin, una vez que un segmento ha sido declarado como compartido, entonces las estructuras que lo integran pueden cambiar de tamao. Lo anterior no cambia el hecho lgico de que residen en un segmento compartido.
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).
Figura 6.18. Compartimiento en un sistema de segmentacin pura.
6.7. SISTEMAS DE PAGINACIN / SEGMENTACIN

Ofrecen las ventajas de las dos tcnicas de organizacin del almacenamiento virtual. El tamao de los segmentos es mltiplo del de las pginas. No es necesario que todas las pginas de un segmento se encuentren al mismo tiempo en el almacenamiento primario. Las pginas de almacenamiento virtual, que son contiguas en este almacenamiento, no necesitan ser contiguas en el almacenamiento real. El direccionamiento es tridimensional con una direccin de almacenamiento virtual v = (s,p,d): s es el nmero del segmento. p es el nmero de pgina.
151
d es el desplazamiento en la pgina donde se encuentra asignado el elemento deseado.
6.7.1. TRADUCCIN DINMICA DE DIRECCIONES EN SISTEMAS DE PAGINACIN / SEGMENTACIN

Se considera la traduccin dinmica de direcciones de virtuales a reales en un sistema de paginacin / segmentacin utilizando la combinacin de transformacin asociativa / directa (ver Figura 6.19). El proceso en ejecucin hace referencia a la direccin virtual v = (s,p,d) (ver Figura 6.19).
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:
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.
6.7.2. COMPARTIMIENTO EN CIN/SEGMENTACIN
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
Figura 6.20. Estructura de tablas para un sistema de paginacin y segmentacin.
155
Figura 6.21. Dos procesos compartiendo un sistema de paginacin y segmentacin.
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:
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.
6.8.2. ESTRATEGIAS PGINA

Las principales son:
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
Por reloj. Conjuntos de trabajo. El Principio de Optimizacin
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
Figura 6.22. Ejemplo de anomala FIFO.
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
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.
Figura 6.23. El LRU con uso de una matriz.
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.
Los bits modificados no se ajustan peridicamente segn esta estrategia.
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.
Figura 6.24. Algoritmo de reposicin (reemplazo) de pginas de la segunda oportunidad.
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.
Figura 6.25. Algoritmo de reposicin (reemplazo) de pginas del reloj.
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
El lector explica los fundamentos de la memora virtual.
Nexo
La siguiente unidad acadmica trata sobre el Sistema de Archivos.
Actividad
Analice los aspectos tericos sobre la Memoria Virtual.

Escriba programas que encuentren la solucin a los siguientes problemas: PROBLEMA UNO Cul es la diferencia entre una direccin fsica y una direccin virtual? PROBLEMA DOS Una computadora tiene cuatro marcos para pgina. 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):
164
SISTEMAS OPERATIVOS
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) 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.
7.2. FUNCIONES DEL SISTEMA DE ARCHIVOS

Los usuarios deben poder crear, modificar y borrar archivos. Se deben poder compartir los archivos de una manera cuidadosamente controlada. El mecanismo encargado de compartir los archivos debe proporcionar varios tipos de acceso controlado: Ej.: Acceso de Lectura, Acceso de Escritura, Acceso de Ejecucin, varias combinaciones de estos, etc.
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:
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.
7.3. EL SISTEMA DE ARCHIVOS

Un Archivo es un conjunto de registros relacionados. El Sistema de Archivos es un componente importante de un S. O. y suele contener: Mtodos de acceso relacionados con la manera de acceder a los datos almacenados en archivos. Administracin de archivos referida a la provisin de mecanismos para que los archivos sean almacenados, referenciados, compartidos y asegurados. Administracin del almacenamiento auxiliar para la asignacin de espacio a los archivos en los dispositivos de almacenamiento secundario. Integridad del archivo para garantizar la integridad de la informacin del archivo.
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.
7.4.1. NOMBRE DE LOS ARCHIVOS

Las reglas exactas para los nombres de archivos varan de sistema a sistema. Algunos sistemas de archivos distinguen entre las letras maysculas y minsculas, mientras que otros no. Muchos S. O. utilizan nombres de archivo con dos partes, separadas por un punto: La parte posterior al punto es la extensin de archivo y generalmente indica algo relativo al archivo, aunque las extensiones suelen ser meras convenciones.
7.4.2. ESTRUCTURA DE UN ARCHIVO

Los archivos se pueden estructurar de varias maneras (Figura 7.1 y Figura 7.2), las ms comunes son: Secuencia de bytes: El archivo es una serie no estructurada de bytes. Posee mxima flexibilidad. - El S. O. no ayuda pero tampoco estorba.
170
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
Figura 7.2. Estructura de archivos: rbol
7.4.3. TIPOS DE ARCHIVOS

Muchos S. O. soportan varios tipos de archivos, por ej.: archivos regulares, directorios, archivos especiales de caracteres, archivos especiales de bloques, etc., donde: Los Archivos Regulares son aquellos que contienen informacin del usuario. Los Directorios son archivos de sistema para el mantenimiento de una estructura del sistema de archivos. Los Archivos Especiales de Caracteres: Tienen relacin con la e / s. Se utilizan para modelar dispositivos seriales de e / s (terminales, impresoras, redes, etc.). Los Archivos Especiales de Bloques se utilizan para modelar discos.
7.4.4. ACCESO A UN ARCHIVO

Los tipos de acceso ms conocidos son: Acceso Secuencial: el proceso lee en orden todos los registros del archivo comenzando por el principio, sin poder: Saltar registros.
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.
7.4.5. ATRIBUTOS DE ARCHIVO

Cada archivo tiene: Su nombre y datos. Elementos adicionales llamados atributos, que varan considerablemente de sistema a sistema.
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.
7.4.6. OPERACIONES CON ARCHIVOS

Las llamadas ms comunes al sistema relacionadas con los archivos son: Create (crear): el archivo se crea sin datos. Delete (eliminar): si el archivo ya no es necesario debe eliminarse para liberar espacio en disco. Ciertos S. O. eliminan automticamente un archivo no utilizado durante n das. Open (abrir): antes de utilizar un archivo, un proceso debe abrirlo. La finalidad es permitir que el sistema traslade los atributos y la lista de direcciones en disco a la memoria principal para un rpido acceso en llamadas posteriores. Close (cerrar): cuando concluyen los accesos, los atributos y direcciones del disco ya no son necesarios, por lo que el archivo debe cerrarse y liberar la tabla de espacio interno. Read (leer): los datos se leen del archivo; quien hace la llamada debe especificar la cantidad de datos necesarios y proporcionar un buffer para colocarlos. Write (escribir): los datos se escriben en el archivo, en la posicin actual. El tamao del archivo puede aumentar (agregado de registros) o no (actualizacin de registros). Append (aadir): es una forma restringida de write. Solo puede aadir datos al final del archivo. Seek (buscar): especifica el punto donde posicionarse. Cambia la posicin del apuntador a la posicin activa en cierto lugar del archivo.
SISTEMAS OPERATIVOS
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.
7.4.7. ARCHIVOS MAPEADOS A MEMORIA

Algunos S. O. permiten asociar los archivos con un espacio de direcciones de un proceso en ejecucin. Se utilizan las llamadas al sistema map y unmap: Map: utiliza un nombre de archivo y una direccin virtual y hace que el S. O. asocie al archivo con la direccin virtual en el espacio de direcciones, por lo cual las lecturas o escrituras de las reas de memoria asociadas al archivo se efectan tambin sobre el archivo mapeado. Unmap: elimina los archivos del espacio de direcciones y concluye la operacin de asociacin.
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
7.5.1. SISTEMAS JERRQUICOS DE DIRECTORIOS

El directorio contiene un conjunto de datos por cada archivo referenciado (ver Figura 7.3). Una posibilidad es que el directorio contenga por cada archivo referenciado: El nombre. Sus atributos. Las direcciones en disco donde se almacenan los datos.
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
El nmero y organizacin de directorios vara de sistema en sistema:

176
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).
Figura 7.4 Un solo directorio compartido por todos los usuarios
Figura 7.5. Un directorio por usuario
177
Figura 7.6. Un rbol arbitrario por usuario
7.5.2. NOMBRE DE LAS RUTAS DE ACCESO

Cuando el sistema de archivos est organizado como un rbol de directorios se necesita una forma de determinar los nombres de los archivos. Los principales mtodos para nombres de los archivos son: Ruta de Acceso Absoluta: Cada archivo tiene una ruta de acceso absoluta. Consta de la ruta de acceso desde el directorio raz hasta el archivo.
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.
7.5.3. OPERACIONES CON DIRECTORIOS

Las llamadas al sistema permitidas para el manejo de los directorios tienen variacin de sistema a sistema. Las ms comunes son las siguientes: Create (crear): se crea un directorio vaco. Delete (eliminar): se elimina un directorio, que debe estar vaco. Opendir (abrir directorio): se pueden leer los directorios, antes de poder leer un directorio, ste debe ser abierto. Closedir (cerrar directorio): cuando se ha ledo un directorio, ste debe ser cerrado para liberar el espacio correspondiente de la tabla interna. Readdir (leer directorio): regresa la siguiente entrada en un directorio abierto, sin importar el tipo de estructura de directorios que se utilice. Rename (cambiar de nombre): cambia el nombre de un directorio de manera similar al cambio para archivos. Link (ligar): es una tcnica que permite que un archivo aparezca en ms de un directorio: Especifica un archivo existente y el nombre de una ruta de acceso.
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.
7.6.1. IMPLANTACIN DE ARCHIVOS

El aspecto clave de la implantacin del almacenamiento de archivos es el registro de los bloques asociados a cada archivo. Algunos de los mtodos utilizados son los siguientes:
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:
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.
Figura 7.7. Encadenamiento de bloques
Localizar un registro determinado requiere:

* 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.
Figura 7.8. 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).
Figura 7.9 Encadenamiento de bloques de ndices
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
Figura 7.10 Transformacin de archivos orientada hacia bloques
186
SISTEMAS OPERATIVOS
Figura 7.11. Esquema de un nodo-i
7.7. IMPLANTACIN DE DIRECTORIOS

Para abrir un archivo el S. O. utiliza informacin del directorio: El directorio contiene la informacin necesaria para encontrar los bloques en el disco. El tipo de informacin vara segn el sistema.
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.
7.7.1. DIRECTORIOS EN MS-DOS

La Figura 7.12 muestra el almacenamiento de directorios en MS-DOS. La figura 7.13 muestra una entrada de dicrectorio en UNIX. La Figura 7.14 muestra los pasos en la bsqueda de un directorio.
Figura 7.12. Un dato de directorio en MS-DOS.
Figura 7.13 Una entrada de directorio en UNIX
188
SISTEMAS OPERATIVOS
Figura 7.14 Los pasos en la bsqueda de /usr/ast/mbox
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.
El lector explica los fundamentos de los archivos y directorios.
Nexo
La siguiente unidad acadmica amplia el Sistema de Archivos.
Actividad
Analice los aspectos tericos sobre el Sistema de Archivos.

Escriba programas que encuentren la solucin a los siguientes problemas: PROBLEMA UNO Escriba un programa que simule el uso de los archivos. PROBLEMA DOS Escriba un programa que simule el uso de los directorios.
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.1. Sistema de archivos con un archivo compartido
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.
8.2. ADMINISTRACIN DEL ESPACIO EN DISCO

Existen dos estrategias generales para almacenar un archivo de n bytes: Asignar n bytes consecutivos de espacio en el disco: Tiene el problema de que si un archivo crece ser muy probable que deba desplazarse en el disco, lo que puede afectar seriamente al rendimiento. Dividir el archivo en cierto nmero de bloques (no necesariamente) adyacentes: Generalmente los sistemas de archivos utilizan esta estrategia con bloques de tamao fijo.
8.2.1. TAMAO DEL BLOQUE:

Dada la forma en que estn organizados los bloques, el sector, la pista y el cilindro son los candidatos obvios como unidades de asignacin. Si se tiene una unidad de asignacin grande, como un cilindro, esto significa que cada archivo, inclusive uno pequeo, ocupar todo un cilindro; con esto se desperdicia espacio de almacenamiento en disco. Si se utiliza una unidad de asignacin pequea, como un sector, implica que cada archivo constar de muchos bloques; con esto su lectura generar muchas operaciones de e / s afectando la performance. Lo anterior indica que la eficiencia en tiempo y espacio tienen un conflicto inherente. Generalmente se utilizan como solucin de compromiso bloques de 1/2 k, 1k, 2k o 4k (ver Figura 8.3). Hay que recordar que el tiempo de lectura de un bloque de disco es la suma de los tiempos de: Bsqueda. Demora rotacional. Transferencia.
194
SISTEMAS OPERATIVOS
Uso del espacio en disco (%)
Figura 8.3. Representacin de la velocidad de lectura y del uso del espacio en disco en funcin del tamao del bloque
8.2.2. REGISTRO DE LOS BLOQUES LIBRES:

Se utilizan por lo general dos mtodos (ver Figura 8.4): La lista de bloques libres como lista ligada. Un mapa de bits.
Lista ligada de bloques de disco: Cada bloque contiene tantos 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
Figura 8.4. Registro de los bloques libres.
8.2.3. DISK QUOTAS

Para evitar que los usuarios se apropien de un espacio excesivo en disco, los S. O. multiusuario proporcionan generalmente un mecanismo para establecer las cuotas en el disco (ver Figura 8.5). La idea es que: Un administrador del sistema asigne a cada usuario una proporcin mxima de archivos y bloques. El S. O. garantice que los usuarios no excedan sus cuotas.
Un mecanismo utilizado es el siguiente: Cuando un usuario abre un archivo: Se localizan los atributos y direcciones en disco. Se colocan en una tabla de archivos abiertos en la memoria principal. Uno de los atributos indica el propietario del archivo; cualquier aumento del 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.
Figura 8.5. Mecanismo para establecer las cuotas en el disco.
8.3. CONFIABILIDAD DEL SISTEMA DE ARCHIVOS

Es necesario proteger la informacin alojada en el sistema de archivos, efectuando los resguardos correspondientes. De esta manera se evitan las consecuencias generalmente catastrficas de la prdida de los sistemas de archivos. Las prdidas se pueden deber a problemas de hardware, software, hechos externos, etc.
8.3.1. MANEJO DE UN BLOQUE DEFECTUOSO:

Se utilizan soluciones por hardware y por software. La solucin en hardware: Consiste en dedicar un sector del disco a la lista de bloques defectuosos. Al inicializar el controlador por primera vez:
197
- 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.
8.3.2. RESPALDOS BACKUP):
(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.
8.3.3. CONSISTENCIA DEL SISTEMA DE ARCHIVOS:

Muchos sistemas de archivos leen bloques, los modifican y escriben en ellos despus. Si el sistema falla antes de escribir en los bloques modificados, el sistema de archivos puede quedar en un estado inconsistente.
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.
8.4. DESEMPEO DEL SISTEMA DE ARCHIVOS

El acceso al disco es mucho ms lento que el acceso a la memoria: Los tiempos se miden en milisegundos y en nanosegundos respectivamente. Se debe reducir el nmero de accesos a disco.
SISTEMAS OPERATIVOS
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.
8.5.1. EL AMBIENTE DE SEGURIDAD

Se entender por seguridad a los problemas generales relativos a la garanta de que los archivos no sean ledos o modificados por personal no autorizado; esto incluye aspectos tcnicos, de administracin, legales y polticos. Se consideraran mecanismos de proteccin a los mecanismos especficos del sistema operativo utilizados para resguardar la informacin de la computadora. La frontera entre seguridad y mecanismos de proteccin no est bien definida. Dos de las ms importantes facetas de la seguridad son: La prdida de datos. Los intrusos.
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.
Para disear un sistema seguro contra intrusos:

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.
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.
8.5.3. PRINCIPIOS DEL DISEO PARA LA SEGURIDAD

El diseo del sistema debe ser pblico, ya que pensar que el intruso no conocer la forma de funcionamiento del sistema es un engao. El estado predefinido debe ser el de no acceso, dado que los errores en donde se niega el acceso vlido se reportan ms rpido que los errores en donde se permite el acceso no autorizado. Verificar la autorizacin actual : El sistema no debe: - Verificar el permiso.
- 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.
8.6. MECANISMOS DE PROTECCIN 8.6.1. DOMINIOS DE PROTECCIN

Muchos objetos del sistema necesitan proteccin, tales como la cpu, segmentos de memoria, unidades de disco, terminales, impresoras, procesos, archivos, bases de datos, etc. Cada objeto se referencia por un nombre y tiene habilitadas un conjunto de operaciones sobre l. Un dominio es un conjunto de parejas (objeto, derechos, Figura 8.9): Cada pareja determina: Un objeto y un subconjunto de las operaciones que se pueden llevar a cabo en l.
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:
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.9 Tres dominios de proteccin
En algunos S. O. los dominios se llaman anillos (ver Figura 8.10).
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.
Figura 8.11 Una matriz de proteccin
8.6.2. LISTAS PARA CONTROL DE ACCESO

Las matrices de proteccin son muy grandes y con muchos lugares vacos: Desperdician espacio de almacenamiento. Existen mtodos prcticos que almacenan solo los elementos no vacos por filas o por columnas.
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.
El lector explica los fundamentos de la confiabilidad, seguridad y mecanismos de proteccin.
Actividad
Analice los aspectos tericos adicionales sobre el Sistema de Archivos.

Escriba programas que encuentren la solucin a los siguientes problemas: PROBLEMA UNO Escriba un programa que simule la administracin de archivos compartidos. PROBLEMA DOS Escriba un programa que simule el uso del registro de los bloques libres
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

Sistemas Operativos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Sistemas Operativos

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD PERUANA LOS ANDES

MG. ABRAHAM ESTEBAN GAMARRA MORENO

Mg. Abraham Gamarra Moreno

Mg. Abraham Gamarra Moreno

Presentar al usuario una interfaz o mquina virtual.

Figura 1.1. Recursos administrados por el S.O.

Recuperarse de los errores.

1.2. HISTORIA DE GENERACIONES

1.2.1. GENERACIN CERO (DCADA DE 1940):

1.2.2. PRIMERA GENERACIN CONEXIONES

1.2.4. TERCERA GENERACIN (1965-1980): CIRCUITOS INTEGRADOS Y MULTIPROGRAMACIN

1.2.5. CUARTA GENERACIN (1980-1990): COMPUTADORAS PERSONALES:

1.3. CONCEPTOS DE LOS SISTEMAS OPERATIVOS

Un proceso (suspendido) consta de:

1.3.3. LLAMADAS AL SISTEMA:

1.4. ESTRUCTURA DE LOS SISTEMAS OPERATIVOS

1.4.1. SISTEMAS MONOLTICOS:

Figura 1.2. Modelo de estructura simple para un sistema monoltico.

Figura 1.3. Forma de llamada al sistema en un sistema monoltico.

Mg. Abraham Gamarra Moreno

1.4.2. SISTEMAS CON CAPAS:

Tabla 1.1. Estructura del S.O. en capas THE

Mg. Abraham Gamarra Moreno

1.4.3. MQUINAS VIRTUALES:

Figura 1.4. La estructura de VM-370 con CMS.

1.4.4. MODELO CLIENTE - SERVIDOR

Mg. Abraham Gamarra Moreno

Figura 1.5. El modelo cliente servidor.

Se adapta para su uso en los sistemas distribuidos: (ver Figura 1.6).

Figura 1.6. El modelo cliente servidor en un sistema distribuido.

1.5. MS ESTRUCTURAS DE SISTEMAS OPERATIVOS

piezas deben tener su funcin, sus inputs y outputs cuidadosamente definidos.

1.5.1. EL SISTEMA OPERATIVOS DOS

Figura 1.7. Estructura del sistema operativo DOS.

1.5.2. EL SISTEMA OPERATIVO UNIX

1.6. EL SISTEMA OPERATIVO OS/2

Figura 1.8. Estructura del UNIX.

Figura 1.9. Estructura de capas del OS/2.

1.6.1. ARQUITECTURA DE WINDOWS NT

Mg. Abraham Gamarra Moreno

Mg. Abraham Gamarra Moreno

Auto evaluacin formativa

2.1. CONCEPTOS DE PLANIFICACIN

Figura 2.2. Ejecucin de procesos sin multiprogramacin

Figura 2.3. Ejecucin de procesos con multiprogramacin.

2.1.1. COLAS DE PLANIFICACIN

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

Figura 2.5. Representacin de la planificacin de procesos mediante un diagrama de colas.

Figura 2.6. Adicin de la planificacin a mediano plazo al diagrama de colas.

2.2. PLANIFICACIN DE LA UCP

2.2.1. CICLO DE RFAGAS DE UCP Y DE E/S

Mg. Abraham Gamarra Moreno

Figura 2.7. Secuencia alterna de rfagas de UCP y E/S.

Figura 2.8. Histograma de tiempos de rfaga de la UCP.

2.2.2. PLANIFICADOR DE LA UCP

2.2.3. ESTRUCTURA DE PLANIFICACIN

Mg. Abraham Gamarra Moreno

2.2.4. CAMBIO DE CONTEXTO

2.3. ALGORITMOS DE PLANIFICACIN

Mg. Abraham Gamarra Moreno

2.3.1. PLANIFICACIN SERVICIO POR ORDEN DE LLEGADA

Proceso Duracin de la rfaga P1 P2 P3 24 3 3

Mg. Abraham Gamarra Moreno