Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Llamadas al sistema

2011-06-12T10:44:15Z

Luidela1:

Una llamada al sistema es una petición que hace un proceso al sistema operativo para obtener cualquier tipo de servicio. La interfaz que el sistema operativo presenta a los programas se denomina API, donde constan todas las llamas al sistema de las que dispone.
Los programas se hacen independientes de la maquina, aunque dependientes del API. Por ello, existen Apis estandarizadas, como POSIX.

=Compatibilidad hacia atrás y hacia delante=

En un sistema operativo bien diseñado, la interfaz de las llamadas al sistema han de ser ser estables a lo largo del tiempo, de forma que la modificación de su funcionamiento interno no repercuta en el funcionamiento externo de éstas para asegurar la compatibilidad hacia atrás([http://en.wikipedia.org/wiki/Backward_compatibility Backward compatibility]). Además, aquellas llamadas que queden obsoletas o en desuso han de ser conservadas para, de la misma manera, asegurar el funcionamiento de programas antiguos ([http://en.wikipedia.org/wiki/Legacy_system?=Legacy_support Legacy Support]).

En ocasiones los sistemas operativos pueden incluir en su diseño criterios de compatibilidad hacia adelante([http://en.wikipedia.org/wiki/Forward_compatibility Fordward compatibility]). Un ejemplo de este tipo de sistemas son aquellos capaces de mostrar información detallada al usuario de aquello que no pueden comprender o los sistemas ignorantes, que son aquellos que solo ejecutan lo que pueden comprender y obvian el resto.

Introducción histórica

2011-06-12T10:35:01Z

Luidela1:

*En 1940, durante la 2º Guerra Mundial , se inicia la 1º Generacion de ordenadores , tales como el ENIAC(1943-1945) que se desarrollo en EEUU y el EDSAC (1949) que se desarrolla en RU.

*Mas tarde , se desarrollan los 1º lenguajes de programacion , se desarrollan los 1º ordenadores comerciales como IBM 701, 702 y 650, en el que algunos de ellos se utilizaban para el calculo cientifico en aplicaciones de gestion, tambien se crean otro ordenadores como el UNIVAC I en EEUU y MARK I o Harvard Mark I en la RU

-Maquinas relevantes:

A) ENIAC:
*Maquina de cálculo completamente electrónica.
*Arquitectura no Von-Neumann.
*17468 lámparas.
*20 registros de 10 lámparas para representar el BCD.
B) EDSAC
*Primera máquina con arquitectura Von Neumann.
*Programada en lenguaje ensamblador.
C) Primeras maquinas comerciales (a partir de 1951):
*Univac I y Mark I
*IBM 701
*IBM 702 e IBM 650
----------------

*Durante la 2º Generacion de Ordenadores, una generacion en donde los equipos eran mas fiables, se crearia el primer germen de sistema operativos, que lo que queria conseguir era un programa para reservar memoria y automatizar ciertas tareas (como por ejemplo lecturas de cintas magneticas).

-Maquinas relevantes
A) TRADIC:
* Ordenador completamente transistorizado.
* Suficientemente pequeño para montarse en un B-52.
* Primera unidad destinada a venta: 1958.
B) IBM 7094
* Memoria: 32K-palabras de 32 bits.
* Potencia de cálculo: 0,35MIPS.
C) PDP-1:
* Uno de los primeros micro-computadores
* 4K-palabras de 16 bits
* Precio: 5% de IBM 7094
-----------------

*En la 3º Generacion de Ordenadores (años 1960-1970), se consigio una alta escala de integracion en circuitos, en los que se consigue mas capacidad de memoria, y mas rendimiento y velocidad en los equipos. Se crean los mainFrame , equipos centrales para procesar una gran cantidad de datos, como por ejemplo IBM 360 y los "mini"ordenadores, en la universidades (DIGITAL PDP - 7 , PDP - 11).

-Maquinas relevantes
A) Aparece el concepto de familia de ordenadores.
* Poder elegir diferentes configuraciones.
* Catálogo de dispositivos y periféricos compatibles.
B) IBM 360
* Sistemas operativo: OS/360
* Lenguaje de control de trabajos: JCL
* Lenguaje de programación: PL/1
C) MULTICS
* Diferentes empresas ayudando en su desarrollo.
* Sistema operativo interactivo en tiempo compartido.
* Pensado para dar servicio de computo a toda una ciudad.
D) Hardware:
*GE-645, 2 procesadores con 256 K-palabras de 36 bits.
-------------------------------
*En 1973 , se crea el primer sistema operativo de tipo UNIX

*En 1980, los fabricantes mas conocidos crean sistemas operativos basados en UNIX, como IBM crea AIX, SUN crea Solaris, Digital crea The64,HP crea HP-UX y Microsoft crea Xenix. Tambien paralelamente en la universidad de california crea un sistema operativo llamado BSD que se distribuye para usos didacticos.

*En 1983, Richard Stallman inicia un proyecto llamado GNU en el que consiste desarrollar un sistema operativo , en el que se puede distribuir de manera gratuita y libre

*En 1990, se crea el Intel 80386 y la universidad de California distrubuye el sistema BSD + un soporte real

*En 1992, se lanza el 1º sistema operativo de tipo GNU / LINUX

Introducción histórica

2011-06-12T10:32:00Z

Luidela1:

*En 1940, durante la 2º Guerra Mundial , se inicia la 1º Generacion de ordenadores , tales como el ENIAC(1943-1945) que se desarrollo en EEUU y el EDSAC (1949) que se desarrolla en RU.

*Mas tarde , se desarrollan los 1º lenguajes de programacion , se desarrollan los 1º ordenadores comerciales como IBM 701, 702 y 650, en el que algunos de ellos se utilizaban para el calculo cientifico en aplicaciones de gestion, tambien se crean otro ordenadores como el UNIVAC I en EEUU y MARK I o Harvard Mark I en la RU

-Maquinas relevantes:

A) ENIAC:
*Maquina de cálculo completamente electrónica.
*Arquitectura no Von-Neumann.
*17468 lámparas.
*20 registros de 10 lámparas para representar el BCD.
B) EDSAC
*Primera máquina con arquitectura Von Neumann.
*Programada en lenguaje ensamblador.
C) Primeras maquinas comerciales (a partir de 1951):
*Univac I y Mark I
*IBM 701
*IBM 702 e IBM 650

*Durante la 2º Generacion de Ordenadores, una generacion en donde los equipos eran mas fiables, se crearia el primer germen de sistema operativos, que lo que queria conseguir era un programa para reservar memoria y automatizar ciertas tareas (como por ejemplo lecturas de cintas magneticas)

