Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Evaluame mis contribuciones a la wiki

2013-01-21T17:25:16Z

Rafgomgal1:

A continuación, indica tu nombre y apellidos:

* Juan Carlos Roldán Salvador
* Daniel Ayala Hernández
* Daniel de los Reyes Leal
* Olga Minerva Moreno Martín IS-G1
* Vanessa Chipirrás Navalón IC
* Alejandro Sánchez Medina IS-G1
* Francisco Javier Borrego Cejudo IC-G2
* Samuel Martin Arenas IC-G2
* Álvaro Fernández García IS-G1
* Rafael Gomez Galbarro GIC2
*María Pérez Reina

Evaluame mis contribuciones a la wiki

2013-01-19T16:33:22Z

Rafgomgal1:

A continuación, indica tu nombre y apellidos:

* Juan Carlos Roldán Salvador
* Daniel Ayala Hernández
* Daniel de los Reyes Leal
* Olga Minerva Moreno Martín IS-G1
* Vanessa Chipirrás Navalón
* Alejandro Sánchez Medina IS-G1
* Francisco Javier Borrego Cejudo IC-G2
* Samuel Martin Arenas IC-G2
* Álvaro Fernández García IS-G1
* Rafael Gomez Galbarro

Ejercicios de paginación y segmentación

2012-12-21T00:37:58Z

Rafgomgal1: /* Ejercicio 1 */

==Ejercicio 1==

El proceso ocupa: 1 KB de código, 4 KB de pila, 5KB ctes+globales

*Paginación pura (4KB de páginas) = 4 páginas -> 16 KB
El código requiere 1 página
La pila otra al completo
Las globales necesitan 2

*Segmentación pura = 3 segmentos, ocupan 10KB
El codigo ocupa un segmento de 1 KB
La pila uno de 4 KB
Para globales es otro de 5KB

*Combinado = 1 segmento de 4 páginas -> 16 KB

