Introducción a los Sistemas Informáticos (Gestión del software) PDF

Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos TEMA 1 – INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS 1. Definición de sistema operativo................................................................

Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos TEMA 1 – INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS 1. Definición de sistema operativo.......................................................................................................... 3 2. Tipos de sistemas operativos............................................................................................................... 3 2.1. Sistemas operativos por su estructura.............................................................................................. 3 2.1.1. Estructura monolítica................................................................................................................. 3 2.1.2. Estructura jerárquica o multicapa.............................................................................................. 4 2.1.3. Estructura cliente-servidor o microkernel.................................................................................. 4 2.1.4. Kernel Híbrido........................................................................................................................... 5 2.2. Sistemas operativos por sus servicios.............................................................................................. 5 2.2.1. Por el número de usuarios.......................................................................................................... 6 2.2.2. Por el número de tareas.............................................................................................................. 6 2.2.3. Por el número de procesadores.................................................................................................. 6 2.3. Sistemas operativos por su interconexión........................................................................................ 6 2.3.1. Sistemas operativos aislados...................................................................................................... 6 2.3.2. Sistemas operativos de red......................................................................................................... 6 2.3.3. Sistemas operativos distribuidos................................................................................................ 7 3. Gestión de procesos............................................................................................................................. 7 3.1. Definición de proceso...................................................................................................................... 7 3.2. Estados de un proceso...................................................................................................................... 7 3.3. Transiciones de estado de un proceso.............................................................................................. 8 3.4. Planificación de procesos................................................................................................................ 8 3.4.1. Objetivos de la planificación..................................................................................................... 8 3.4.2. Variables a tener en cuenta en la planificación de procesos...................................................... 8 3.4.3. Algoritmos de planificación de procesos................................................................................... 9 3.4.3.1. FIFO (First Input First Output, Primero en Entrar Primero en Salir)................................. 9 3.4.3.2. SJF (Shortest Job First, Primero el Trabajo más Corto)..................................................... 9 3.4.3.3. SRTF (Shortest Remainder Time First, Primero el Tiempo Restante más Corto)............ 10 3.4.3.4. RR (Round Robin, Rueda de Tiempo)............................................................................. 11 3.4.3.5. Algoritmos con prioridades.............................................................................................. 12 3.4.3.5.1. FIFO con prioridades no apropiativo.......................................................................... 12 3.4.3.5.2. FIFO con prioridades apropiativo............................................................................... 13 3.4.3.6. Colas multinivel............................................................................................................... 13 4. Gestión de memoria........................................................................................................................... 14 4.1. Particiones estáticas....................................................................................................................... 15 4.2. Particiones dinámicas.................................................................................................................... 15 4.2.1. Compactación.......................................................................................................................... 15 4.3. Paginación...................................................................................................................................... 16 4.4. Segmentación................................................................................................................................. 17 4.5. Segmentación paginada................................................................................................................. 17 5. Gestión de memoria virtual............................................................................................................... 18 5.1. Definición de memoria virtual....................................................................................................... 18 5.2. Algoritmos de remplazo de páginas.............................................................................................. 18 6. Gestión de entrada-salida................................................................................................................... 19 6.1. Problemas asociados a la gestión de entrada-salida...................................................................... 19 6.2. Evolución histórica de la gestión de entrada-salida....................................................................... 19 7. Gestión de discos duros..................................................................................................................... 20 7.1. Algoritmos de acceso a disco........................................................................................................ 20 7.1.1. FIFO (First Input First Output, Primero en Entrar Primero en Salir)...................................... 20 7.1.2. SSTF (Short Seek Time First, Primero el Menor Tiempo de Búsqueda)................................ 21 Tema 1 – Introducción a los Sistemas Operativos Página 1 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 7.1.3. SCAN....................................................................................................................................... 22 7.1.4. C-SCAN................................................................................................................................... 23 7.1.5. LOOK...................................................................................................................................... 23 7.1.6. C-LOOK.................................................................................................................................. 23 8. Gestión de ficheros............................................................................................................................ 24 Tema 1 – Introducción a los Sistemas Operativos Página 2 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 1. Definición de sistema operativo El sistema operativo es un conjunto de programas que actúan como interfaz del “hardware” del ordenador y que controlan la ejecución del resto de programas. Usuarios Programas Sistema Operativo Hardw are El Sistema operativo es un software con unas características particulares, ya que debe administrar todos los recursos del sistema entre los usuarios y el resto de software. Por tanto, las características fundamentales que debe aportar cualquier sistema operativo genérico son: Adaptabilidad: se debe acomodar a las situaciones que evolucionan en paralelo, nuevo software y hardware. Esto lo realiza normalmente mediante actualizaciones, para hacer nuevas mejoras tanto en componentes físicos como en software Facilidad de uso: teniendo como referente el fin al que se empleará el sistema informático, la facilidad de manejo ha de ser primordial. Eficiencia: los recursos (procesadores y núcleos, RAM, acceso a discos, red o cola de impresión) son limitados. El sistema operativo debe atender a las peticiones de usuarios, programas y el propio sistema operativo para facilitar el acceso a los recursos. Esta tarea es muy compleja y crítica, ya que repercutirá en todo el sistema. 2. Tipos de sistemas operativos. 2.1. Sistemas operativos por su estructura 2.1.1. Estructura monolítica Es la estructura de los primeros sistemas operativos constituidos fundamentalmente por un solo programa compuesto de un conjunto de rutinas entrelazadas de tal forma que cada una puede llamar a cualquier otra. Tema 1 – Introducción a los Sistemas Operativos Página 3 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 2.1.2. Estructura jerárquica o multicapa A medida que fueron creciendo las necesidades de los usuarios y se perfeccionaron los sistemas, se hizo necesaria una mayor organización del software. Se dividió entonces el sistema operativo en pequeñas partes, de tal forma que cada una de ellas estuviera perfectamente definida y con un claro interfaz con el resto de los elementos. 2.1.3. Estructura cliente-servidor o microkernel El paradigma más reciente es el denominado cliente-servidor, también llamado microkernel. En este tipo de estructura el núcleo del sistema operativo tiene como misión establecer la comunicación entre procesos clientes y servidores. Los procesos pueden ser tanto clientes como servidores, y procesos cliente puede actuar como servidor para otros procesos. Este paradigma ofrece gran flexibilidad, ya que el núcleo provee solamente funciones muy básicas de memoria, entrada/salida, archivos y procesos. Tema 1 – Introducción a los Sistemas Operativos Página 4 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 2.1.4. Kernel Híbrido Se considera una evolución que aúna las arquitecturas monolítica y microkernel, persiguiendo la ventaja de ambas. Consiste en un diseño microkernel, pero con una implantación monolítica, que consigue una estabilidad y un significativo rendimiento. La diferencia de los sistemas microkernel, los sistemas híbridos añadirían en un espacio kernel los drivers de los dispositivos y todo lo relativo a la comunicación entre procesos, como servicios fundamentales para ejecutar en modo supervisor. Los sistemas operativos actuales no se pueden definir en una arquitectura claramente definica, aunque si se puede decir que sean tendentes a una de ellas. Por ejemplo: Mac OS: híbrido Windows de la familia NT: híbrido Ubuntu: monolítico. 2.2. Sistemas operativos por sus servicios Tema 1 – Introducción a los Sistemas Operativos Página 5 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 2.2.1. Por el número de usuarios Los sistemas operativos monousuario son aquellos que sólo son capaces de dar servicio a un usuario. Ejemplos de sistemas operativos de este tipo son MS-DOS, Microsoft Windows 9x y ME, MAC OS, entre otros. Los sistemas operativos multiusuario son aquellos que son capaces de dar servicio a más de un usuario concurrentemente. Algunos ejemplos serán UNIX, GNU/Linux, Microsoft Windows Server o MAC OS X. 2.2.2. Por el número de tareas Los sistemas operativos monotarea son aquellos que sólo permiten la ejecución de una tarea a la vez por usuario. Ejemplos de sistemas monotarea son MSDOS, Microsoft Windows 3.x y 95 (estos últimos sólo simulan la multitarea) Los sistemas operativos multitarea son aquellos que permiten la ejecución de varias tareas concurrentemente para cada uno de los usuarios. Algunos ejemplos son MAC OS, UNIX, Linux, Microsoft Windows 98, 2000, XP, Vista, 7 y 10 2.2.3. Por el número de procesadores Los sistemas operativos un proceso (monoprocesador) son aquellos que sólo con capaces de manejar un procesador. de manera que si el ordenador tuviese más de uno le sería inútil. MS-DOS y MAC OS son ejemplos de este tipo de sistemas operativos. Los sistemas operativos multiproceso son aquellos que con capaces de manejar varios procesadores a la vez. Trabajan de forma simétrica o de forma asimétrica. Cuando se trabaja de manera asimétrica, el sistema operativo selecciona a uno de los procesadores el cual jugará el papel de procesador maestro y servirá como pivote para distribuir la carga a los demás procesadores, que reciben el nombre de esclavos. Cuando se trabaja de manera simétrica, los procesos son enviados indistintamente a cualquiera de los procesadores disponibles, teniendo, teóricamente, una mejor distribución y equilibrio en la carga de trabajo bajo este esquema. 2.3. Sistemas operativos por su interconexión 2.3.1. Sistemas operativos aislados Los sistemas operativos aislados son aquellos que no tienen la capacidad de comunicarse e interactuar con otros ordenadores. 2.3.2. Sistemas operativos de red Los sistemas operativos de Red se definen como aquellos que tiene la capacidad de interactuar con otros ordenadores mediante un medio de transmisión con el objetivo de intercambiar información, transferir archivos, ejecutar comandos remotos y un sin fin de otras actividades. El punto crucial de estos sistemas es que el usuario debe saber la sintaxis de un conjunto de comandos o llamadas al sistema para ejecutar estas operaciones, además de la ubicación de los recursos que desee acceder. Tema 1 – Introducción a los Sistemas Operativos Página 6 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 2.3.3. Sistemas operativos distribuidos Los sistemas operativos distribuidos logran integrar recursos de distintos ordenadores interconectados (CPU, memoria principal, memoria secundaria, otros dispositivos de Entrada/Salida) en una sola máquina virtual a la que el usuario accede de forma transparente. 3. Gestión de procesos 3.1. Definición de proceso Antes de nada, hay que distinguir entre programa y proceso. Un programa es una secuencia de instrucciones escrita en un lenguaje dado. Un proceso es una instancia de ejecución de un programa. Un programa es un concepto estático, mientras que un proceso es un concepto dinámico. Es posible que un programa sea ejecutado por varios usuarios en un sistema multiusuario, por cada una de estas ejecuciones existirá un proceso. El sistema operativo necesita el concepto de proceso para poder gestionar el procesador mediante la técnica de multiprogramación o de tiempo compartido, de hecho, el proceso es la unidad planificable, o de asignación de la CPU. 3.2. Estados de un proceso Durante su vida, un proceso puede pasar por una serie de estados, estos son: Nuevo: El proceso acaba de ser creado, pero todavía no ha sido admitido por el sistema operativo. En ejecución: El proceso ocupa la CPU. Listo: El proceso está listo para ser ejecutado, sólo está esperando que el sistema operativo así lo disponga. Los procesos con este estado se ordenan en una o varias colas de espera. Bloqueado: El proceso no se puede ejecutar hasta que no se produzca un cierto suceso, como una operación de Entrada/Salida. Al igual que antes, los procesos con este estado se ordenan en una o varias colas de espera. Listo y suspendido: El proceso está listo para ser ejecutado, sólo que por falta de memoria principal está alojado en la memoria secundaria. Los procesos con este estado se ordenan en una o varias colas de espera. Tema 1 – Introducción a los Sistemas Operativos Página 7 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Bloqueado y suspendido: El proceso no se puede ejecutar hasta que no se produzca un cierto suceso, como una operación de Entrada/Salida, pero además por falta de memoria principal está alojado en la memoria secundaria. Terminado: El proceso ha finalizado o ha fallado. 3.3. Transiciones de estado de un proceso A continuación, se dan ejemplos de eventos que pueden provocar transiciones de estado en un proceso: Se pasa, por ejemplo, de ejecución a bloqueado, cuando el proceso necesita iniciar una operación de entrada-salida. Se pasa, por ejemplo, de ejecución a listo, cuando el proceso que ocupa la CPU lleva demasiado tiempo ejecutándose y el sistema operativo decide que sea sustituido por otro proceso. Se pasa, por ejemplo, de listo a ejecución, cuando el sistema operativo así lo requiera. Se pasa, por ejemplo, de bloqueado a listo, cuando termina la operación de entrada-salida que originó el bloqueo. 3.4. Planificación de procesos La planificación de procesos se refiere a la manera o técnicas que los sistemas operativos usan para decidir cuando un proceso puede apropiarse de la CPU, y cuánto tiempo puede utilizar dicho recurso. 3.4.1. Objetivos de la planificación Las estrategias de planificación buscan, en general, los siguientes objetivos: Imparcialidad: Todos los procesos son tratados de la misma forma, y en algún momento obtienen su turno de ejecución o intervalos de tiempo de ejecución hasta su terminación exitosa. Productividad: El sistema debe de finalizar el mayor número de procesos posibles en el menor tiempo posible. Rapidez de respuesta: Los usuarios interactivos deben recibir una respuesta en tiempos aceptables. 3.4.2. Variables a tener en cuenta en la planificación de procesos A la hora de elegir un algoritmo de planificación hay que tener en cuenta ciertas variables. Instante de Entrada: es el instante en el que el proceso pasa al estado listo por primera vez. Instante de Salida: es el instante en el que el proceso pasa al estado finalizado. Tiempo de Espera: cantidad de tiempo en el que el proceso ha estado inactivo en estado listo. Tiempo de CPU: cantidad de tiempo en el que el proceso está en ejecución. Tiempo de Respuesta: cantidad de tiempo total desde que entra hasta que sale. Tiempo de Respuesta = Tiempo de CPU + Tiempo de Espera = Instante de Salida – Instante de Entrada Tema 1 – Introducción a los Sistemas Operativos Página 8 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 3.4.3. Algoritmos de planificación de procesos 3.4.3.1. FIFO (First Input First Output, Primero en Entrar Primero en Salir) El algoritmo de planificación de procesos más sencillo es el FIFO (del inglés First Input First Output, Primero en Entrar Primero en Salir) también llamado FCFS (del inglés Fist Come First Served, Primero en Llegar Primero en ser Servido) Este algoritmo elige el proceso que lleva más tiempo listo. Es teóricamente justo, pero ofrece tiempos de espera y de respuesta poco óptimos, penalizando los procesos cortos. Ejemplo: Instante Tiempo Instante Tiempo Tiempo Proceso Entrada CPU Salida Espera Respuesta A 1 3 4 0 3 B 2 6 10 2 8 C 4 4 14 6 10 D 6 5 19 8 13 E 9 2 21 10 12 Tiempo de Espera Medio = (0+2+6+8+10) / 5 = 26 / 5 = 5,2 Tiempo de Respuesta Medio = (3+8+10+13+12) / 5 = 46 / 5 = 9,2 1 5 10 15 20 25 A E E E B L L E E E E E E C L L L L L L E E E E D L L L L L L L L E E E E E E L L L L L L L L L L E E Iniciado E=Ejecución L=Listo 3.4.3.2. SJF (Shortest Job First, Primero el Trabajo más Corto) El algoritmo SJF (del inglés Shortest Job First , Primero el Trabajo más Corto) selecciona para ejecución el trabajo con tiempo estimado de ejecución más corto. Favorece los trabajos cortos sobre los largos lo que reduce los tiempos de espera y de retorno. Sin embargo, requiere de un conocimiento previo del tiempo de ejecución para lo cual se suele confiar en las estimaciones de los programadores y en las estadísticas de procesos similares ejecutados con anterioridad. Tema 1 – Introducción a los Sistemas Operativos Página 9 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Otro problema de este algoritmo es que puede provocar inanición de los procesos largos. Imaginemos un proceso largo que necesite de mucha CPU, si antes de ejecutarse llega un proceso corto, se ejecutará primero el proceso corto, y si justo antes de terminar ese proceso corto llega otro proceso corto, se volverá a ejecutar el nuevo proceso corto y así sucesivamente. Ejemplo: Instante Tiempo Instante Tiempo Tiempo Proceso Entrada CPU Salida Espera Respuesta A 1 3 4 0 3 B 2 6 21 13 19 C 4 4 8 0 4 D 6 5 13 2 7 E 9 2 15 4 6 Tiempo de Espera Medio = (0+13+0+2+4) / 5 = 19 / 5 = 3,8 Tiempo de Respuesta Medio = (3+19+4+7+6) / 5 = 39 / 5 = 7,8 1 5 10 15 20 25 A E E E B L L L L L L L L L L L L L E E E E E E C E E E E D L L E E E E E E L L L L E E Iniciado E=Ejecución L=Listo 3.4.3.3. SRTF (Shortest Remainder Time First, Primero el Tiempo Restante más Corto) El algoritmo SRTF (del Shortest Remainder Time First, Primero el Tiempo Restante más Corto) es una variante del SJF, donde ahora, cada vez que un trabajo entra en la cola de listos, se selecciona para ejecución el trabajo con tiempo restante de ejecución más corto, teniendo en cuenta en que si el tiempo estimado de ejecución del que acaba de entrar es más corto que el tiempo restante de ejecución del proceso que se está ejecutando, el primero se apropia de la CPU. El algoritmo STRF tiene las mismas ventajas e inconvenientes que el SJF, con mejores tiempos medios de espera y retorno. Sin embargo, tiene una sobrecarga mayor que el SJF puesto que debe mantener un registro del tiempo de ejecución de los trabajos parcialmente ejecutados. Tema 1 – Introducción a los Sistemas Operativos Página 10 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Ejemplo: Instante Tiempo Instante Tiempo Tiempo Proceso Entrada CPU Salida Espera Respuesta A 1 3 4 0 3 B 2 6 21 13 19 C 4 4 8 0 4 D 6 5 15 4 9 E 9 2 11 0 2 Tiempo de Espera Medio = (0+13+0+4+0) / 5 = 17 / 5 = 3,4 Tiempo de Respuesta Medio = (3+19+4+9+2) / 5 = 37 / 5 = 7,4 1 5 10 15 20 25 A E E E B L L L L L L L L L L L L L E E E E E E C E E E E D L L E L L E E E E E E E I=Iniciado E=Ejecución L=Listo 3.4.3.4. RR (Round Robin, Rueda de Tiempo) Este algoritmo otorga la CPU por ráfagas de tiempo llamadas quantum. Los procesos se despachan mediante un algoritmo FIFO y si un proceso consume su quantum pasa al final de la cola. Este algoritmo es efectivo en ambientes de tiempo compartido en los cuales el sistema operativo necesita garantizar tiempos de respuesta razonables para usuarios interactivos. El tamaño del quantum es importante para un buen rendimiento. Si el quantum es muy grande degenera en FIFO pues los procesos reciben el tiempo necesario para su finalización. En cambio si el quantum es muy pequeño aumenta la sobrecarga debida al de intercambio de procesos y el rendimiento se degrada. Tema 1 – Introducción a los Sistemas Operativos Página 11 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Ejemplo: Instante Tiempo Instante Tiempo Tiempo Proceso Entrada CPU Salida Espera Respuesta A 1 3 12 8 11 B 2 6 20 12 18 C 4 4 16 8 12 D 6 5 21 10 15 E 9 2 11 0 2 Tiempo de Espera Medio = (8+12+8+10+0) / 5 = 38 / 5 = 7,6 Tiempo de Respuesta Medio = (12+19+13+16+2) / 5 = 62 / 5 = 12,4 1 5 10 15 20 25 A E E L L L L L L L L E B L E E L L L L L L L E E L L L L E E C L E E L L L L L L L E E D L E E L L L L L L L E E L L E E E E I=Iniciado E=Ejecución L=Listo 3.4.3.5. Algoritmos con prioridades En este caso a cada proceso se le asigna una prioridad y el sistema operativo elige de la cola de listos el proceso con mayor prioridad. Mediante la asignación de prioridades se puede influir en el orden de ejecución de aquellos procesos cuyos tiempos de respuesta son críticos. Notar que puede provocar inanición de los procesos de más baja prioridad. Si los trabajos no llegan al mismo tiempo puede suceder que llegue un trabajo con mayor prioridad que el que se está ejecutando. En esta situación se deberá distinguir entre prioridades apropiativas donde el nuevo proceso desplaza al que está en ejecución y prioridades no apropiativas donde el nuevo proceso espera hasta que acabe el proceso en ejecución. 3.4.3.5.1. FIFO con prioridades no apropiativo Ejemplo: Instante Tiempo Instante Tiempo Tiempo Proceso Prioridad Entrada CPU Salida Espera Respuesta A 1 3 5 4 0 3 B 2 6 4 21 13 19 C 4 4 3 8 0 4 D 6 5 1 13 2 7 E 9 2 2 15 4 6 Tiempo de Espera Medio = (0+13+0+2+4) / 5 = 19 / 5 = 3,8 Tema 1 – Introducción a los Sistemas Operativos Página 12 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Tiempo de Respuesta Medio = (3+19+4+7+6) / 5 = 39 / 5 = 7,8 1 5 10 15 20 25 A E E E B L L L L L L L L L L L L L E E E E E E C E E E E D L L E E E E E E L L L L E E I=Iniciado E=Ejecución L=Listo 3.4.3.5.2. FIFO con prioridades apropiativo Ejemplo: Instante Tiempo Instante Tiempo Tiempo Proceso Prioridad Entrada CPU Salida Espera Respuesta A 1 3 5 21 17 20 B 2 6 4 19 11 17 C 4 4 3 15 7 11 D 6 5 1 11 0 5 E 9 2 2 13 2 4 Tiempo de Espera Medio = (17+11+7+0+2) / 5 = 37 / 5 = 7,4 Tiempo de Respuesta Medio = (20+17+11+5+4) / 5 = 57 / 5 = 11,4 1 5 10 15 20 25 A E L L L L L L L L L L L L L L L L L E E B E E L L L L L L L L L L L E E E E C E E L L L L L L L E E D E E E E E E L L E E I=Iniciado E=Ejecución L=Listo 3.4.3.6. Colas multinivel Las situaciones reales son una mezcla bastante diversa de procesos con tiempos de respuesta críticos, procesos muy largos combinados con otros cortos, procesos que requieren mucha CPU, o demandan mucha entrada-salida, etc. Una propuesta para estas situaciones consiste en clasificar los trabajos según sus características y formar colas separadas para cada grupo que serán atendidos con un algoritmo específico. Tema 1 – Introducción a los Sistemas Operativos Página 13 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Una división frecuentemente utilizada es la de formar colas de tareas del sistema, procesos interactivos y procesos por lotes. Las colas tienen distinta prioridad y hasta que la de prioridad más alta no esté vacía no se atienden las colas siguientes. Puesto que esto puede provocar inanición en las colas de baja prioridad lo que se hace es que cuando un proceso en una cola no concluye su ejecución en el tiempo asignado se le pasa a otra cola de menor prioridad. 4. Gestión de memoria La gestión de memoria consiste en la asignación de una memoria física de capacidad limitada a los diversos procesos que la soliciten. En un ambiente multiproceso, en el cual la memoria es un recurso escaso y fuertemente demandado por los procesos, la gestión de memoria realiza las siguientes funciones: Determinar qué proceso se debe asignar. Conocer cuánta memoria necesita un proceso y en qué posiciones se asignará. Contabilizar qué posiciones están asignadas y cuales están libres. Controlar el acceso a los espacios de direcciones de cada proceso, evitando los accesos indebidos a espacios de otros procesos. Si se dispone de mecanismos de intercambio, decidir qué procesos han de abandonar la memoria principal, cuándo y en qué orden, con la finalidad de dejar espacio para otros procesos. Todo ello bajo los requisitos de un desperdicio mínimo de memoria y bajo coste de gestión. El sistema operativo ocupa siempre una parte de la memoria, y el resto estará disponible para el resto de los procesos. Una forma de conseguir multiprogramación consiste en dividir la memoria disponible en partes, cada una de las cuales recibirá un proceso o partes de un proceso. Si todas las partes de un proceso se cargan juntas en la memoria se dice que la asignación es contigua, y si, por el contrario, un programa puede estar en espacios físicamente no continuos, se dice que la asignación es no-contigua. Del primer modelo de memoria revisaremos las particiones estáticas y las dinámicas, y en el segundo caso estudiaremos la paginación y segmentación. Tema 1 – Introducción a los Sistemas Operativos Página 14 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 4.1. Particiones estáticas Consiste en la división de la memoria en zonas de igual o diferente tamaño, de forma que en cada una de ellas se pueda ejecutar un proceso diferente. Esta división se realiza al principio (en general en el tiempo de arranque), y las particiones quedan fijas a partir de ese momento. Cuando se crean lo ideal es encontrar una buena correspondencia entre el tamaño de las particiones y las necesidades de memoria de los trabajos. Si un trabajo necesita N bytes de memoria, podrá ejecutarse en cualquier partición de M bytes tal que M>=N, quedando (M-N) bytes sin utilizar. A esta memoria sin utilizar se le denomina fragmentación interna. Otras veces lo que sucede es que una partición es demasiado pequeña para contener el programa que está en la cola para ser ejecutado, en cuyo caso el programa no puede ser ejecutado y la partición permanece desocupada. Esto recibe el nombre de fragmentación externa. 4.2. Particiones dinámicas En un sistema de particiones dinámicas la descomposición en particiones no se define desde el inicio, sino que se va redefiniendo cada vez que un proceso llega a memoria y cuando finaliza su ejecución. Al inicio, cuando toda la memoria está disponible, se crean particiones del tamaño del proceso solicitante hasta que se llena la memoria o hasta que el programa que debe entrar es más grande que lo disponible. Después, a medida que salen procesos de memoria dejando espacio libre, se crean particiones en dichos espacios libres del tamaño de los procesos entrantes. En cualquier caso ningún proceso ocupa más espacio del que necesite y sólo existirá espacio desaprovechado cuando el proceso entrante sea mayor que la zona de memoria libre. En otras palabras, sólo existirá fragmentación externa. 4.2.1. Compactación Después de diversas asignaciones y liberaciones la memoria libre puede encontrarse dividida en pequeños bloques distribuidos a lo largo del espacio de direcciones. Esta fragmentación reduce el tamaño máximo de bloque que un proceso puede solicitar. Si no hay suficiente espacio libre continuo, el gestor puede realizar una reubicación de los bloques asignados uniéndolos entre sí para obtener un bloque libre mayor. Esta técnica llamada compactación es una forma de maximizar el uso de memoria, sin embargo, existen otros problemas asociados: problemas de eficiencia pues el sistema operativo tiene que mover los bloques de memoria y es una tarea que toma una considerable cantidad de tiempo; otro problema es que las direcciones de memoria cambian y hay que actualizar todos los punteros a direcciones memoria que se guardan. Tema 1 – Introducción a los Sistemas Operativos Página 15 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 4.3. Paginación Las particiones, ya sean estáticas o dinámicas, son relativamente simples de implementar, sin embargo, sufren de problemas relacionados con la aparición de fragmentación interna y/o externa, que no son más que desperdicios de memoria. La fragmentación es un problema de encaje: cada proceso tiene sus propias necesidades de memoria y éstas pueden diferir mucho entre ellas. Por esta razón, en el caso de particionado estático es muy difícil decidir la mejor combinación de tamaños de partición produciendo la asignación de particiones mayores a las necesidades de los procesos (fragmentación interna), y en el caso de particionado dinámico, es necesario consumir muchos recursos para reorganizar la memoria debido a la frecuente aparición de huecos intermedios sin utilizar. La gestión de memoria paginada está basada en ambas ideas: la división del espacio lógico de direcciones en trozos del mismo tamaño y en la asignación de memoria física no-contigua, es decir, que los diversos trozos en que ha sido dividido el espacio lógico pueden situarse de forma dispersa a lo largo de la memoria física. Para dicha gestión se divide el proceso en trozos iguales llamados páginas, y la memoria física en zonas de igual tamaño llamados encuadres, bloques o marcos de página. Cualquier página es asignada a cualquier encuadre y si bien cada página es lógicamente contigua, los encuadres correspondientes no lo son necesariamente. Puesto que cada página lógica se puede ubicar en cualquier página física es necesaria una tabla de paginas que establezca, para cada página lógica, cual es el marco de página físico dónde está localizada. Memoria Tabla de páginas 1 Proceso Página Dirección 2 A 1 4 3 Proceso A 2 7 4 A A 3 8 5 B B 1 10 6 C B 2 2 7 C 1 5 8 C 2 6 9 C 3 11 10 C 4 1 11 12 Cuando hay que asignar un proceso de tamaño T, el sistema operativo debe asignar T/p (entero por exceso) encuadres libres, siendo p el tamaño de página y de encuadre. Observe que se puede producir una pequeña fragmentación interna en la última página llamada en este caso fragmentación de página. El tamaño de página influye en esta fragmentación, a menor tamaño menor fragmentación, pero a cambio se requieren tablas de página más grandes. Determinado el número de encuadres necesarios, se buscan los encuadres libres y se carga el proceso construyendo la tabla de páginas de dicho proceso. El número de página lógica se usa como índice para acceder a la tabla de páginas del proceso, en la cual se anota el marco de página en la memoria física en la que ha sido cargada la página. Tema 1 – Introducción a los Sistemas Operativos Página 16 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Cuando un proceso finaliza su ejecución, todos los marcos de páginas que le habían sido asignados regresan al conjunto de marcos de páginas libres para ser asignados a otros procesos. El modelo es muy efectivo en cuanto a la mejora en la utilización de la memoria (se elimina la fragmentación externa y la fragmentación interna se reduce a la última página del proceso). 4.4. Segmentación En la línea de resolver estos problemas y minimizar aquellos debidos al encaje, otra de las formas de dividir el espacio lógico de un proceso es en segmentos. Un segmento es una entidad lógica que agrupa conjuntos de la misma naturaleza (por ejemplo, código y datos). De esta forma, el espacio lógico de un proceso es dividido en segmentos, de diferente tamaño. La traducción de direcciones debe ahora contemplar la localización de cada segmento en memoria, siendo el espacio de cada segmento continuo, pero los segmentos pueden estar dispersos en memoria física. Para ello se utiliza una tabla de segmentos, y como el número de segmentos de un proceso es mucho menor que el de posibles páginas, la tabla de traducción es ahora bastante más pequeña. 4.5. Segmentación paginada Siendo los segmentos entidades lógicas es más simple protegerles. Sin embargo, no es difícil observar que con este modelo reaparecen los problemas de encaje (aunque a menor escala puesto que los segmentos son de menor tamaño que el proceso entero). Una solución más general que intenta aprovechar las ventajas de la segmentación y de la paginación consiste en los modelos de segmentación paginada, en la cual, cada segmento es a su vez dividido en páginas (para facilitar el encaje) manteniendo las ventajas aportadas por la división lógica (protección) y sin problemas de encaje. A cambio, la traducción es más cara puesto que hay que traducir el segmento y a continuación la página dentro del segmento. Memoria Tabla de páginas 1 Segmento Página Dirección 2 A.Código 1 1 3 Tabla de segmentos A.Código 2 6 4 Proceso Segmento A.Datos 1 8 5 Proceso A A.Código A.Datos 2 2 6 A A A.Datos A.Datos 3 4 7 B B B.Código B.Código 1 9 8 C B B.Datos B.Datos 1 11 9 C C.Código B.Datos 2 12 10 C C.Datos C.Código 1 13 11 C.Código 2 10 12 C.Datos 1 7 13 14 Puedes consultar el vídeo: https://www.youtube.com/watch?v=hMhPTWUJX_M Tema 1 – Introducción a los Sistemas Operativos Página 17 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 5. Gestión de memoria virtual Los modelos de gestión de memoria no contigua resuelven buena parte de los problemas de fragmentación y de asignación de memoria que se presentan en los modelos contiguos, a cambio de un mayor coste en la gestión. Sin embargo, quedan al menos dos preguntas no resueltas por estos modelos: ¿qué hacer con los procesos que requieren más memoria que la instalada?, y ¿cómo incrementar el grado de multiprogramación del sistema permitiendo ejecutar más procesos de los que caben físicamente en memoria? 5.1. Definición de memoria virtual La solución definitiva y adoptada como estándar en los sistemas operativos modernos consiste en el uso de memoria virtual. Con ella el sistema operativo crea la ilusión de una memoria más grande de la que existe físicamente, permitiendo a los procesos hacer referencia a un espacio de direcciones mayor que el físico. Para poder manejar un espacio de direcciones más grande que la memoria física instalada es necesario que este espacio de direcciones no resida completamente en memoria (no cabría), en otras palabras, el proceso no está entero en memoria. La pregunta inmediata es ¿y cómo se procede cuando un proceso hace referencia a unas posiciones lógicas que no se encuentran en memoria? La respuesta es simple y potente: el espacio completo del proceso reside en disco (swap) y la parte que se necesita se lleva a memoria principal, retirando de ellas las que no sean necesarias en ese momento. 5.2. Algoritmos de remplazo de páginas El esquema de memoria virtual paginado es el más difundido (ya sea sólo paginación o segmentación paginada). Cada proceso se representa por un conjunto de direcciones dividido en una colección de páginas virtuales de igual tamaño, mientras que la memoria física también se divide en partes de igual tamaño llamadas marcos de página. Sobre cualquier marco físico es posible ubicar cualquier página virtual. Las páginas virtuales de un proceso son lógicamente contiguas, pero los marcos de página física que le son asignados no tienen por qué serlo. Hasta ahora este esquema es equivalente al modelo de paginación con programa completo en memoria visto anteriormente. Ahora bien, ¿qué hacer cuando no existen marcos libres en memoria principal y un proceso requiere de alguno de ellos para cargar sus páginas? Para resolver este problema es necesario recurrir a los algoritmos de remplazo, que deben elegir uno de los marcos en memoria para ser reemplazada por la página solicitada. Para ello se crean una serie de algoritmos como: Óptimo: Este algoritmo de remplazo sustituye la página que tenga que esperar más tiempo para ser referenciada. LRU (Least Recently Used, Usada Menos Recientemente) El algoritmo de remplazo LRU (del inglés Least Recently Used, Usada Menos Recientemente), sustituye la página que ha sido referenciada hace más tiempo. Tema 1 – Introducción a los Sistemas Operativos Página 18 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos FIFO (First Input First Output, Primero en Entrar Primero en Salir) El algoritmo de remplazo de páginas más sencillo es el FIFO (del inglés First Input First Output, Primero en Entrar Primero en Salir) también llamado FCFS (del inglés Fist Come First Served, Primero en Llegar Primero en ser Servido. Con este algoritmo se sustituye la página que lleve más tiempo en la memoria. 6. Gestión de entrada-salida La gestión de entrada-salida proporciona los medios para que se traten los distintos dispositivos de manera uniforme conservando las particularidades de cada dispositivo. 6.1. Problemas asociados a la gestión de entrada-salida 1. El primer problema con el que tiene que lidiar el sistema operativo es que las peticiones de entrada- salida, a diferencia que la comunicación CPU-Memoria, se hacen de forma asíncrona, es decir, desde que la CPU invoca una operación de entrada-salida hasta que esta se lleva a cabo, pasa un tiempo considerable, tiempo que por lo general, la CPU no conoce. 2. Otro problema con el que tiene que lidiar la gestión de entrada-salida, es con las diferentes velocidades (de varias magnitudes) de los distintos dispositivos de entrada-salida. 3. La gestión de entrada-salida tiene el problema añadido de que la forma de comunicación no es igual para todos los dispositivos de entrada-salida, en unos la comunicación es bit a bit (serie), y en otros la comunicación es byte a byte (paralelo), y además cada dispositivo entiende una serie de órdenes y mensajes de error que no tienen por que entender otros. 6.2. Evolución histórica de la gestión de entrada-salida 1. Al principio, era la CPU quien controlaba directamente todos los dispositivos periféricos, con los citados problemas que ello conllevaba. 2. Luego se añadió un controlador o módulo de entrada-salida, de forma que el procesador se aislaba de los detalles específicos de los dispositivos externos, pero se seguía utilizando la gestión de entrada-salida programada, es decir la CPU mandaba una orden de entrada-salida y esperaba a que terminase, con la correspondiente pérdida de tiempo. 3. Para intentar solucionar el problema de la pérdida de tiempo, se añadieron las interrupciones. En este caso cuando un proceso necesita del módulo de entrada-salida, la CPU manda una orden de entrada-salida y continúa con la ejecución de otro proceso. Cuando el dispositivo externo completa su trabajo el módulo de entrada-salida interrumpe la CPU para que termine la ejecución del proceso. 4. Luego apareció el DMA (del Inglés Direct Memory Acces, o Acceso Directo a Memoria) con el que se da libertad al módulo de entrada-salida para que este pueda escribir directamente en la memoria sin necesidad de la CPU, la cual sólo interviene al principio y al final de la transferencia. 5. Después, para aligerar de trabajo a la CPU, se crearon procesadores de entrada-salida con instrucciones propias. De esta forma la CPU especifica una secuencia de instrucciones de entrada y salida, delega en el procesador de entrada-salida y se desentiende hasta que termine. 6. Por último, a dichos procesadores de entrada-salida se le añade memoria independiente, de tal forma que el módulo de entrada-salida se convierte en una especie de ordenador independiente, con lo que la CPU es liberada cada vez más de la gestión de entrada-salida aumentando su rendimiento. Tema 1 – Introducción a los Sistemas Operativos Página 19 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 7. Gestión de discos duros Los discos duros son los dispositivos de entrada-salida más importantes del ordenador. En ellos se guarda toda la información no volátil, y sirve también de memoria secundaria gracias a la memoria virtual. Un disco duro, está formado principalmente por una serie de discos montados en un eje, y de un cabezal pivotante para cada una de las caras de dichos discos. Cada cara del disco se divide mediante círculos concéntricos en pistas. A su vez cada pista se divide en sectores. A la agrupación de varios sectores se le conoce como cluster. Y a la agrupación de todas las pistas de todos las caras de todos los discos de mismo radio se le denomina cilindro. 7.1. Algoritmos de acceso a disco En sistemas multiprogramados los procesos pueden generar peticiones de lectura/escritura en las unidades de memoria secundaria con frecuencia mayor a la que pueden ser atendidas por los discos de cabeza móvil, por lo cual es necesario gestionar colas o listas de espera de dichas peticiones. La gestión de las peticiones contempla debe de: Ser equitativa, es decir la asignación del servicio debe respetar en alguna medida el orden de llegada de las peticiones. Proporcionar una buena capacidad de ejecución, lo cual se mide en el número de peticiones servidas por unidad de tiempo. Proporcionar un tiempo medio de respuesta aceptable. Ser predecible, es decir según haya más carga de trabajo mayor deberá de ser el tiempo de respuesta, siempre de una forma proporcional. 7.1.1. FIFO (First Input First Output, Primero en Entrar Primero en Salir) El algoritmo de acceso a disco más sencillo es el FIFO (del inglés First Input First Output, Primero en Entrar Primero en Salir) también llamado FCFS (del inglés Fist Come First Served, Primero en Llegar Primero en ser Servido) Este algoritmo procesa las peticiones de la cola en un orden secuencial. Este algoritmo es intrínsecamente justo, pero generalmente no proporciona el servicio más rápido. Si hay pocos procesos que requieren acceso y las peticiones son a pistas cercanas, se puede esperar un buen rendimiento. Sin embargo, si hay muchos procesos compitiendo por el disco y las peticiones son a pistas muy distantes el movimiento del cabezal es por lo general mayor que con otros algoritmos. Tema 1 – Introducción a los Sistemas Operativos Página 20 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Consideremos por ejemplo un disco con 200 pistas, donde el cabezal se encuentra situado en la pista 53, y una cola de peticiones con solicitudes de entrada-salida a sectores en las siguientes pistas: 98, 183, 37, 122, 14, 124, 65, 67 El cabezal recorrerá un total de 640 pistas para satisfacer la cola de peticiones. La siguiente figura muestra las oscilaciones del cabezal. Como vemos el problema de este algoritmo es la gran oscilación del cabezal. Tiene que ir de la pista 37 a la 122, luego de la 122 a la 14 para volver luego de la 14 a la 124. Si las solicitudes de las pistas 37 y 14 pudieran atenderse juntas, antes o después de las solicitudes en 122 y 124, el movimiento total del cabezal podría reducirse considerablemente. 7.1.2. SSTF (Short Seek Time First, Primero el Menor Tiempo de Búsqueda) Intentando mejorar el algoritmo anterior, surge el algoritmo SSTF (del inglés Short Seek Time First, Primero el Menor Tiempo de Búsqueda) Es decir, consiste en elegir la solicitud que requiera el menor movimiento del cabezal desde una petición a otra. Siguiendo el mismo ejemplo que el anterior, en este caso el cabezal iría de la pista inicial 53 a la más cercana, osea a la 65. Una vez en la 65, la siguiente solicitud más cercana está en la pista 67 y así sucesivamente. Con este algoritmo el cabezal recorrerá un total de 236 pistas para satisfacer la cola de peticiones, reduciendo considerablemente su movimiento con respecto al algoritmo anterior. La siguiente figura muestra las oscilaciones del cabezal. Tema 1 – Introducción a los Sistemas Operativos Página 21 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Lo malo de esta técnica es que puede provocar inanición de algunas solicitudes. Las solicitudes pueden llegar en cualquier momento. Supongamos que tenemos dos solicitudes en cola de las pistas 14 y 186, y mientras se está dando servicio a la solicitud 14, llega una nueva solicitud cercana a esta pista y luego otra y otra. En teoría podría llegar un flujo continuo de solicitudes cercanas a la pista 14 haciendo que la solicitud de la pista 186 espere indefinidamente. Este escenario se vuelve cada vez más probable si crece mucho la cola de solicitudes. Además, aun cuando el algoritmo SSTF presenta una mejora considerable sobre el algoritmo FIFO, no es óptimo. En el ejemplo, podemos mejorar el proceso moviendo la cabeza de la pista 53 a la 37, aun cuando la 37 no es la más cercana, y luego a la 14, antes de dar la vuelta para atender a las pistas 65, 67, 98,... Esta estrategia reduciría el movimiento total de la cabeza a 208 pistas. 7.1.3. SCAN Con este algoritmo, el cabezal comienza en un extremo del disco, y se mueve hacia el otro extremo, atendiendo solicitudes a medida que llega a cada una de las pistas en cuestión. Cuando llega al final la dirección del movimiento del cabezal se invierte, y el servicio continúa. El cabezal explora pues continuamente el disco hacia adelante y hacia atrás. Con respecto a nuestro ejemplo, necesitamos conocer la dirección del movimiento de la cabeza, además de su posición actual. Si el brazo del disco se está moviendo hacia 0, la cabeza dará servicio a primero a la pista 37 y luego a la 14. En la pista 0, el brazo dará la vuelta y se moverá hacia el otro extremo del disco, atendiendo las solicitudes 65, 67, 98, 122, 124 y 183. La siguiente figura muestra las oscilaciones del cabezal. Este algoritmo es conocido como “el algoritmo del ascensor”, ya que el cabezal se comporta igual que un ascensor, atendiendo primero las solicitudes hacia arriba, y luego dando la vuelta para atender las solicitudes hacia abajo. Con este algoritmo, si una solicitud llega a la cola justamente en frente del cabezal será atendida casi inmediatamente. En cambio, si llega justo detrás del cabezal tendrá que esperar hasta que vaya al final del disco, cambie de dirección y regrese. Con este algoritmo sucede que cuando el cabezal llega a uno de los extremos e invierte su desplazamiento hay relativamente pocas solicitudes por atender ya que estas pistas acaban de ser servidas y en el otro extremo esperan un gran número de solicitudes que además son las llevan más tiempo esperando. Tema 1 – Introducción a los Sistemas Operativos Página 22 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos 7.1.4. C-SCAN Para solucionar este problema surgió el algoritmo C-SCAN o SCAN circular. Este algoritmo intenta conseguir un tiempo de espera más uniforme. Al igual que SCAN, el cabezal se mueve de un extremo del disco al otro atendiendo solicitudes durante su recorrido. Sin embargo, cuando el cabezal llega al otro extremo inmediatamente regresa al inicio del disco sin atender ninguna solicitud en el viaje de regreso. Con respecto a nuestro ejemplo, ahora el cabezal sólo sirve las solicitudes que van de la pista 0 a pistas mayores. Empezando en la pista inicial 53, servirá la pista 65, 67 y así sucesivamente hasta que llega a la pista 199. En ese punto el cabezal irá directamente a la pista 0 y volverá a ir sirviendo las pistas que se valla encontrando en su camino hacia pistas mayores. La siguiente figura muestra las oscilaciones del cabezal. Ahora, como en el caso anterior, si una solicitud llega a la cola justamente en frente del cabezal será atendida casi inmediatamente, pero, a diferencia del caso anterior, las solicitudes que llegan justo detrás del cabezal sólo tienen que esperar hasta que vaya al final del disco y vuelva al principio. 7.1.5. LOOK Este algoritmo es igual que el SCAN, sólo que ahora el cabezal no va hasta el final del disco, sólo va hasta la última solicitud en cada dirección y luego invierte el sentido inmediatamente. Con respecto a nuestro ejemplo, ahora el cabezal empieza en la pista inicial 53, sirve las pistas 37 y 14 y acto seguido cambia de dirección y sirve las pistas restantes. La siguiente figura muestra las oscilaciones del cabezal. 7.1.6. C-LOOK Este algoritmo es igual que el C-SCAN, sólo que ahora el cabezal no va hasta el final del disco, sólo va hasta la última solicitud y luego vuelve inmediatamente a la primera solicitud. Tema 1 – Introducción a los Sistemas Operativos Página 23 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Con respecto a nuestro ejemplo, ahora el cabezal empieza en la pista inicial 53, sirve las pistas 65, 67 y así sucesivamente hasta que sirve la última pista en esta dirección, la 183. Acto seguido vuelve a la primera solicitud, la 14 y continúa sirviendo la 37. La siguiente figura muestra las oscilaciones del cabezal. 8. Gestión de ficheros El sistema de ficheros es la parte del sistema de administración del almacenamiento responsable de la gestión de archivos en el almacenamiento secundario (no sólo discos duros, también pueden ser pendrives, archivos en red, etc.). Debe suministrar un almacenamiento "privado" y a la vez "compartido" de la información entre los usuarios del sistema. El sistema debe proporcionar soporte a operaciones que tratan un fichero como una unidad (open, close, create, remove, copy, rename, etc); y a operaciones que tratan unidades básicas de información (read, write, update, insert, delete, etc). Podemos describir una lista más o menos detallada de estos requerimientos: Crear, modificar, borrar archivos. Renombrar, mover archivos. Compartir archivos. Control de acceso en archivos compartidos. Transferencia de datos entre archivos. Independencia del dispositivo. Posibilidad de cifrado/descifrado de datos. Proporcionar al usuario una visión lógica de sus archivos. Los objetivos más importantes en la implementación de un sistema de archivos son: Optimizar el rendimiento mediante un acceso rápido para recuperar la información contenida en archivos: No se debe ralentizar el sistema en general por una deficiente gestión de los medios de almacenamiento, discos duros. Fácil actualización: Los cambios (añadir, borrar y modificar) no deben suponer una tarea complicada para el usuario y las aplicaciones. Economía de almacenamiento: Intentar que los archivos desperdicien la menor cantidad de espacio en disco posible. Es muy importante evitar la fragmentación de los discos. Mantenimiento sencillo: Evitar las operaciones complicadas a usuarios y programas, ocultando los detalles y proporcionando un acceso estandarizado a los archivos. Fiabilidad para asegurar la confianza en los datos: Deben proveer sistemas que aseguren que los datos escritos o leídos (entradas/salidas) sean correctos y fiables. También se debe minimizar o eliminar la posibilidad de pérdida o destrucción de datos. Tema 1 – Introducción a los Sistemas Operativos Página 24 de 25 Desarrollo de Aplicaciones Multiplataforma Sistemas Informáticos Incorporar mecanismos de seguridad y permisos: Esto es especialmente importante en sistemas de archivos de sistemas operativos multiusuario. Se debe poder proteger los archivos de un usuario del acceso de los demás usuarios. Por ejemplo estableciendo permisos de escritura, lectura o ejecución. Control de concurrencia: Se debe controlar y asegurar el acceso correcto a los archivos por parte de varios usuarios a un tiempo, posiblemente bloqueando el archivo en uso hasta que termine la operación de modificación en curso. Tema 1 – Introducción a los Sistemas Operativos Página 25 de 25