*En la 3º Generacion de Ordenadores (años 1960-1970), se consigio una alta escala de integracion en circuitos, en los que se consigue mas capacidad de memoria, y mas rendimiento y velocidad en los equipos. Se crean los mainFrame , equipos centrales para procesar una gran cantidad de datos, como por ejemplo IBM 360 y los "mini"ordenadores, en la universidades (DIGITAL PDP - 7 , PDP - 11).

*En 1973 , se crea el primer sistema operativo de tipo UNIX

*En 1980, los fabricantes mas conocidos crean sistemas operativos basados en UNIX, como IBM crea AIX, SUN crea Solaris, Digital crea The64,HP crea HP-UX y Microsoft crea Xenix. Tambien paralelamente en la universidad de california crea un sistema operativo llamado BSD que se distribuye para usos didacticos.

*En 1983, Richard Stallman inicia un proyecto llamado GNU en el que consiste desarrollar un sistema operativo , en el que se puede distribuir de manera gratuita y libre

*En 1990, se crea el Intel 80386 y la universidad de California distrubuye el sistema BSD + un soporte real

*En 1992, se lanza el 1º sistema operativo de tipo GNU / LINUX

Introducción histórica

2011-06-12T10:27:02Z

Luidela1:

SO multiprogramables con particiones fijas

2011-06-08T06:31:22Z

Luidela1: /* Criterios de asignación */

La memoria se encuentra dividida en particiones, en cada una habrá un proceso. Por lo tanto, se pueden ejecutar tantos procesos como particiones haya.

=Estrategias=
Las estrategias a seguir cuando no hay memoria suficiente para otro proceso son dos:
*Cancelación: "lo siento, no hay memoria libre, prueba más tarde".
*Espera: añadir el proceso a una cola hasta que haya memoria disponible.

=Limitaciones=
*Si un proceso necesita mayor memoria que la partición más grande, entonces éste no se ejecuta.
*Desperdicio de memoria. Por ejemplo, si los procesos son muy pequeños y las particiones grandes.

=Criterios de asignación=
Se lanza un proceso, y hay que elegir a qué partición va (estrategia de espera). Puede haber una cola por partición, o una sola para todas las particiones.

Ej: tenemos los siguientes procesos: m(P1) = 6KB, m(P2) = 1KB, m(P3) = 3KB, m(P4) = 31KB, m(P5) = 30KB;
suponemos que la decisión sobre la asignación de procesos a particiones se hace ordenadamente de manera consecutiva según el número del proceso
y una memoria de 64 KB divididos en 4 huecos como sigue:
_____
|_____| H1 = 8KB
|_____| H2 = 8KB
| |
|_____| H3 = 16KB
| |
| |
| | H4 = 32KB
|_____|

*'''Mejor ajuste estático''': se adjudica cada proceso a la menor partición que quepa. Si la menor en la que cabe está ocupada, se espera. Complejidad: O(1)

[[solución mejor ajuste estático|Ver solución]]

*'''Primer ajuste''': cuando una partición queda libre, se asigna el primer proceso según el orden de la cola que quepa en ella. Complejidad: O(1)

[[solución primer ajuste|Ver solución]]

*'''Mejor ajuste dinámico''': cuando una partición queda libre, se asigna el mayor proceso que quepa en ella. Complejidad: O(nlog(p))

[[solución ajuste dinámico|Ver solución]]

*'''Mejor ajuste dinámico con aplazamiento limitado''': Es una variante del criterio anterior que evita el aplazamiento indefinido. Cuando queda una partición libre, se selecciona el mayor proceso que quepa en ella, pero se cuenta el nº de veces que un proceso se aplaza. Si se superan esas '''n''' veces (umbral), se le da paso.

*'''Subparticiones''': No es un criterio como tal sino que viene a complementar a los anteriores. Si no hay un proceso que pueda aprovechar la partición madre: se asignan las subparticiones a procesos pequeños (para que el desperdicio interno sea lo menor posible). Si llega un proceso grande: los procesos pequeños se vuelcan a disco y se asigna partición madre.
*''Partición madre'': tipo especial de partición que se puede dividir en múltiples particiones menores.

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

*'''Montaje absoluto''': Se asigna una dirección de memoria constante, siendo por tanto este método muy restrictivo. Se utiliza para la carga del sistema operativo.

* '''Carga con reubicación''': Al realizar la carga, se le aplica a las direcciones lógicas del programa un ''offset'' o desplazamiento. Este desplazamiento es establecido por el programador antes de que se ejecute el programa. Este método es más flexible que el anterior, pero una vez cargado no se puede cambiar de partición.

* '''Reubicación dinámica''': A diferencia de la carga con reubicación, el desplazamiento se asigna en tiempo de ejecución.
** '''Reubicación dinámica parcial''': Es una variante del anterior, en la que existe también un registro límite.

= Mecanismos de protección de memoria =

Es necesario proteger el SO frente a procesos; y proteger a los procesos entre sí.

* '''Bits de protección''' : Se le asigna a cada zona/partición de la memoria principal una zona con información sobre el propietario y los permisos de lectura/escritura

* '''Ampliación registros valla''' : De esta manera se conocen la posición inicial y final, de manera que si no está entre esas dos posiciones no se permite el acceso a memoria.

Discos Magnéticos

2011-06-07T19:16:58Z

Luidela1:

[[Archivo:Sin_título.png]][[Archivo:Estructura_disco.png|Estructura de un disco óptico|right]]
Partes importantes de los discos magnéticos:

*Cabezal: sección que se mueve por un plato para leer la información.
*Pista (track): zona accesible por el cabezal.
*Sector: los que se divide una pista.
*Cilindro: Conjunto accesible por todos los cabezales.

Prestaciones a tener en cuenta de los discos duros magnéticos:

*Capacidad
*rpm (revoluciones por minuto)
*Tiempo de arranque del motor
*Tiempo de accesos (lectura/escritura):
**Tiempo de búsqueda: tiempo en desplazarse de una pista a otra.
**Demora de rotación: tiempo en desplazarse de un sector a otro.
**Tiempo de transmisión: tiempo desde la lectura de los datos hasta que pasa la información al gestor de dispositivo correspondiente.

Archivo:Sin título.png

2011-06-07T19:16:20Z

Luidela1:

Solución ejercicio 1 memoria virtual

2011-06-07T19:07:35Z

Luidela1: /* Sustitución por envejecimiento */