== Ejercicio 2==
''[Este ejercicio formó parte del tercer Control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

Suponga un sistema operativo con un administrador de memoria paginada cuyo tamaño de página es de 8KB. Se conoce que el sistema operativo funciona sobre un procesador cuyo tamaño de palabra es de 64 bits.

'''A)''' Calcule el tamaño máximo que puede llegar a alcanzar la tabla de página de un proceso, suponiendo que cada entrada de la tabla de páginas ocupa 128 bits.

'''B)''' Calcule cuántas páginas puede llegar a ocupar como máximo la tabla de páginas.

'''C)''' Dado un proceso en ejecución que requiere 7 Mbytes, calcule cuántas entradas de la tabla de páginas están siendo empleadas por dicho proceso en el sistema descrito anteriormente.

(''[[Solución de los ejercicios de paginación y segmentación#Ejercicio 2|Ver solución]]'')

PD: Podrían colocar todos los ejercicios del examen C3, y aquel que sepa las soluciones que las coloque si es tan amable.
-----------

¿Alguien recuerda los ejercicios que se pusieron en el tercer parcial? El ejercicio tipo test, y el de las 2 preguntas de pensar un poco.

== Ejercicio 3 ==
Tenemos 3 procesos (P1,P2 y P3): P1 ocupa 1KB, P2 ocupa 4 KB y P3 ocupa 2 KB.
El tamaño de las páginas es de 4 KB.
¿Cuál es el desperdicio interno?

*Del proceso 1 desperdiciamos: 4 KB - 1 KB = 3 KB
*Del proceso 2 no desperciamos nada.
*Del proceso 3 desperdiciamos: 4 KB - 2 KB = 2 KB
*Desperdicio intero total: 3 KB + 2 KB = 5 KB

Ejercicios de paginación y segmentación

2012-12-21T00:35:40Z

Rafgomgal1: /* Ejercicio 1 */

==Ejercicio 1==

El proceso ocupa: 1 KB de código, 4 KB de pila, 5KB ctes+globales

*Paginación pura (4KB de páginas) = 4 páginas -> 16 KB
El código requiere 1 página
La pila otra al completo
Las globales necesitan 2

*Segmentación pura = 3 segmentos, ocupan 10KB
El codigo ocupa un segmento de 1 KB
La pila uno de 4 KB
Para globales es otro de 5KB

*Combinado = 1 segmento de 4 páginas -> 16 KB

El tamaño de página sería 4KB. ¿Cierto?

== Ejercicio 2==
''[Este ejercicio formó parte del tercer Control de Evaluación Continua del curso 2010/11, del 8 de junio de 2011]''

Suponga un sistema operativo con un administrador de memoria paginada cuyo tamaño de página es de 8KB. Se conoce que el sistema operativo funciona sobre un procesador cuyo tamaño de palabra es de 64 bits.

'''A)''' Calcule el tamaño máximo que puede llegar a alcanzar la tabla de página de un proceso, suponiendo que cada entrada de la tabla de páginas ocupa 128 bits.

'''B)''' Calcule cuántas páginas puede llegar a ocupar como máximo la tabla de páginas.

'''C)''' Dado un proceso en ejecución que requiere 7 Mbytes, calcule cuántas entradas de la tabla de páginas están siendo empleadas por dicho proceso en el sistema descrito anteriormente.

(''[[Solución de los ejercicios de paginación y segmentación#Ejercicio 2|Ver solución]]'')

PD: Podrían colocar todos los ejercicios del examen C3, y aquel que sepa las soluciones que las coloque si es tan amable.
-----------

¿Alguien recuerda los ejercicios que se pusieron en el tercer parcial? El ejercicio tipo test, y el de las 2 preguntas de pensar un poco.

== Ejercicio 3 ==
Tenemos 3 procesos (P1,P2 y P3): P1 ocupa 1KB, P2 ocupa 4 KB y P3 ocupa 2 KB.
El tamaño de las páginas es de 4 KB.
¿Cuál es el desperdicio interno?

*Del proceso 1 desperdiciamos: 4 KB - 1 KB = 3 KB
*Del proceso 2 no desperciamos nada.
*Del proceso 3 desperdiciamos: 4 KB - 2 KB = 2 KB
*Desperdicio intero total: 3 KB + 2 KB = 5 KB

Ejercicios administración de memoria contigua

2012-12-21T00:23:43Z

Rafgomgal1: /* Ejercicio 1 */

=Ejercicios Clase=

==Ejercicio 1==
Ejercicio visto el martes 29 de Noviembre de 2011 en clase.

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 3 |
P2 | 1 | 4 | 1 |
P3 | 2 | 5 | 2 |
P4 | 3 | 2 | 9 |
P5 | 4 | 1 | 15 |

Y la siguiente configuración de memoria:
_____
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

a) Determina el cronograma del Mejor Ajuste Estático [[solución Ejercicio clase Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[Solución Ejercicio clase Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución Ejercicio clase Mejor Ajuste Dinámico|Ver solución]]

El mejor ajuste estático y el mejor ajuste dinámico no se estudian en el presente curso (12/13)

==Ejercicio 2==
Segundo ejercicio visto el martes 29 de Noviembre de 2011 en clase.

Dada la siguiente configuración de procesos:

| H0 | t | M |
---------------------
P1 | 0 | 4 | 2 |
P2 | 0 | 4 | 1 |
P3 | 0 | 5 | 3 |
P4 | 0 | 2 | 8 |
P5 | 0 | 1 | 7 |

Aunque todos llegan en el mismo instante de tiempo, suponga el siguiente orden de llegada: 1º P1, 2º P2, 3º P3, 4º P4 y 5º P5.

Y la siguiente configuración de memoria:
_______
|_____| A = 4kB
|_____| B = 4kB
| |
|_____| C = 8kB
| |
| |
| | D = 16kB
|_____|

Calcula los cronogramas tal y como se hizo en el ejercicio anterior.

a) Determina el cronograma del Mejor Ajuste Estático [[solución ejercicio2 Mejor Ajuste Estático|Ver solución]]

b) Determina el cronograma Primer ajuste [[solución ejercicio2 Primer Ajuste|Ver solución]]

c) Determina el cronograma del Mejor Ajuste Dinámico [[solución ejercicio2Mejor Ajuste Dinámico|Ver solución]]

Corregido --[[Usuario:Pneira|Pneira]] 15:55 22 dic 2011 (UTC)

Los apartados a y c de los ejercicios no se imparte en el temario del año 2012-2013 --[[Usuario:jescordia|jescordia]] 11:16 17 dic 2012

Ejercicios sincronización y comunicación

2012-12-13T11:11:36Z

Rafgomgal1: /* Ejercicio 7 */

= Ejercicio 1 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
if (get(s1) == 0) /* #4 */
up(s2); /* #5 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las líneas de código toman el mismo tiempo de ejecución.
* La función get(semáforo s) devuelve el valor del contador del semáforo.

El cronograma deberá incluir qué línea de código se ejecuta en cada unidad de ejecución.

[[solución ejercicio 1|Ver solución del ejercicio 1]]

= Ejercicio 2 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s2); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 2|Ver solución del ejercicio 2]]

= Ejercicio 3 =

En un exámen de sistemas operativos, un estudiante plantea la siguiente solución basada en dos procesos, un proceso P1 productor y un proceso P2 consumidor, en el que el contador de los semáforos s1 y s2 valen inicialmente 0.

<source lang="c">
while(1) {
down(s1);
produce();
up(s2);
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
while(1) {
down(s2);
consume();
up(s1);
}
</source>

Responda brevemente si la solución que propone es idónea justificando su respuesta.

[[solución ejercicio 3|Ver solución del ejercicio 3]]

= Ejercicio 4 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
send(msg, P2); /* #2 */
recv(msg, P2); /* #3 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
recv(msg, P1); /* #2 */
send(msg, P1); /* #3 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
* El comportamiento de la primitiva send() es síncrono y el la primitiva recv() es bloqueante.
* Suponga que msg contiene un mensaje que se emplea como testigo y cuyo contenido no tiene relevancia.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 4|Ver solución del ejercicio 4]]

= Ejercicio 5 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s2); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s1); /* #4 */
}
</source>

Para el semáforo s1 el contador vale 1, mientras que para el semáforo s2 el contador vale 0.

Suponga que:

* El planificador emplea turno rotatorio estricto, con quantum ilimitado, por tanto, un proceso se mantiene en estado activo hasta que realice una operación bloqueante.
* Se sabe que el proceso P2 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 5|Ver solución del ejercicio 5]]

= Ejercicio 6 =

Dado dos procesos P1 y P2 cuyos códigos son los siguientes:

Código del Proceso 1:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
send(msg); /* #2 */
f(msg); /* #3 */
recv(msg); /* #4 */
}
</source>

Código del Proceso 2:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
recv(msg); /* #2 */
f(msg); /* #3 */
send(msg); /* #4 */
}
</source>

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
* El comportamiento de la primitiva send() es asíncrono y el de la primitiva recv() es bloqueante.
* Suponga que msg contiene un mensaje inicialmente bien formado cuyo contenido no tiene relevancia

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 6|Ver solución del ejercicio 6]]

= Ejercicio 7 =

En base a dos hilos h1 y h2 de un mismo proceso P cuyos codigos son los siguientes:

En el hilo h1 se ejecuta el siguiente código:

<source lang="c">
for (int i = 0; i<2; i++){ //#1
while(cerrojo_p2); //#2
cerrojo_p1 = 1; //#3
f(); //#4
cerrojo_p1 = 0; //#5

}
</source>

<source lang="c">
for (int i = 0; i<2; i++){ //#1
while(cerrojo_p1); //#2
cerrojo_p2 = 1; //#3
f(); //#4
cerrojo_p2 = 0; //#5

}
</source>
Proponga una solución en la que se reemplacen los cerrojos por semáforos. Realice el cronograma temporal de ejecución de la solución que propone.

Siendo cerrojo_p1 y cerrojo_p2 variables globales inicialmente a cero.
Inicialmente, el semáforo s1 es 1 y el semáforo s2 es 0.

[[Usuario:Migoligon|Migoligon]] 17:57 4 dic 2011 (UTC)Creí que en el ejercicio 3 quedó claro que no debian iniciarse ambas a 0 porque era un error garrafal. Y ahora me encuentro esto y en las soluciones no diferencia s1 de s2, además de que la solución está preparada para que sea s1 = 1 y s2 = 0 no se de donde han sacado los datos para hacer la solución pero no creo que desde aqui.

Supongamos que:
*El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
*Se sabe que el hilo h1 es seleccionado en primer lugar por el planificador para ejecutarse.
*La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.
el planificador

[[Usuario:Juacordia|Juacordia]] 16:33 5 dic 2011

Hola [[Usuario:Migoligon|Migoligon]] creo que estas confundiendo cerrojos por semaforos, una cosa es que los semaforos no puedan estar inicializados a cero y otra son los cerrojos. Espero haberte ayudado. PD: Los semaforos puedes ponerlos de otra manera.

[[solución ejercicio 7|Ver solución del ejercicio 7]]

= Ejercicio 8 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s1); /* #2 */
f1(); /* #3 */
up(s1); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s2); /* #2 */
f2(); /* #3 */
up(s2); /* #4 */
}
</source>

Suponiendo que los contadores de los semáforos s1 y s2 valen 1.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 8|Ver solución del ejercicio 8]]

= Ejercicio 9 =

Realice el cronograma temporal que represente la ejecución de dos procesos P1 y P2. El proceso P1 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s); /* #2 */
f1(); /* #3 */
up(s); /* #4 */
}
</source>

Y el proceso P2 ejecuta el siguiente código:

<source lang="c">
for (int i=0; i<2; i++) { /* #1 */
down(s); /* #2 */
f2(); /* #3 */
up(s); /* #4 */
}
</source>

Suponiendo que el contador del semáforos s vale 1.

Suponga que:

* El planificador emplea turno rotatorio estricto con quantum de 3 unidades de ejecución.
* Se sabe que el proceso P1 es seleccionado en primer lugar por el planificador para ejecutarse.
* La ejecución de cada línea de código representado anteriormente supone una unidad de ejecución, por tanto, todas las instrucciones toman el mismo tiempo de ejecución.

El cronograma deberá incluir qué instrucción se ejecuta en cada unidad de ejecución.

[[solución ejercicio 9|Ver solución del ejercicio 9]]

Página Principal

2012-12-13T10:59:16Z

Rafgomgal1:

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla. ¡Contribuye!

= Novedades y noticias =

* Comienza el curso 2012/2013 --[[Usuario:Pneira|Pneira]] 15:01 28 sep 2012 (UTC)
* Primer control de evaluación continua del grupo GC2 el viernes 9 de noviembre --[[Usuario:Pneira|Pneira]] 16:47 26 oct 2012 (UTC)
* Segundo control de evaluación continua del grupo GC2 el viernes 14 de diciembre --[[Usuario:Pneira|Pneira]] 16:13 28 nov 2012 (UTC)
* Tercer control de evaluación continua del grupo GC2 el viernes 21 de diciembre --[[Usuario:Pneira|Pneira]] 15:10 12 dic 2012 (UTC)

= Unidades didácticas =

A continuación encontrarás las unidades didácticas que forman parte de la asignatura.

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema Operativo|Qué es un sistema operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los sistemas operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de sistemas operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Llamadas al sistema|Llamadas al sistema]]
* 2.6. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]

== Modelos de diseño de Sistemas Operativos ==