= FIFO =
accesos a páginas
-------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
---------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | = | = | 1 | = | = | = |
--------------------------------------------------------------------------------
| 3 | | | | | 3 | = | = | = | = | 2 | = | = |
---------------------------------------------------------------------------------
| 4 | | | | | | 4 | = | = | = | = | 3 | = |
---------------------------------------------------------------------------------
fallo | X | | | X | X | X | X | | X | X | X | X |
página -------------------------------------------------------------------------

tiempo ->

9
talla de fallos de página = ------ = 0.75
12

= NRU =

En caso de empate, se emplea LRU.
accesos a páginas

| r | r | w | r | r | r | r | w | w | w | r | r |
-------------------------------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | = | = | = | = | = | = |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | 1 | 0 | = | = | 1 | 1 | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = | = |
---------------------------------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | 5 | = | = | = | = | 4 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | | | | | | | 1 | 0 | = | = | = | = | 1 | 0 | = | = | = | = | = | = | = | = | 1 | 0 |
---------------------------------------------------------------------------------------------------------
| 3 | | | | | 3 | = | = | 3 | = | = | = | = |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | | | | | | | | | 1 | 0 | = | = | = | = | 1 | 1 | = | = | = | = | = | = | = | = |
---------------------------------------------------------------------------------------------------------
| 4 | | | | | | 4 | = | = | = | 2 | = | = |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | M | | | | | | | | | | | 1 | 0 | = | = | = | = | = | = | 1 | 1 | = | = | = | = |
---------------------------------------------------------------------------------------------------------
fallo | X | | | X | X | X | X | | | X | | X |
página -------------------------------------------------------------------------------------------------

tiempo ->

7
talla de fallos de página = ------ = 0.583
12

= NRU con 2º oportunidad =

accesos a páginas

| r | r | w | r | r | r | r | w | w | w | r | r |
-------------------------------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | 1 | = | = | = | = | = | 1 | = | = | = | = | 1 |
---------------------------------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | 2 | = | 1 | = | = | 1 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | | | | 1 | = | = | 0 | = | 1 | = | = | 0 |
---------------------------------------------------------------------------------------------------------
| 3 | | | | | 3 | = | 3 | 3 | = | = | 3 | 3 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | | | | | 1 | = | 0 | 1 | = | = | 1 | 0 |
---------------------------------------------------------------------------------------------------------
| 4 | | | | | | 4 | 4 | = | = | 2 | = | 2 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| R | | | | | | 1 | 0 | = | = | 1 | = | 0 |
---------------------------------------------------------------------------------------------------------
fallo | X | | | X | X | X | X | | X | X | | X |
página -------------------------------------------------------------------------------------------------

tiempo ->

8
talla de fallos de página = ------
12

Creo que es asi, pero no me lo tomeis a pies juntillas que no estoy muy seguro.

Por favor que alguien explique bien este criterio, que en cada ejercicio se aplica de una forma diferente.Gracias

Explicación:

El criterio se basa en combinar el NRU (sin bit M) con FIFO. En la cola se van añadiendo las páginas según se cargan con su respectivo valor del bit R. A la hora de sustituir se mira el candidato de la cabecera de la cola. Si su R=1, se le da una segunda oportunidad desplazándolo al final de la cola y poniendo su bit R=0. Si hubiera tenido el R=0, se hubiera tomada esa página como víctima. Eso es lo que sucede cuando llega la página 5. En ese momento la cola es 1 2 3 4 con su bit R=1 en todas las páginas. Se va mirando el candidato si tiene el bit R=0 como no es así, pasa al final de la cola. Llega un momento en el que la página 1 vuelve a la cabecera(en este caso con R=0),por lo que ahora si es sustituida por la página 5.[[Usuario:Jherrera|Jherrera]]

Una Dudilla : la FIFO es por orden de carga o por orden de acceso?¿ Según veo en el ejercicio lo hace por orden de acceso --[[Usuario:DvS 013|DvS 013]]

= LRU =

accesos a páginas
-------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------
| 1 | 1 | = | = | = | = | = | 5 | = | = | = | = | 4 |
---------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | = | = | 1 | = | = | = |
--------------------------------------------------------------------------------
| 3 | | | | | 3 | = | = | = | = | = | = | = |
---------------------------------------------------------------------------------
| 4 | | | | | | 4 | = | = | = | 2 | = | = |
---------------------------------------------------------------------------------
fallo | X | | | X | X | X | X | | X | X | | X |
página -------------------------------------------------------------------------

tiempo ->

8
talla de fallos de página = ------
12

= LFU =

accesos a páginas

| r | r | w | r | r | r | r | w | w | w | r | r |
-------------------------------------------------------------------------------------------------
| 1 | 1 | 1 | 2 | 3 | 4 | 5 | 3 | 1 | 2 | 3 | 4 |
---------------------------------------------------------------------------------------------------------
| 1 | 1 | 1 | 1 | = | = | = | = | = | 1 | = | = | 1 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| C | 1 | 2 | 3 | = | = | = | = | = | 4 | = | = | 4 |
---------------------------------------------------------------------------------------------------------
marcos | 2 | | | | 2 | = | = | 5 | = | = | = | = | 4 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| C | | | | 1 | = | = | 1 | = | = | = | = | 1 |
---------------------------------------------------------------------------------------------------------
| 3 | | | | | 3 | = | = | 3 | = | = | 3 | 3 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| C | | | | | 1 | = | = | 2 | = | = | 3 | 3 |
---------------------------------------------------------------------------------------------------------
| 4 | | | | | | 4 | = | = | = | 2 | = | 2 |
| |-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|-------|
| C | | | | | | 1 | = | = | = | 1 | = | 1 |
---------------------------------------------------------------------------------------------------------
fallo | X | | | X | X | X | X | | | X | | X |
página -------------------------------------------------------------------------------------------------

tiempo ->

7
talla de fallos de página = ------
12

Observación: al quitar un elemento se resetea su contador

= Sustitución por envejecimiento =
Periodo de 4, registro R de 3 bits, desempate: FIFO (por orden de carga)

_________________accesos a página__________________
|_1_|_1_|_1_|_2_||_3_|_4_|_5_|_3_||_1_|_2_|_3_|_4_|
======================================================
1 | 1 | = | = | = || 1 | = | 5 | 5 || 5 | = | = | 4 |
|100| = | = | = ||010| = |100|100||010| = | = |100|
m---|---|---|---|---||---|---|---|---||---|---|---|---|
a 2 | | | | 2 || 2 | = | = | = || 1 | = | = | = |
r | | | |100||010| = | = | = ||100| = | = | = |
c---|---|---|---|---||---|---|---|---||---|---|---|---|
o 3 | | | | || 3 | = | = | = || 3 | 2 | = | = |
s | | | | ||100| = | = | = ||010|100| = | = |
---|---|---|---|---||---|---|---|---||---|---|---|---|
4 | | | | || | 4 | = | = || 4 | = | 3 | = |
| | | | || |100| = | = ||010| = |100| = |
--------------------------------------------------------> t
x x x x x x x x x

9
tasa fallos pág = ----
12
----------------------------------
En este ejercicio hay un error cuando en la iteraccion 8 entra el 3, se ha puesto 5 100

_________________accesos a página__________________
|_1_|_1_|_1_|_2_||_3_|_4_|_5_|_3_||_1_|_2_|_3_|_4_|
======================================================
1 | 1 | = | = | = || 1 | = | 5 | = || 5 | = | = | 4 |
|100| = | = | = ||010| = |100| = ||010| = | = |100|
m---|---|---|---|---||---|---|---|---||---|---|---|---|
a 2 | | | | 2 || 2 | = | = | = || 1 | = | = | = |
r | | | |100||010| = | = | = ||100| = | = | = |
c---|---|---|---|---||---|---|---|---||---|---|---|---|
o 3 | | | | || 3 | = | = | 3 || 3 | = | 3 | = |
s | | | | ||100| = | = |110||011| = |111| = |
---|---|---|---|---||---|---|---|---||---|---|---|---|
4 | | | | || | 4 | = | = || 4 | 2 | = | = |
| | | | || |100| = | = ||010|100| = | = |
--------------------------------------------------------> t
x x x x x x x x x

Esta seria la solucion creo --[[Usuario:Luidela1|Luidela1]] 19:07 7 jun 2011 (UTC)

Sol 9.2

2011-06-07T18:48:12Z

Luidela1:

La lista de paginas a la que se acceden son las siguientes : '''2--2--3--1--1--3--4--5--1--1--2--3--4'''

_________________accesos a página____________________
|_2_|_2_|_3_|_1_||_1_|_3_|_4_|_5_||_1_|_1_|_2_|_3_||_4_| ||=Fin periodo, puesta R=0
===========================================================
1 | 2 | = | = | = || 2 | = | = | = || 2 | = | 2 | = || 2 | Periodo = 4
|R=1| = | = | = ||R=0| = | = | = ||R=0| = |R=1| = ||R=0|
m---|---|---|---|---||---|---|---|---||---|---|---|---||---|
a 2 | | | 3 | = || 3 | 3 | = | = || 3 | = | = | 3 || 3 | Contadores:
r | | |R=1| = ||R=0|R=1| = | = ||R=0| = | = |R=1||R=0| P0: 2=1 3=1 1=1 4=0 5=0
c---|---|---|---|---||---|---|---|---||---|---|---|---||---| P1: 2=1 3=2 1=2 4=0 5=1
o 3 | | | | 1 || 1 | = | = | = || 1 | = | = | = || 1 | P2: 2=2 3=3 1=3 4=0 5=1
s | | | |R=1||R=1| = | = | = ||R=1| = | = | = ||R=0|
---|---|---|---|---||---|---|---|---||---|---|---|---||---|
4 | | | | || | | 4 | 5 || 5 | = | = | = || 4 |
| | | | || | |R=1|R=1||R=0| = | = | = ||R=0|
------------------------------------------------------------> t
fp | x | | x | x || | | x | x || | | | || x |
|_> Fallos de Página
P0(2++, 3++,1++) P1(3++,1++,5++) P2(2++,3++,1++)

6
tasa fallos pág = ---- = 0,4615
13

Sol 9.2

2011-06-07T18:47:40Z

Luidela1:

Sistema combinado

2011-06-07T15:18:51Z

Luidela1:

Emplea paginación y segmentación.

Idea: Cada segmento ocupa n páginas.

Tiene las ventajas de tener la protección de memoria de segmentos y su compartición, la carga a petición de las páginas y su fácil gestión.

En estos sistemas, cada segmento ocupa una página como mínimo. También se podría decir que un segmento ocupa siempre N páginas.
Tamaño Segmento = N * Tamaño de Página

Sistema combinado

2011-06-07T15:18:27Z

Luidela1:

Tipos de errores en discos magnéticos

2011-06-07T14:48:34Z

Luidela1:

Los errores típicos relacionados con los discos duros magnéticos pueden ser:

Relacionados con el material:

*Permanentes:La unidad se encuentra mal en algún sentido. No existe forma “tradicional” de acceder a ellos. En los discos magnéticos existen dos estrategias para tratar estos errores:

Archivo que contiene todos los sectores defectuosos.
Mantener en una tabla aquellos bloques defectuosos (p.e. FAT).

*Transitorios: Errores temporales del dispositivo. Por ejemplo, caídas de tensión. La solución consiste en reintentar acceder al dispositivo un nº finito de veces, antes de declarar el error permanente. También existen rutinas de checksum (dispersión, como CRC) para detectarlos.

Errores de software:

*Errores de programación:Cuando el error se encuentra en el propio código del programa. Por ejemplo, un acceso a un cilindro, sector o pista inexistente, o a un fichero inexistente. Para solucionarlo, se devuelve un código de error para indicar al usuario que ha ocurrido.

Tipos de errores en discos magnéticos

2011-06-07T14:42:09Z

Luidela1:

Los errores típicos relacionados con los discos duros magnéticos pueden ser:

*Relacionados con el material:

**Permanentes:La unidad se encuentra mal en algún sentido. No existe forma “tradicional” de acceder a ellos. En los discos magnéticos existen dos estrategias para tratar estos errores:

***Archivo que contiene todos los sectores defectuosos.
***Mantener en una tabla aquellos bloques defectuosos (p.e. FAT).

**Transitorios: Errores temporales del dispositivo. Por ejemplo, caídas de tensión. La solución consiste en reintentar acceder al dispositivo un nº finito de veces, antes de declarar el error permanente. También existen rutinas de checksum (dispersión, como CRC) para detectarlos.

*Errores de software:

**Errores de programación:Cuando el error se encuentra en el propio código del programa. Por ejemplo, un acceso a un cilindro, sector o pista inexistente, o a un fichero inexistente. Para solucionarlo, se devuelve un código de error para indicar al usuario que ha ocurrido.

SO multiprogramables con particiones fijas

2011-06-07T14:32:50Z

Luidela1:

La memoria se encuentra dividida en particiones, en cada una habrá un proceso. Por lo tanto, se pueden ejecutar tantos procesos como particiones haya.

=Estrategias=
Las estrategias a seguir cuando no hay memoria suficiente para otro proceso son dos:
*Cancelación: "lo siento, no hay memoria libre, prueba más tarde".
*Espera: añadir el proceso a una cola hasta que haya memoria disponible.