* 3.1. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 3.2. [[Virtualización]]
* 3.3. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 4.1. [[Multiprogramación|La multiprogramación]]
* 4.2. [[Estados de los procesos|Estados de los procesos]]
* 4.3. [[Planificador de procesos|El planificador de procesos]]
* 4.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 4.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 4.6. [[Conmutación de procesos|La conmutación de procesos]]
* 4.7. [[Hilos|Hilos]]
* 4.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 5.1 [[Planificación de procesos|La planificación de procesos]]
* 5.2 [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 5.3 [[Criterios de planificación|Criterios de planificación]]
* 5.4 [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 5.5 [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 5.6 [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 5.7 [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 5.8 [[Ejercicios planificación de procesos|Ejercicios]]

== Concurrencia de procesos ==

* 6.1 [[Concurrencia de procesos|Concurrencia de procesos]]
* 6.2 [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 6.3 [[Cerrojos|Cerrojos]]
* 6.4 [[Ejercicio de concurrencia de procesos|Ejercicios]]

== Semáforos y comunicación ==

* 7.1 [[Semáforos|Semáforos]]
* 7.2 [[Monitores|Monitores]]
* 7.3 [[Mensajería|Mensajería]]
* 7.4 [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 8.1 [[Definición de interbloqueo|Definición]]
* 8.2 [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 8.3 [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 8.4 [[Ejercicios]]

== Segmentación y paginación ==

* 9.1 [[Introducción|Introducción]]
* 9.2 [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 9.3 [[Segmentacion|Segmentación]]
* 9.4 [[Paginación|Paginación]]
* 9.5 [[Sistema combinado|Sistema combinado]]
* 9.6 [[Ejercicios administración de memoria contigua|Ejercicios]]
* 9.7 [[Ejemplo de segmentación, paginación y combinado|Ejercicios]]

== Memoria virtual ==

* 10.1 [[Memoria Virtual|Introducción]]
* 10.2 [[Criterios de reemplazo|Criterios de reemplazo]]
* 10.3 [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 11.1 [[EstructuraES|Estructura dispositivo E/S]]
* 11.2 [[GestionES|Modos de gestionar dispositivos E/S]]
* 11.3 [[Diseño modular E/S|Diseño modular E/S]]
* 11.4 [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión L/E ==

* 12.1 [[Discos Magnéticos|Discos Magnéticos]]
* 12.2 [[MejorasTiempoBusqueda|Mejoras en el tiempo de búsqueda]]
* 12.3 [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 12.4 [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 12.5 [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 13.1 [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 13.2 [[FAT|FAT]]
* 13.3 [[EXT2 |EXT2]]
* 13.4 [[Ejercicios Administración Ficheros|Ejercicios]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].

Página Principal

2012-12-13T10:57:36Z

Rafgomgal1: /* Memoria virtual */

Bienvenido al wiki de la asignatura de Sistemas Operativos del departamento de Lenguajes y Sistemas Informáticos de la Universidad de Sevilla. ¡Contribuye!

= Novedades y noticias =

* Comienza el curso 2012/2013 --[[Usuario:Pneira|Pneira]] 15:01 28 sep 2012 (UTC)
* Primer control de evaluación continua del grupo GC2 el viernes 9 de noviembre --[[Usuario:Pneira|Pneira]] 16:47 26 oct 2012 (UTC)
* Segundo control de evaluación continua del grupo GC2 el viernes 14 de diciembre --[[Usuario:Pneira|Pneira]] 16:13 28 nov 2012 (UTC)
* Tercer control de evaluación continua del grupo GC2 el viernes 21 de diciembre --[[Usuario:Pneira|Pneira]] 15:10 12 dic 2012 (UTC)

= Unidades didácticas =

A continuación encontrarás las unidades didácticas que forman parte de la asignatura.

== Introducción a los Sistemas Operativos ==

* 1.1. [[Qué es un Sistema Operativo|Qué es un sistema operativo]]
* 1.2. [[Introducción histórica|Breve introducción histórica a los sistemas operativos]]
* 1.3. [[Tipos de Sistemas Operativos|Tipos de sistemas operativos]]

== Fundamentos de Sistemas Operativos ==

* 2.1. [[Organización básica de un ordenador]]
* 2.2. [[Modos de operación de la CPU|Modos de operación de la CPU]]
* 2.3. [[Componentes básicos de un sistema operativo|Componentes básicos de un sistema operativo]]
* 2.4. [[Conceptos básicos|Conceptos básicos]]
* 2.5. [[Llamadas al sistema|Llamadas al sistema]]
* 2.6. [[Ejercicios fundamentos Sistemas Operativos|Ejercicios]]

== Modelos de diseño de Sistemas Operativos ==

* 3.1. [[Modelos de Diseño de Sistemas Operativos|Modelos de diseño de sistemas operativos]]
* 3.2. [[Virtualización]]
* 3.3. [[Ejercicios 3|Ejercicios]]

== Procesos ==
* 4.1. [[Multiprogramación|La multiprogramación]]
* 4.2. [[Estados de los procesos|Estados de los procesos]]
* 4.3. [[Planificador de procesos|El planificador de procesos]]
* 4.4. [[Comportamiento de los procesos|El comportamiento de los procesos según el planificador]]
* 4.5. [[Bloque de control de procesos|El bloque de control del proceso]]
* 4.6. [[Conmutación de procesos|La conmutación de procesos]]
* 4.7. [[Hilos|Hilos]]
* 4.8. [[Ejercicios Procesos|Ejercicios]]

== Planificación de Procesos ==
* 5.1 [[Planificación de procesos|La planificación de procesos]]
* 5.2 [[Índices de evaluación|Índices de evaluación de la planificación de procesos]]
* 5.3 [[Criterios de planificación|Criterios de planificación]]
* 5.4 [[Planificadores de sistemas operativos existentes|Planificadores de sistemas operativos existentes]]
* 5.5 [[Planificación de procesos de tiempo real|La planificación de procesos de tiempo real]]
* 5.6 [[Planificación en sistemas multiprocesadores|La planificación de procesos en sistemas multiprocesadores]]
* 5.7 [[Ejercicios otros aspectos de la planificación|Ejercicios]]
* 5.8 [[Ejercicios planificación de procesos|Ejercicios]]

== Concurrencia de procesos ==

* 6.1 [[Concurrencia de procesos|Concurrencia de procesos]]
* 6.2 [[Mecanismos de sincronización|Control optimista y pesimista de la concurrencia]]
* 6.3 [[Cerrojos|Cerrojos]]
* 6.4 [[Ejercicio de concurrencia de procesos|Ejercicios]]

== Semáforos y comunicación ==

* 7.1 [[Semáforos|Semáforos]]
* 7.2 [[Monitores|Monitores]]
* 7.3 [[Mensajería|Mensajería]]
* 7.4 [[Ejercicios sincronización y comunicación|Ejercicios]]

== Interbloqueo ==

* 8.1 [[Definición de interbloqueo|Definición]]
* 8.2 [[Condiciones para el interbloqueo y estrategias de resolución|Modelado y Estrategias]]
* 8.3 [[Algoritmo para averiguar interbloqueo|Algoritmo del banquero]]
* 8.4 [[Ejercicios]]

== Segmentación y paginación ==

* 9.1 [[Introducción|Introducción]]
* 9.2 [[SO multiprogramables con particiones variables|SO multiprogramables con particiones variables]]
* 9.3 [[Segmentacion|Segmentación]]
* 9.4 [[Paginación|Paginación]]
* 9.5 [[Sistema combinado|Sistema combinado]]
* 9.6 [[Ejercicios administración de memoria contigua|Ejercicios]]
* 9.7 [[Ejemplo de segmentación, paginación y combinado|Ejercicios]]

== Memoria virtual ==

* 10.1 [[Memoria Virtual|Introducción]]
* 10.2 [[Criterios de reemplazo|Criterios de reemplazo]]
* 10.3 [[Ejercicios memoria virtual|Ejercicios]]

== Entrada/Salida ==

* 12.1 [[EstructuraES|Estructura dispositivo E/S]]
* 12.2 [[GestionES|Modos de gestionar dispositivos E/S]]
* 12.3 [[Diseño modular E/S|Diseño modular E/S]]
* 12.4 [[Ejercicios de Entrada/Salida|Ejercicios]]

== Gestión L/E ==

* 13.1 [[Discos Magnéticos|Discos Magnéticos]]
* 13.2 [[MejorasTiempoBusqueda|Mejoras en el tiempo de búsqueda]]
* 13.3 [[Mejoras en la demora de rotación|Mejoras en la demora de rotación]]
* 13.4 [[Tipos de errores en discos magnéticos|Tipos de errores en discos magnéticos]]
* 13.5 [[Ejercicios Gestión L/E|Ejercicios]]

== Administración de archivos ==

* 14.1 [[Introducción en la administración de archivos|Introducción en la administración de archivos]]
* 14.2 [[FAT|FAT]]
* 14.3 [[EXT2 |EXT2]]
* 14.4 [[Ejercicios Administración Ficheros|Ejercicios]]

== Anexo ==

Esta sección contiene información interesante pero que no pertenece al temario de la asignatura.

* Todo lo que siempre has querido saber sobre el protocolo SSH está [[SSH|aquí]].

Concurrencia de procesos

2012-12-07T18:13:56Z

Rafgomgal1: /* Sección crítica */

La concurrencia de procesos se refiere a las situaciones en las que dos o más procesos puedan coincidir en el acceso a un recurso compartido o, dicho de otra forma, que requieran coordinarse en su ejecución. Para evitar dicha coincidencia, el sistema operativo ofrece mecanismos de arbitraje que permiten coordinar la ejecución de los procesos.

Un ejemplo de un problema de concurrencia sería el siguiente: Dados dos procesos A y B, suponiendo que ambos se ejecutan indefinidamente en el tiempo, el proceso A debe recibir tiempo de ejecución antes que B, tras esto, el proceso B debe recibir su oportunidad de ejecución, dando paso de nuevo al proceso A y así sucesivamente.

proceso A |-- -- --
|
proceso B | -- -- --
|_____________

Recuerde que el planificador de procesos, al desconocer la naturaleza de los procesos y sus objetivos, no dispone de información suficiente como para garantizar la secuencia de ejecución descrita en el ejemplo anterior. Por tanto, suponiendo que ambos procesos se encuentran en estado preparado, podría seleccionar al proceso B para pasar a estado activo antes de seleccionar al proceso A, situación que no es deseada.

Recuerde que el planificador de procesos, como hemos visto en capítulos anteriores, emplea [[Criterios de planificación|criterios de planificación]] que no tienen en consideración el objetivo de los procesos. Podemos decir que el planificador de procesos '''desconoce''' cuál es el propósito de los procesos, únicamente puede observar su comportamiento, es decir, si presentan un comportamiento más o menos interactivo.

Por tanto, el programador, a la hora de modelar los procesos, debe emplear mecanismos de arbitraje que ofrece el sistema operativo y que permiten resolver el problema de concurrencia que se plantee.

= Formas de interacción entre procesos =

Hay dos formas básicas de interacción entre los procesos:

* '''Relaciones de competencia''': Dados dos procesos A y B, ambos procesos tienen objetivos diferentes y compiten por los recursos para conseguirlos. Por ejemplo, dos procesos desean modificar el contenido de un mismo fichero, pero no deben hacerlo de manera simultánea o quedará en un estado incoherente.

* '''Relaciones de cooperación''': Dados dos procesos A y B, ambos con un mismo objetivo, ''se ponen de acuerdo'' a la hora de emplear los recursos existentes para alcanzarlos. Por ejemplo, si el proceso A produce un objeto que es consumido por el proceso B, hasta que el proceso A no produzca, el proceso B no debe consumir y viceversa.

= Mecanismos de arbitraje =

Los mecanismos de arbitraje que ofrece el sistema operativo son básicamente dos:

* Mecanismos de '''sincronización''': el sistema operativo ofrece mecanismos que permiten a los procesos coordinar su ejecución para conseguir el objetivo sin que sucedan situaciones no deseadas, como por ejemplo que dos o más procesos coincidan simultáneamente en el acceso a un cierto recurso que no se puede compartir.

* Mecanismos de '''mensajería''': el sistema operativo ofrece mecanismos de comunicación entre procesos mediante mensajes. El intercambio de mensajes entre procesos permite coordinarlos.

= Programación concurrente =

El término programación concurrente se emplea con frecuencia para referirse a un conjunto de programas que funcionan en cooperación.

Hay tres formas de interacción entre procesos cooperativos:

*Concurrencia: Hay un recurso común, si varios procesos modificaran la misma información a la vez , cada uno podría destruir parte del trabajo de los demás. Si lo hacen uno tras otro, en serie, se obtendrá el resultado correcto.

*Sincronización: El Sistema Operativo se encarga de enviarle señales a los procesos para coordinar su evolución y conseguir que progrese armónicamente.

*Comunicación: El S.O. transmite mensajes entre los procesos, que se usan para intercambiar, enviar o recibir información.

Se le llama programación concurrente ya que la concurrencia fue la primera forma de iterar recursos entre procesos cooperativos.

= Sección crítica =

Una ''sección crítica'' se trata de una sección del código que puede ser ejecutada por un único proceso o hilo simultáneamente. Un ejemplo de ''sección crítica'' es la sección de código en la que se accede a un recurso compartido. Para evitar el acceso simultaneo a la sección crítica se emplean mecanismos que garantizan la ''exclusión mutua''.

La exclusión mutua se debe realizar de forma coordinada y eficiente, para ello se requiere:

*No más de un proceso por sección crítica y recurso compartido.

*El mismo proceso no puede usar el mismo recurso compartido indefinidamente.

*Todo proceso debe entrar antes o después a usar el recurso.

*Si el recurso está sin uso, cualquiera que lo requiera dispondrá de él inmediatamente.

*Si hay varios esperando usar el recurso y éste se libera, uno de los que estaba esperando lo usará durante un tiempo determinado.

Para llevar ésto a cabo se necesita un protocolo que indique cuando el recurso está libre y cuando está siendo ocupado.

= Tipos de mecanismos de sincronización =

Los mecanismos de sincronización los podemos catalogar en dos categorías:

*[[Mecanismos de sincronización#Optimista|Optimistas]]: Este mecanismo considera que la frecuencia de acceso a un cierto recurso compartido es ''baja''. Este tipo tiene mas consumo de memoria, ya que tiene que copiar el recurso compartido y en caso de interferencia en el hilo tiene que volver a ejecutarlo y consume mas recursos.

*[[Mecanismos de sincronización#Pesimista|Pesimistas]]: Este mecanismo permite coordinar la ejecución de dos o más procesos que acceden al recurso compartido con una frecuencia ''alta''.

Dependerá del criterio del programador el tipo de mecanismo que utilice ya que puede que no elija el tipo correcto. Por ejemplo, puede que la frecuencia de acceso a un cierto recurso sea alta y el programador le asigna un mecanismo optimista, esto provocaría no obtener el resultado esperado.

Semáforos

2012-11-16T19:28:26Z

Rafgomgal1: /* Semáforos */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos es importante recordar cómo funciona el [[Estados de los procesos|diagrama de estados de los procesos]]

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra] en 1965. Los semáforos permiten al programador '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que permiten sincronizar la ejecución de dos o más procesos. A diferencia de los [[cerrojos]], los semáforos nos ofrecen un mecanismo de espera no ocupada.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos(lista formada por el PCB de cada proceso), inicialmente vacía.

Y disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
añade proceso a s.lista
proceso a estado bloqueado
sino:
s.contador--
}
</source>

En el pseudocódigo anterior, se puede añadir a la lista un proceso o un hilo.

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Además, se disponen de un constructor y un destructor que permiten la creación y la liberación de un semáforo.

=== Ejemplo de uso de semáforos ===

Suponga el siguiente ejemplo en el que se quieren sincronizar dos hilos de un proceso, de manera que se dé la siguiente secuencia de ejecución: A, B, A, B, ... y así sucesivamente. El siguiente código resolvería el problema:

<source lang="c">
semaforo a = semaforo.create(1);
semaforo b = semaforo.create(0);

/* código del hilo A */
while (1) {
a.down();
printf("hilo A\n");
b.up();
}

/* código del hilo B */
while (1) {
b.down();
printf("hilo B\n");
a.up();
}
</source>

=== Tipos de semáforos ===

Dependiendo de la función que cumple el semáforo, vamos a diferenciar los siguientes tipos:

* Semáforo de exclusión mutua, inicialmente su contador vale 1 y permite que haya un único proceso simultáneamente dentro de la sección crítica.
* Semáforo contador, permiten llevar la cuenta del número de unidades de recurso compartido disponible, que va desde 0 hasta N.
* Semáforo de espera, generalmente se emplea para forzar que un proceso pase a estado bloqueado hasta que se cumpla la condición que le permite ejecutarse. Por lo general, el contador vale 0 inicialmente, no obstante, podría tener un valor distinto de cero.

=== Ventajas e inconvenientes ===

La principal ventaja de los semáforos frente a los [[cerrojos]] es que permiten sincronizar dos o más procesos de manera que no se desperdician recursos de CPU realizando comprobaciones continuadas de la condición que permite progresar al proceso.

Los inconvenientes asociados al uso de semáforos son los siguientes:

* Los programadores tienden a usarlos incorrectamente, de manera que no resuelven de manera adecuada el problema de concurrencia o dan lugar a interbloqueos.
* No hay nada que obligue a los programadores a usarlos.
* Los compiladores no ofrecen ningún mecanismo de comprobación sobre el correcto uso de los semáforos.
* Son independientes del recurso compartido al que se asocian.

Debido a estos inconvenientes, se desarrollaron los [[Monitores|monitores]].

Semáforos

2012-11-16T19:25:20Z

Rafgomgal1: /* Semáforos */

= Planificador de procesos: Diagrama de estados simplicado =

Para comprender apropiadamente cómo funcionan los semáforos es importante recordar cómo funciona el [[Estados de los procesos|diagrama de estados de los procesos]]

= Semáforos =

Los semáforos son un mecanismo de sincronización de procesos inventados por [http://es.wikipedia.org/wiki/Edsger_Dijkstra Edsger Dijkstra] en 1965. Los semáforos permiten al programador '''asistir al planificador del sistema operativo en su toma de decisiones''' de manera que permiten sincronizar la ejecución de dos o más procesos. A diferencia de los [[cerrojos]], los semáforos nos ofrecen un mecanismo de espera no ocupada.

Los semáforos son un tipo de datos que están compuestos por dos atributos:

* Un contador, que siempre vale >= 0.
* Una lista de procesos(lista formada por el PCB de cada proceso), inicialmente vacía.

Y disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:

<source lang="c">
down(semáforo s)
{
si s.contador == 0:
añade proceso a s.lista
proceso a estado bloqueado
sino:
s.contador--
}
</source>

En el pseudocódigo anterior, se puede añadir un proceso o un hilo.

Nótese que siempre que queramos forzar una transición de un proceso a estado bloqueado, tenemos que hacer que dicho proceso realice una operación ''down'' sobre un semáforo cuyo contador vale cero.

<source lang="c">
up(semáforo s)
{
si hay procesos en s.lista
retira proceso de s.lista
proceso a estado preparado
sino:
s.contador++
}
</source>

Nótese que una operación ''up'' sobre un semáforo en el que hay procesos en su lista resulta en que se retire uno de los procesos (el que más tiempo lleva en la lista), realizando éste la transición a estado preparado. Es un error frecuente pensar que una operación ''up'' resulte en que el proceso retirado de la lista pase a estado activo. Recuerde que las transiciones de estado activo a preparado y viceversa son siempre controladas por el planificador del sistema operativo.

Además, se disponen de un constructor y un destructor que permiten la creación y la liberación de un semáforo.

=== Ejemplo de uso de semáforos ===

Suponga el siguiente ejemplo en el que se quieren sincronizar dos hilos de un proceso, de manera que se dé la siguiente secuencia de ejecución: A, B, A, B, ... y así sucesivamente. El siguiente código resolvería el problema:

<source lang="c">
semaforo a = semaforo.create(1);
semaforo b = semaforo.create(0);

/* código del hilo A */
while (1) {
a.down();
printf("hilo A\n");
b.up();
}

/* código del hilo B */
while (1) {
b.down();
printf("hilo B\n");
a.up();
}
</source>

=== Tipos de semáforos ===

Dependiendo de la función que cumple el semáforo, vamos a diferenciar los siguientes tipos:

* Semáforo de exclusión mutua, inicialmente su contador vale 1 y permite que haya un único proceso simultáneamente dentro de la sección crítica.
* Semáforo contador, permiten llevar la cuenta del número de unidades de recurso compartido disponible, que va desde 0 hasta N.
* Semáforo de espera, generalmente se emplea para forzar que un proceso pase a estado bloqueado hasta que se cumpla la condición que le permite ejecutarse. Por lo general, el contador vale 0 inicialmente, no obstante, podría tener un valor distinto de cero.

=== Ventajas e inconvenientes ===

La principal ventaja de los semáforos frente a los [[cerrojos]] es que permiten sincronizar dos o más procesos de manera que no se desperdician recursos de CPU realizando comprobaciones continuadas de la condición que permite progresar al proceso.

Los inconvenientes asociados al uso de semáforos son los siguientes:

* Los programadores tienden a usarlos incorrectamente, de manera que no resuelven de manera adecuada el problema de concurrencia o dan lugar a interbloqueos.
* No hay nada que obligue a los programadores a usarlos.
* Los compiladores no ofrecen ningún mecanismo de comprobación sobre el correcto uso de los semáforos.
* Son independientes del recurso compartido al que se asocian.

Debido a estos inconvenientes, se desarrollaron los [[Monitores|monitores]].

Conmutación de procesos

2012-11-07T16:08:23Z

Rafgomgal1:

La conmutación de procesos es la operación que consiste en retirar el procesador a un proceso para asignárselo a otro. La conmutación se produce por cuatro razones:

#Un proceso agota el tiempo máximo asignado al procesador, por tanto, se debe dar paso a otro proceso para garantizar que la multiprogramación es llevada a cabo apropiadamente.
#Un proceso está pendiente de un evento externo, por tanto, pasa a estado bloqueado haciendo uso de la llamada al sistema bloqueante. El planificador debe asignar el procesador a otro nuevo proceso de entre los que están en estado preparado.
#Que termine la ejecución del proceso en cuestión.
#Que haya una [[Gestión_de_Entrada/Salida|interrupción]] en la ejecución.

Los pasos que se siguen son los siguientes:

# Pasar a modo privilegiado.
# Guardar el contenido de los registros del hardware en el PCB (el llamado ''contexto de la ejecución'').
# Actualizar el estado del proceso en el PCB (el estado ha pasado de activo a bloqueado o preparado).
# Si se produjo una interrupción, atenderla.
# Seleccionar un nuevo proceso.
# Restaurar el contexto de ejecución del nuevo proceso seleccionado. En el caso de que el nuevo proceso no hubiese estado en el contexto de la ejecución deberá inicializarse.
# Pasar a modo no privilegiado.

[[Imagen:Asig2.png]]

El tiempo de conmutación se considera una penalizanción, ya que si realizamos muchas conmutaciones el rendimiento decrece y esto da al usuario la sensación de que sus actividades van a saltos. Para optimizar esto hay que evitar conmutaciones innecesarias, empleando para ello criterios de selección lo más eficientes posibles.

Qué es un Sistema Operativo

2012-10-27T09:09:21Z

Rafgomgal1: /* 1.1.1. ¿Qué es un Sistema Operativo? */

= 1.1. ¿Qué es un Sistema Operativo? =

== 1.1.1. ¿Qué es un Sistema Operativo? ==

El sistema operativo es el conjunto de programas que:

* Gestionan y reparten de manera equitativa los recursos que ofrece el ''hardware'' entre los programas en ejecución. Concretamente, los recursos a gestionar son tres:

** La [http://es.wikipedia.org/wiki/Unidad_central_de_procesamiento CPU], también conocida como procesador o unidad central de procesamiento. Todo procesador ofrece un conjunto de instrucciones de bajo nivel (lenguaje ensamblador) con operaciones básicas que ejecuta de manera secuencial.
** La [http://es.wikipedia.org/wiki/Memoria_principal Memoria principal], memoria empleada para almacenar el estado de la ejecución del programa.
** Los [http://es.wikipedia.org/wiki/Entrada/salida#Dispositivos_de_entrada_y_salida dispositivos de Entrada/Salida], tales como la tarjeta de vídeo, la tarjeta de red, los dispositivos de almacenamiento masivo (disco duro del tipo que sea), teclado, ratón, pantalla, entre muchos otros.

* Ofrece un '''lanzador de aplicaciones''', que pueden estar basados en:

** Intérprete de órdenes/comandos (traducción incorrecta del original inglés ''command'', que significa órden), también llamado ''shell''. El dispositivo de entrada empleado es el teclado. Es generalmente complejo pero ofrece funcionalidades avanzadas. Algunos ejemplos son la shell de ''bash'' disponible en Linux o el PowerShell disponible en la recientes versiones de MS-Windows. Para ejecutar un programa se escribe su nombre, seguido de opciones (en caso de que las tenga y se pulsa la tecla de ''Intro'').
** Gestor de ventanas: Son los más populares por su sencillez, aunque ofrecen menor funcionalidad que los basados en intérpretes de órdenes. Los programas se ejecutan mediante un clic sencillo o doble de ratón. En dispositivos portátiles en lugar del ratón se emplea una pantalla táctil.

* Ofrece una interfaz estable y homogénea a los programas de usuario para solicitar servicios. Esta interfaz se conoce como '''API''' (del inglés, ''Application Programming Interface'') del sistema operativo.

El sistema operativo se sitúa entre los programas de usuario en ejecución y el hardware, de manera que los programas '''siempre''' deben emplear la ''API'' del sistema operativo para acceder a los recursos que ofrece el hardware.

== 1.1.2. Principios de diseño de un buen Sistema Operativo ==

Los aspectos a tener en cuenta respecto a la gestión de recursos son:

* Realizar una gestión eficiente de los recursos.
* Coordinar la asignación de los mismos entre los programas de ejecución (como se si tratase de un moderador en un debate, asignando el turno de palabra a cada uno de los asistentes).
* Hacer un reparto equitativo (del diccionario de la RAE, ''equidad'' significa "dar a cada uno lo que merece"). Esto no significa hacer una división exacta de los recursos, si no que se tendrán en cuenta la naturaleza de cada programa en ejecución a la hora de hacer el reparto.
* No ofrecer ninguna interfaz que permita a las aplicaciones acceder directamente los recursos hardware.

Respecto a la API, debe:

* Ser estable, no debe cambiar con el tiempo.
* Ser homogénea.
* Debe abstraer y ocultar los detalles de bajo nivel de los componentes, de manera que los programas lleguen a ser complemente independientes del hardware.

Además de todo esto, un buen sistema operativo es ''portable'', es decir, que soporte diferentes arquitecturas ''hardware'', como por ejemplo la ARM (típicamente empleada en dispositivos móviles con limitaciones importantes en materia de energía), la PC x86 y x86_64 de Intel, las variantes del PC que ofrece AMD, la arquitectura PowerPC (empleada antaño por Apple y desarrollada por IBM) y SPARC (desarrollada por Sun Microsystems, adquirida por Oracle).