=Limitaciones=
*Si un proceso necesita mayor memoria que la partición más grande, entonces éste no se ejecuta.
*Desperdicio de memoria. Por ejemplo, si los procesos son muy pequeños y las particiones grandes.

=Criterios de asignación=
Se lanza un proceso, y hay que elegir a qué partición va (estrategia de espera). Puede haber una cola por partición, o una sola para todas las particiones.

Ej: tenemos los siguientes procesos: m(P1) = 6KB, m(P2) = 1KB, m(P3) = 3KB, m(P4) = 31KB, m(P5) = 30KB;
suponemos que la decisión sobre la asignación de procesos a particiones se hace ordenadamente de manera consecutiva según el número del proceso
y una memoria de 64 KB divididos en 4 huecos como sigue:
_____
|_____| H1 = 8KB
|_____| H2 = 8KB
| |
|_____| H3 = 16KB
| |
| |
| | H4 = 32KB
|_____|

*'''Mejor ajuste estático''': se adjudica cada proceso a la menor partición que quepa. Si la menor en la que cabe está ocupada, se espera. Complejidad: O(1)

[[solución mejor ajuste estático|Ver solución]]

*'''Primer ajuste''': cuando una partición queda libre, se asigna el primer proceso según el orden de la cola que quepa en ella. Complejidad: O(1)

[[solución primer ajuste|Ver solución]]

*'''Mejor ajuste dinámico''': cuando una partición queda libre, se asigna el mayor proceso que quepa en ella. Complejidad: O(nlog(p))

[[solución ajuste dinámico|Ver solución]]

*'''Mejor ajuste dinámico con aplazamiento limitado''': Es una variante del criterio anterior que evita el aplazamiento indefinido. Cuando queda una partición libre, se selecciona el mayor proceso que quepa en ella, pero se cuenta el nº de veces que un proceso se aplaza. Si se superan esas '''n''' veces (umbral), se le da paso.

*'''Subparticiones''': No es un criterio como tal sino que viene a complementar a los anteriores. Si no hay un proceso que pueda aprovechar la partición madre: se asignan las subparticiones a procesos pequeños (para que el desperdicio interno sea lo menor posible). Si llega un proceso grande: los procesos pequeños se vuelcan a disco y se asigna partición madre.
''Partición madre'': tipo especial de partición que se puede dividir en múltiples particiones menores.

[[Otro ejemplo|Otro ejemplo]]

= Métodos de colocación en memoria =

*'''Montaje absoluto''': Se asigna una dirección de memoria constante, siendo por tanto este método muy restrictivo. Se utiliza para la carga del sistema operativo.

* '''Carga con reubicación''': Al realizar la carga, se le aplica a las direcciones lógicas del programa un ''offset'' o desplazamiento. Este desplazamiento es establecido por el programador antes de que se ejecute el programa. Este método es más flexible que el anterior, pero una vez cargado no se puede cambiar de partición.

* '''Reubicación dinámica''': A diferencia de la carga con reubicación, el desplazamiento se asigna en tiempo de ejecución.
** '''Reubicación dinámica parcial''': Es una variante del anterior, en la que existe también un registro límite.

= Mecanismos de protección de memoria =

Es necesario proteger el SO frente a procesos; y proteger a los procesos entre sí.

* '''Bits de protección''' : Se le asigna a cada zona/partición de la memoria principal una zona con información sobre el propietario y los permisos de lectura/escritura

* '''Ampliación registros valla''' : De esta manera se conocen la posición inicial y final, de manera que si no está entre esas dos posiciones no se permite el acceso a memoria.

Otro ejemplo

2011-06-07T14:26:50Z

Luidela1:

Ej: tenemos los siguientes procesos: m(P1)=6KB,m(P2)=1KB,m(P3)=3KB,m(P4)=31KB,m(P5)=30KB,m(P6)=2KB,m(P7)=4KB,m(P8)=1KB;
y una memoria de 64 KB divididos en 4 huecos como sigue:
_____
|_____| H1 = 8KB | m(P1)=6KB | H0(P1)=0 | t(P1)=8
|_____| H2 = 8KB | m(P2)=1KB | H0(P2)=0 | t(P2)=8
| | | m(P3)=3KB | H0(P3)=1 | t(P3)=2
|_____| H3 = 16KB | m(P4)=31KB | H0(P4)=0 | t(P4)=2
| | | m(P5)=30KB | H0(P5)=0 | t(P5)=2
| | | m(P6)=2KB | H0(P6)=0 | t(P6)=2
| | H4 = 32KB | m(P7)=4KB | H0(P7)=2 | t(P7)=2
|_____| | m(P8)=1KB | H0(P8)=0 | t(P8)=2

solución:
>: fin del proceso.

| P1| P1| P1| P1| P1| P1| P1| P1| |
H1|---|---|---|---|---|---|---|---> |
| | | | | | | | | |
| P6| P6| P7| P7| P3| P3| | | |
H2|---|--->---|--->---|---> | | |
| | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| |
H3|---|---|---|---|---|---|---|---> |
| | | | | | | | | |
| P4| P4| P5| P5| P8| P8| | | |
H4|---|--->---|--->---|---> | | |
|___|___|___|___|___|___|___|___|___|__>
0 1 2 3 4 5 6 7 8 9 t

¿A qué criterio pertenece esta solución?
--[[Usuario:Jorcalmar|Jorcalmar]] 16:42 31 may 2011 (UTC)

Soluciones:

'''a) Mejor ajuste estático''': Asociamos a cada proceso la partición menor en la que cabe. En nuestro caso:
P1: H1
P2: H2
P3: H1/H2 el que acabe primero.
P4: H4
P5: H4
P6: H1/H2 el que acabe primero.
P7: H1/H2 el que acabe primero.
P8: H1/H2 el que acabe primero.

Como vemos, usando este criterio, la partición H3 se queda siempre libre. Éste es uno de los inconvenientes del mejor ajuste estático, no aprovechamos todas las particiones.

| P1| P1| P1| P1| P1| P1| P1| P1| P3| P3| P7| P7
H1|---|---|---|---|---|---|---|--->---|--->---|--->
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| P6| P6| P8| P8
H2|---|---|---|---|---|---|---|--->---|-->|---|--->
| | | | | | | | | | | | |
| | | | | | | | | | | | |
H3| | | | | | | | | | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| | | | | | | | |
H4|---|--->---|---> | | | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

'''b) Primer ajuste:''' En este criterio, elegimos el primer proceso que quepa en la partición que tengamos en la cola de procesos en espera.
Para este criterio, es conveniente verificar en cada instante de tiempo qué procesos tengo en espera (y en qué orden) y qué particiones se me van quedando libres en cada instante.

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| | | | |
H2|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P6| P6| P8| P8| P3| P3| | | | | | |
H3|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| P7| P7| | | | | | |
H4|---|--->---|--->---|---> | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

'''c) Mejor ajuste dinámico:'''En este criterio, hemos de seleccionar el mayor proceso que quepa en nuestra partición. Para esto debemos recorrer toda la cola de procesos en espera. Como inconveniente nos encontramos con que los procesos menores quedarán aplazados en favor de los procesos de mayor tamaño. Una vez más debemos tener cuidado verificando el estado de la cola de espera en cada instante de tiempo para la elección de los procesos.

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P6| P6| P7| P7| P3| P3| | | | | | |
H2|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P2| P2| P2| P2| P2| P2| P2| P2| | | | |
H3|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| P8| P8| | | | | | |
H4|---|--->---|--->---|---> | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

Como podemos observar, el proceso 8, queda aplazado hasta que el resto de procesos mayores han terminado. Para solucionar este problema tenemos el siguiente criterio, mayor que quepa con aplazamiento, en el cual hacemos uso de una variable 'umbral' que selecciona aquellos procesos que han sido aplazados un número dado de veces.--[[Usuario:Jorcalmar|Jorcalmar]] 17:43 31 may 2011 (UTC)

--El c en realidad,¿no seria?:

| P1| P1| P1| P1| P1| P1| P1| P1| | | | |
H1|---|---|---|---|---|---|---|---> | | | |
| | | | | | | | | | | | |
| P7| P7| P6| P6| P8| P8| | | | | | |
H2|---|--->---|--->---|---> | | | | | |
| | | | | | | | | | | | |
| P3| P3| P2| P2| P2| P2| P2| P2| P2| P2| | |
H3|---|--->---|---|---|---|---|---|---|---> | |
| | | | | | | | | | | | |
| P4| P4| P5| P5| | | | | | | | |
H4|---|--->---|---> | | | | | | | |
|___|___|___|___|___|___|___|___|___|__ |___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12

Cambia las asignaciones de H2 ya que P7>P3>P6 y por ese mismo criterio, en H3 primero entraria P3 y P8 entraria en H2.--[[Usuario:Luidela1|Luidela1]] 14:26 7 jun 2011 (UTC)

Solución de los ejercicios de concurrencia

2011-05-09T15:35:34Z

Luidela1:

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4|#1-El programa ya termina
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #2| #2| | | | #2| #3| #4| #1| #2| #3| #4| El programa termina.
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---| |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

En este ejercicio, el hilo 2 se queda esperando continuamente a que el hilo 1 libere el cerrojo para poder acceder a la función.
El programa finaliza en el hilo 1 cuando llega dos veces a la instrucción 4 (bucle for).

Modificación:

Solución:

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4| > | | | | | | | |
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | | | |
| | | | | | | | | | | | | | | | | | | | | | |
| | | | #1| __| __| | | | __| __| __| | | | #2| #3| #4| #1| #2| #3| #4|
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---|---|---|---|
| | | | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

Posible solución:

Los hilos comparten variables por lo que la variable i está siendo compartida por ambos hilos. Además, al ser los cerrojos un control de concurrencia de espera activa, tiene que comprobar continuamente la condición que me permite acceder a la sección crítica. En un bucle for, el incremento se hace una vez realizada la iteración, por lo que tendrá que comprobar en la instrucción 1 si el contador cumple la condición o no. Dicho esto y si no me equivoco la solución sería la siguiente:

| #1| #2| #3| | | | #4| #1| #2| | | | #3| #4| #1| | | | | |
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #2| #2| | | | #2| #3| #4| #1| |
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---| |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Posible solución2: Lo que explicas esta muy bien, pero creo que la condición que expones en tu apartado es i=<2, cuando el ejercicio pide i<2. Por lo que habria que cortar un trozo, ¿no?

| #1| #2| #3| | | | #4| #1| #1| | | | | | | | | | | |
H1 |---|---|---| | | |---|---|---| | | |---|---|---| | | | | |
| | | | | | | | | | | | | | | | | | | | |
| | | | #1| #2| #2| | | | #2| #3| #4| | | | | | | | |
H2 | | | |---|---|---| | | |---|---|---| | | |---|---|---|---| |
| | | | | | | | | | | | | | | | | | | | |
|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|___|
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Yo creo que esta bien ya que es i<2 y empieza con i = 0 --[[Usuario:Luidela1|Luidela1]] 15:35 9 may 2011 (UTC)

Mensajería

2011-05-04T09:07:55Z

Luidela1: erratas

Es una unidad de información que se intercambia entre dos o más procesos.

Mediante los mensajes podemos transmitir información y sincronizar procesos (mediante la espera de un cierto mensaje).

Los sistemas operativos generalmente ofrecen dos llamadas al sistema (o primitivas básicas) para que los procesos enviar y recibir mensajes:

* send(mensaje): Para enviar un mensaje
* receive(mensaje): Para recibir un mensaje

== Destino y fuente ==

* '''Denominación Directa'''
** Se emplea ID para identificar al destinatario.
** Valores especiales: BROADCAST (a todos), MULTICAST (a un grupo).

* '''Denominación Indirecta'''
** Se emplea un elemento intermediario.
** Recurso compartido especial en el sistema: BUZÓN.
** Habiendo intermediarios, hay que comprobar las identidades pues pueden ser falsas/erróneas

== Formas de transmisión ==

* '''Transmisión por copia'''
** ''Directa'': el mensaje se copia de espacio de emisor a espacio de receptor.
** ''Indirecta'': el mensaje se copia de espacio de emisor a espacio (buzón) de SO, y de ahí a espacio de receptor.

* '''Transmisión por referencia'''
** ''Directa'': lo que se copia es un puntero al mensaje
** ''Global'': el emisor crea mensaje en espacio de SO, y se copia a espacio de receptor un puntero al mismo.

* '''Transmisión por copia de escritura''': el mensaje sólo se copia si se modifica por emisor o receptor.

== Formas de comunicación ==

* Comportamiento del emisor, '''send()'''
**Síncrona: el proceso emisor que realiza el send() queda bloqueado hasta que el receptor llama a recv()
**Asíncrona: suponemos capacidad de almacenamiento en el destinatario o en el buzón. Allí acumulamos los mensajes entrantes y el receptor irá leyendo cuando pueda. Es más ágil pero el destinatario/buzón necesita capacidad de almacenamiento, la cual será limitada y los mensajes posteriores pueden caer en saco roto

* Comportamiento del receptor, '''recv()'''
** Bloqueante: un recv() sin mensajes a procesar pasa a estado bloqueado. Si se hace un send() vuelve a estado preparado
** No bloqueante: recv() sin mensajes a procesar devuelve un "prueba más tarde"

== Formato de los mensajes ==

=== Fijo ===

Los procesos acuerdan emplear un formato fijo para sus mensajes.

Ejemplo: Simple Network Time Protocol. Ver http://tools.ietf.org/html/rfc4330, sección 4, Message Format.

1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|LI | VN |Mode | Stratum | Poll | Precision |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Delay |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Dispersion |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Reference Identifier |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Reference Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Originate Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Receive Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Transmit Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Key Identifier (optional) (32) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| |
| Message Digest (optional) (128) |
| |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

=== Variable ===

* Type-Length-Value.

Ejemplo: Usado en Netlink para la codificación de atributos de un mensaje. Ver Communicating between the kernel and user-space in Linux using Netlink Sockets (1984.lsi.us.es/~pablo/docs/spae.pdf).

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Length | Type |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
/ /
/ Value /
/ /
/////////////////////////////////////////////////////////////////

* Text-based human-readable.

** Comma-Separated Value (CSV): http://en.wikipedia.org/wiki/Comma-separated_values
** Extensible Markup Language (XML): http://en.wikipedia.org/wiki/XML
** JavaScript Object Notation (JSON): http://en.wikipedia.org/wiki/JSON

=== Mixto ===

Los procesos acuerdan emplear mensaje con partes cuyo formato es fijo, como por ejemplo una cabecera inicial, seguido de partes de tamaño variable.

Ejemplo: Internet Protocol (IPv4). Ver http://www.ietf.org/rfc/rfc791.txt, sección 3.1.

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| IHL |Type of Service| Total Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Identification |Flags| Fragment Offset |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Time to Live | Protocol | Header Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options | Padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
/ /
/ Payload /
/ /
/////////////////////////////////////////////////////////////////

== Mensajería a través de la red ==

* Unidad del destinatario
* Fiabilidad en la transmisión
* Formato de los datos (http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html): Enviar un entero a través de la red puede ser un problema debido a la forma en el que se representan los datos en la memoria dependiente de la arquitectura. Por ejemplo, un PC con arquitectura Intel x86 emplea formato little-endian, mientras que un SPARC de Sun Microsystems (ahora Oracle) emplea big-endian.

** Little Endian: Bytes menos significativo al principio.

<source lang="c">
int main(void)
{
int a = 10, i;
char *p = &a;

for (i=0; i<sizeof(a); i++) {
printf("posición %d: %.2x\n", i, p[i]);
}
}
</source>

Muestra el siguiente resultado en un PC:

posición 0: 0a (n+3)
posición 1: 00 (n+2)
posición 2: 00 (n+1)
posición 3: 00 (n)

** Big Endian: Bytes menos significativo al final.

posición 0: 00 (n)
posición 1: 00 (n+1)
posición 2: 00 (n+2)
posición 3: 0a (n+3)

En Internet se sigue la convención de expresar datos en Big Endian, habría que hacer la conversión. Habría que usar '''ntohl''' (network to host long).

En little-endian, la implementación de ntohl es la siguiente:

#define __constant_ntohl(x) ___constant_swab32((__be32)(x)

Ver /usr/include/linux/byteorder/little_endian.h

mientras que en big-endian es:

#define __constant_ntohl(x) ((__u32)(__be32)(x))

Si empleamos formato textuales, como CSV, XML o JSON, que codifican la información en bytes, no tenemos este problema.

Mensajería

2011-05-04T08:54:35Z

Luidela1:

Es una unidad de información que se intercambia entre dos o más procesos.

Mediante los mensajes podemos transmitir información y sincronizar procesos (mediante la espera de un cierto mensaje).

Los sistemas operativos generalmente ofrecen dos llamadas al sistema (o primitivas básicas) para que los procesos enviar y recibir mensajes:

* send(mensaje): Para enviar un mensaje
* receive(mensaje): Para recibir un mensaje

== Destino y fuente ==

* '''Denominación Directa'''
** Se emplea ID para identificar al destinatario.
** Valores especiales: BROADCAST (a todos), MULTICAST (a un grupo).

* '''Denominación Indirecta'''
** Se emplea un elemento intermediario.
** Recurso compartido especial en el sistema: BUZÓN.
** Habiendo intermediarios, hay que comprobar las identidades pues pueden ser falsas/erróneas

== Formas de transmisión ==

* '''Transmisión por copia'''
** ''Directa'': el mensaje se copia de espacio de emisor a espacio de receptor.
** ''Indirecta'': el mensaje se copia de espacio de emisor a espacio (buzón) de SO, y de ahí a espacio de receptor.

* '''Transmisión por referencia'''
** ''Directa'': lo que se copia es un puntero al mensaje
** ''Global'': el emisor crea mensaje en espacio de SO, y se copia a espacio de receptor un puntero al mismo.

* '''Transmisión por copia de escritura''': el mensaje sólo se copia si se modifica por emisor o receptor.

== Formas de comunicación ==

* Comportamiento del emisor, '''send()'''
**Síncrona: el proceso emisor que realiza el send() queda bloqueado hasta que el receptor llama a recv()
**Asíncrona: suponemos capacidad de almacenamiento en el destinatario o en el buzón. Allí acumulamos los mensajes entrantes y el receptor irá leyendo cuando pueda. Es más ágil pero el destinatario/buzón necesita capacidad de almacenamiento, la cual será limitada y los mensajes posteriores pueden caer en saco roto

* Comportamiento del receptor, '''recv()'''
** Bloqueante: un recv() sin mensajes a procesar pasa a estado bloqueado. Si se hace un send() vuelve a estado preparado
** No bloqueante: recv() sin mensajes a procesar devuelve un "prueba más tarde"

== Formato de los mensajes ==

=== Fijo ===

Los procesos acuerdan emplear un formato fijo para sus mensajes.

Ejemplo: Simple Network Time Protocol. Ver http://tools.ietf.org/html/rfc4330, sección 4, Message Format.

1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|LI | VN |Mode | Stratum | Poll | Precision |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Delay |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Root Dispersion |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Reference Identifier |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Reference Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Originate Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Receive Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| Transmit Timestamp (64) |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Key Identifier (optional) (32) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
| |
| Message Digest (optional) (128) |
| |
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

=== Variable ===

* Type-Length-Value.

Ejemplo: Usado en Netlink para la codificación de atributos de un mensaje. Ver Communicating between the kernel and user-space in Linux using Netlink Sockets (1984.lsi.us.es/~pablo/docs/spae.pdf).

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Length | Type |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
/ /
/ Value /
/ /
/////////////////////////////////////////////////////////////////

* Text-based human-readable.

** Comma-Separated Value (CSV): http://en.wikipedia.org/wiki/Comma-separated_values
** Extensible Markup Language (XML): http://en.wikipedia.org/wiki/XML
** JavaScript Object Notation (JSON): http://en.wikipedia.org/wiki/JSON

=== Mixto ===

Los procesos acuerdan emplear mensaje con partes cuyo formato es fijo, como por ejemplo una cabecera inicial, seguido de partes de tamaño variable.

Ejemplo: Internet Protocol (IPv4). Ver http://www.ietf.org/rfc/rfc791.txt, sección 3.1.

0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| IHL |Type of Service| Total Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Identification |Flags| Fragment Offset |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Time to Live | Protocol | Header Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options | Padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
/ /
/ Payload /
/ /
/////////////////////////////////////////////////////////////////

== Mensajería a través de la red ==

* Unidad del destinatario
* Fiabilidad en la transmisión
* Formato de los datos (http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/Data/endian.html): Enviar un entero a través de la red puede ser un problema debido a la forma en el que se representan los datos en la memoria dependiente de la arquitectura. Por ejemplo, un PC con arquitectura Intel x86 emplea formato little-endian, mientras que un SPARC de Sun Microsystems (ahora Oracle) empla big-endian.

** Little Endian: Bytes menos significativo al principio.

<source lang="c">
int main(void)
{
int a = 10, i;
char *p = &a;

for (i=0; i<sizeof(a); i++) {
printf("posición %d: %.2x\n", i, p[i]);
}
}
</source>

Muestra el siguiente resultado en un PC:

posición 0: 0a (n+3)
posición 1: 00 (n+2)
posición 2: 00 (n+1)
posición 3: 00 (n)

** Big Endian: Bytes menos significativo al final.

posición 0: 00 (n)
posición 1: 00 (n+1)
posición 2: 00 (n+2)
posición 3: 0a (n+3)

En Internet se sigue la convención de expresar datos en Big Endian, habría que hacer la conversión. Habría que usar '''ntohl''' (network to host long).

En little-endian, la implementación de ntohl es la siguiente:

#define __constant_ntohl(x) ___constant_swab32((__be32)(x)

Ver /usr/include/linux/byteorder/little_endian.h

mientras que en big-endian es:

#define __constant_ntohl(x) ((__u32)(__be32)(x))

Si empleamos formato textuales, como CSV, XML o JSON, que codifican la información en bytes, no tenemos este problema.

Concurrencia de procesos

2011-05-02T11:36:08Z

Luidela1:

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, 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 =

La programación concurrente se trata del conjunto de técnicas que nos permiten elaborar programas que resuelven situaciones de concurrencia. En programación concurrente, el programador emplea alguno de los mecanismos de arbitraje que ofrece el sistema operativo, ya sean los de sincronización o mensajería, para resolver el problema de concurrencia.

= 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''.
*[[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.

Usuario:Luidela1

2011-04-22T10:41:20Z

Luidela1: Página nueva: Luis Francisco De La Llave Gómez

Luis Francisco De La Llave Gómez

Mecanismos de sincronización

2011-04-22T10:40:25Z

Luidela1:

= Optimistas =

Este mecanismo debe emplearse si el programador considera que la frecuencia de acceso a un recurso compartido es baja, es decir, que supone que la probabilidad de coincidencia de dos o más procesos al recurso compartido es baja.

El siguiente ejemplo muestra el código ejecutado por dos hilos: hx y hy de un mismo proceso.

<source lang="c">
int compartida = 1, tmp;
retry:
tmp = compartida; /* almaceno el valor de la variable compartida en una temporal. */
tmp++; /* actualizo la varible temporal. */
if (compartida+1 != tmp) /* compruebo si la variable compartida ha sido modificada */
goto retry; /* mientras operaba con la variable temporal. */
</source>

La principal ventaja es el mayor grado de paralelismo.

Los inconvenientes de este tipo de mecanismo son dos:

* Se consume más memoria, pues hay que realizar una copia del recurso compartido para efectuar la comprobación.
* En situaciones de coincidencia, se tiene que volver a realizar la operación, por tanto, se desperdician recursos de procesamiento.

Por último, si el programador ha empleado una aproximación optimista para una situación en la que la frecuencia de coincidencia es alta, podría darse el caso de que un hilo no progrese en su ejecución de manera indefinida, al tener que volver a reintentar la actualización una y otra vez hasta conseguirlo sin que haya concurrencia.

= Pesimista =
Este mecanismo debe emplear si se considera que la frecuencia de acceso al recurso compartido es alta.

En este mecanismo disponemos de tres partes:

* El protocolo de entrada, en el que se emplea un mecanismo que no permite continuar con la ejecución si otro y otros procesos están accediendo al recurso compartido.
* La sección crítica, en el que se se realizan las operaciones pertinentes con el recurso compartido.
* El protocolo de salida, en el que se vuelve a permitir el acceso al recurso compartido.

El siguiente ejemplo muestra como se implementa el control de concurrencia pesimista para 2 hilos, hx y hy:

<source lang="c">
int compartida = 1;
protocolo_de_entrada(); /* no permito acceso a variable compartida. */
compartida++; /* sección crítica: actualización de la variable compartidad. */
protocolo_de_salida(); /* vuelvo a permitir acceso a la variable compartida. */
</source>

Los protocolos de entrada y salida son, generalmente, operaciones costosas en términos de recursos de procesamiento.

El inconveniente de este mecanismo es:

*Que aunque siempre se pueda implementar, se fuerzan esperas que pueden llegar a ser innecesarias.

Por último, se podría emplear un control de concurrencia pesimista para resolver un problema que se resuelve con un control de concurrencia optimista, pero no al revés.

== Implementación del control de concurrencia pesimista ==

El control de concurrencia pesimista se puede implementar de dos formas mediante:

* Espera ocupada o activa, mediante cerrojos. En este mecanismo se comprueba continuamente la condición que permite franquear en el protocolo de entrada, por tanto, el proceso permanece en estado activo comprobando continuadamente la condición que le permite progresar en su ejecución.
* Espera no ocupada o bloqueante, mediante semáforos, monitores y mensajes. Estos mecanismos hacen que el proceso pase a estado bloqueado cuando no se puede franquear el protocolo de entrada, por tanto, al quedar un proceso que no puede progresar en estado bloqueado, el planificador de procesos tiene que seleccionar a otro proceso.

Mecanismos de sincronización

2011-04-22T10:30:12Z

Luidela1: