<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="es">
		<id>https://1984.lsi.us.es/wiki-ssoo/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Lorruimor</id>
		<title>Wiki de Sistemas Operativos - Contribuciones del usuario [es]</title>
		<link rel="self" type="application/atom+xml" href="https://1984.lsi.us.es/wiki-ssoo/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=Lorruimor"/>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php/Especial:Contribuciones/Lorruimor"/>
		<updated>2026-05-05T19:29:42Z</updated>
		<subtitle>Contribuciones del usuario</subtitle>
		<generator>MediaWiki 1.29.0</generator>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=P%C3%A1gina_con_listado_de_personas_que_han_contribuido&amp;diff=2406</id>
		<title>Página con listado de personas que han contribuido</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=P%C3%A1gina_con_listado_de_personas_que_han_contribuido&amp;diff=2406"/>
				<updated>2012-01-26T17:42:41Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;A continuación, la lista de usuarios/as de la Universidad de Sevilla que han contribuido a la wiki. Si ponéis tu usuario/a estás solicitando al profesor que evalúe tus contribuciones a la wiki para la subida de notas de hasta 2 puntos posible:&lt;br /&gt;
&lt;br /&gt;
* luigarhor&lt;br /&gt;
* rafperper&lt;br /&gt;
* sergaralo&lt;br /&gt;
* josalgrod1&lt;br /&gt;
* felgaroje&lt;br /&gt;
* luimunlei&lt;br /&gt;
* [https://1984.lsi.us.es/wiki-ssoo/index.php/Usuario:Lorruimor Lorruimor]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=P%C3%A1gina_con_listado_de_personas_que_han_contribuido&amp;diff=2405</id>
		<title>Página con listado de personas que han contribuido</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=P%C3%A1gina_con_listado_de_personas_que_han_contribuido&amp;diff=2405"/>
				<updated>2012-01-26T17:41:17Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;A continuación, la lista de usuarios/as de la Universidad de Sevilla que han contribuido a la wiki. Si ponéis tu usuario/a estás solicitando al profesor que evalúe tus contribuciones a la wiki para la subida de notas de hasta 2 puntos posible:&lt;br /&gt;
&lt;br /&gt;
* luigarhor&lt;br /&gt;
* rafperper&lt;br /&gt;
* sergaralo&lt;br /&gt;
* josalgrod1&lt;br /&gt;
* felgaroje&lt;br /&gt;
* luimunlei&lt;br /&gt;
* [[Lorruimor]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=P%C3%A1gina_con_listado_de_personas_que_han_contribuido&amp;diff=2404</id>
		<title>Página con listado de personas que han contribuido</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=P%C3%A1gina_con_listado_de_personas_que_han_contribuido&amp;diff=2404"/>
				<updated>2012-01-26T17:40:58Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;A continuación, la lista de usuarios/as de la Universidad de Sevilla que han contribuido a la wiki. Si ponéis tu usuario/a estás solicitando al profesor que evalúe tus contribuciones a la wiki para la subida de notas de hasta 2 puntos posible:&lt;br /&gt;
&lt;br /&gt;
* luigarhor&lt;br /&gt;
* rafperper&lt;br /&gt;
* sergaralo&lt;br /&gt;
* josalgrod1&lt;br /&gt;
* felgaroje&lt;br /&gt;
* luimunlei&lt;br /&gt;
* [[lorruimor]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Archivo:Sdf.svg&amp;diff=2331</id>
		<title>Archivo:Sdf.svg</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Archivo:Sdf.svg&amp;diff=2331"/>
				<updated>2012-01-17T17:38:59Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mejoras_en_la_demora_de_rotaci%C3%B3n&amp;diff=2330</id>
		<title>Mejoras en la demora de rotación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mejoras_en_la_demora_de_rotaci%C3%B3n&amp;diff=2330"/>
				<updated>2012-01-17T16:23:19Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Para mejorar los tiempos de espera asociados a la demora de rotación se pueden intercalar los sectores que forman parte de una pista. Esto se basa en que los tiempos de lectura/escritura y transmisión de los datos no son despreciables, con lo que cuando el dispositivo lee unos datos en un sector, mientras que espera a que se transmitan, el disco ha seguido girando y posiblemente se encuentre en otro sector. Por tanto, si los colocamos consecutivamente, tendremos que esperar toda una vuelta para acceder al siguiente. Sin embargo, colocándolos de manera alterna, podemos tener la suerte de sólo tener que esperar una fracción del disco.&lt;br /&gt;
&lt;br /&gt;
Para este procedimiento se usa una variable conocida con el nombre de '''grado de intercalación (n)''' que dependerá de la velocidad de rotación del disco para usar un valor u otro.&lt;br /&gt;
&lt;br /&gt;
==Ejemplo==&lt;br /&gt;
&lt;br /&gt;
[[Archivo:Sdf.png]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mejoras_en_la_demora_de_rotaci%C3%B3n&amp;diff=2329</id>
		<title>Mejoras en la demora de rotación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mejoras_en_la_demora_de_rotaci%C3%B3n&amp;diff=2329"/>
				<updated>2012-01-17T16:22:33Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Para mejorar los tiempos de espera asociados a la demora de rotación se pueden intercalar los sectores que forman parte de una pista. Esto se basa en que los tiempos de lectura/escritura y transmisión de los datos no son despreciables, con lo que cuando el dispositivo lee unos datos en un sector, mientras que espera a que se transmitan, el disco ha seguido girando y posiblemente se encuentre en otro sector. Por tanto, si los colocamos consecutivamente, tendremos que esperar toda una vuelta para acceder al siguiente. Sin embargo, colocándolos de manera alterna, podemos tener la suerte de sólo tener que esperar una fracción del disco.&lt;br /&gt;
&lt;br /&gt;
Para este procedimiento se usa una variable conocida con el nombre de grado de intercalación (n) que dependerá de la velocidad de rotación del disco para usar un valor u otro.&lt;br /&gt;
&lt;br /&gt;
[[Archivo:Sdf.png]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Archivo:Sdf.png&amp;diff=2328</id>
		<title>Archivo:Sdf.png</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Archivo:Sdf.png&amp;diff=2328"/>
				<updated>2012-01-17T16:20:52Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: mejora en demora de rotación&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;mejora en demora de rotación&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2238</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2238"/>
				<updated>2011-12-20T13:30:07Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida está dividida en tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
**Registros de órdenes&lt;br /&gt;
**Registros de estado&lt;br /&gt;
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
El orden en el que intervienen las diferentes partes es:&lt;br /&gt;
&lt;br /&gt;
 SO &amp;lt;==&amp;gt; [Interfaz del bus &amp;lt;==&amp;gt; Puerto de lectura/escritura &amp;lt;==&amp;gt; Interfaz del dispositivo]&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Harvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2237</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2237"/>
				<updated>2011-12-20T13:24:12Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida está dividida en tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
**Registros de órdenes&lt;br /&gt;
**Registros de estado&lt;br /&gt;
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
El orden en el que intervienen las diferentes partes es:&lt;br /&gt;
&lt;br /&gt;
 SO &amp;lt;==&amp;gt; Interfaz del bus &amp;lt;==&amp;gt; Puerto de lectura/escritura &amp;lt;==&amp;gt; Interfaz del dispositivo&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Harvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2235</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2235"/>
				<updated>2011-12-20T13:16:28Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida está dividida en tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
**Registros de órdenes&lt;br /&gt;
**Registros de estado&lt;br /&gt;
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Hardvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2234</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2234"/>
				<updated>2011-12-20T13:16:09Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida esta dividida en tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
**Registros de órdenes&lt;br /&gt;
**Registros de estado&lt;br /&gt;
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Hardvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2233</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2233"/>
				<updated>2011-12-20T13:08:59Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida es de tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
**Registros de órdenes&lt;br /&gt;
**Registros de estado&lt;br /&gt;
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Hardvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2232</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2232"/>
				<updated>2011-12-20T13:06:46Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida es de tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
&lt;br /&gt;
**Registros de órdenes&lt;br /&gt;
**Registros de estado&lt;br /&gt;
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Hardvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2231</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2231"/>
				<updated>2011-12-20T13:06:28Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida es de tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
&lt;br /&gt;
 *Registros de órdenes&lt;br /&gt;
 *Registros de estado&lt;br /&gt;
 *Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Hardvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2230</id>
		<title>Estructura típica de dispositivo E/S</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Estructura_t%C3%ADpica_de_dispositivo_E/S&amp;diff=2230"/>
				<updated>2011-12-20T13:06:04Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En general, la estructura típica de un dispositivo de entrada/salida es de tres partes:&lt;br /&gt;
&lt;br /&gt;
* '''Adaptador de Entrada/Salida del ordenador, o interfaz del bus:''' Se encarga de traducir las señales al dialecto empleado por el bus del ordenador.&lt;br /&gt;
* '''Adaptador de Entrada/Salida del dispositivo, o interfaz del dispositivo:''' Se encarga de traducir las señales al dialecto empleado por el dispositivo.&lt;br /&gt;
* '''Control del dispositivo, o puerto de lectura/escritura:''' Ofrece una interfaz que es empleada por el gestor de dispositivos para gobernar el dispositivo, que dispone de:&lt;br /&gt;
&lt;br /&gt;
**Registros de órdenes&lt;br /&gt;
**Registros de estado&lt;br /&gt;
**Registros de lectura/escritura, o alternativamente una pequeña memoria propia.&lt;br /&gt;
&lt;br /&gt;
Cuanto más elaborado sea el puerto de lectura/escritura, mayor rendimiento se puede llegar a alcanzar, puesto que el gestor de dispositivo será más sencillo (y eso implica menor número de instrucciones a ejecutar en el gestor de dispositivo).&lt;br /&gt;
&lt;br /&gt;
= Arquitecturas de ordenadores típicas =&lt;br /&gt;
&lt;br /&gt;
* Arquitectura de Von Neumann (http://es.wikipedia.org/wiki/Arquitectura_de_von_Neumann)&lt;br /&gt;
* Arquitectura de Hardvard (http://es.wikipedia.org/wiki/Arquitectura_Harvard)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Usuario:Lorruimor&amp;diff=2228</id>
		<title>Usuario:Lorruimor</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Usuario:Lorruimor&amp;diff=2228"/>
				<updated>2011-12-20T11:48:38Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: Página creada con 'Lorenzo Ruiz Moreno'&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Lorenzo Ruiz Moreno&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_reemplazo&amp;diff=2200</id>
		<title>Criterios de reemplazo</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_reemplazo&amp;diff=2200"/>
				<updated>2011-12-19T09:45:45Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;La evaluación se hace en base a la '''tasa de fallos de página''', que es el número de fallos de página entre el número de accesos totales a página, con lo que su valor oscila en el rango [0,1].&lt;br /&gt;
&lt;br /&gt;
El fallo de página se produce cuando se accede a una posición de memoria que pertenece a una página de memoria que esta descargada en disco.&lt;br /&gt;
     &lt;br /&gt;
&amp;lt;math&amp;gt;tasa fallos pagina = \frac{total fallos de pagina}{total accesos a pagina}&amp;lt;/math&amp;gt;&lt;br /&gt;
&lt;br /&gt;
También hay que tener en cuenta el contexto, si estamos en arranque en frío o en caliente, así como el cumplimiento del principio de localidad espacial y temporal. &lt;br /&gt;
&lt;br /&gt;
* Arranque en frío : se dan muchos fallos de página al principio, ya que los procesos se acaban de lanzar y ninguno esta cargado en memoria principal.&lt;br /&gt;
* Arranque en caliente : se suponen ya cargadas las páginas de los procesos en memoria principal.&lt;br /&gt;
&lt;br /&gt;
== Criterio de página óptima ==&lt;br /&gt;
&lt;br /&gt;
Este es un criterio teórico que viene a establecer la cota inferior de la ''tasa de fallos de página''. Consiste en escoger la página que mayor tiempo va a tardar en utilizarse. Este es el mejor caso, pero se necesita conocimiento de futuro, de ahí que sea un criterio teórico.&lt;br /&gt;
&lt;br /&gt;
Ejemplo: Secuencia de acceso a página : 2,2,3,1,1,3,4,5,1,1,2,3,4&lt;br /&gt;
          Suponiendo arranque en frío   &lt;br /&gt;
                                         ___1_____2_____3_____4___&lt;br /&gt;
                   memoria principal     |     |     |     |     |&lt;br /&gt;
                    de 4 marcos          |_____|_____|_____|_____|&lt;br /&gt;
&lt;br /&gt;
*[[sol_1|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio de página pésima ==&lt;br /&gt;
&lt;br /&gt;
Este también es teórico y viene a establecer la cota superior de la ''tasa de fallos de página'', para ver lo peor que podría comportarse un criterio. Consiste en seleccionar la página que menor tiempo tardará en usarse.&lt;br /&gt;
&lt;br /&gt;
*[[sol_2|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio de selección estocástica (aleatoria) ==&lt;br /&gt;
&lt;br /&gt;
Se trata también de un criterio teórico, serviría para aproximar la cota media de la ''tasa de fallos de página''. Consiste en seleccionar una página al azar.&lt;br /&gt;
&lt;br /&gt;
== Criterio MRU('''M'''ost '''R'''ecently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Se selecciona la última página a la que se ha accedido. Podría implementarse con una LIFO por orden de acceso.&lt;br /&gt;
&lt;br /&gt;
*[[sol_3|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio por orden de carga FIFO ==&lt;br /&gt;
&lt;br /&gt;
Se selecciona la página que más tiempo lleva cargada en memoria principal. Se implementa con una FIFO por orden de carga, es decir, a medida que se cargan en memoria principal las páginas son añadidas a la cola. Un problema es que suele suceder que las páginas más usadas tienden a estar mucho tiempo en memoria principal y este criterio va contra eso.&lt;br /&gt;
&lt;br /&gt;
*[[sol_5|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio NRU ('''N'''ot '''R'''ecently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Ofrece dos bits para cada página:&lt;br /&gt;
* Bit R : Se pone a 1 si la página ha sido usada (tanto para lectura como para escritura).&lt;br /&gt;
* Bit M : Se pone a 1 si la página es modificada (escritura).&lt;br /&gt;
&lt;br /&gt;
En resumen, siempre se pone a 1 el bit R, y solo se toca M cuando se accede a escritura.&lt;br /&gt;
&lt;br /&gt;
Para seleccionar la página víctima iteramos sobre los marcos cargados en memoria (comenzando por el primero de ellos) buscando el que cumpla lo siguiente, en este orden:&lt;br /&gt;
&lt;br /&gt;
# R=0, M=0&lt;br /&gt;
# R=0, M=1&lt;br /&gt;
# R=1, M=0&lt;br /&gt;
# R=1, M=1&lt;br /&gt;
&lt;br /&gt;
Periódicamente se pone a cero el bit R.&lt;br /&gt;
&lt;br /&gt;
*[[sol_6|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio de 2ª oportunidad ==&lt;br /&gt;
&lt;br /&gt;
Se trata de la combinación de los criterios FIFO y NRU, pero sin emplear el bit M de NRU. Cuando hay que seleccionar una página víctima, se recorre la lista de páginas por orden de carga en memoria hasta encontrar alguna que tenga el bit R a 0. Durante la iteración, si se encuentra una cuyo bit R valga 1, se pone a 0, se retira de la lista y se añade al final (para darle una segunda oportunidad). Cuando se añade una nueva página, se añade al final de la cola con el bit R a 1.&lt;br /&gt;
&lt;br /&gt;
*[[sol_7|Solución]]&lt;br /&gt;
&lt;br /&gt;
;Criterio del reloj: Es una variante en la manera de implementar la 2ª oportunidad. Se emplea una lista circular. En lugar de eliminar y añadir elementos al final de la FIFO, mantenemos un puntero a la página siguiente a la última página víctima seleccionada.&lt;br /&gt;
&lt;br /&gt;
*[[sol_reloj|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio LRU ('''L'''east '''R'''ecently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Es justamente el criterio contrario al MRU. En LRU elegimos la página que más tiempo lleve sin ser accedida. Se implementa mediante una FIFO que mantiene el '''orden de acceso''' a las páginas. Es decir, cada vez que se accede a una página, en caso de estar ya en la FIFO, se retira de la cola y se añade al final.&lt;br /&gt;
&lt;br /&gt;
*[[sol_8|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio LFU ('''L'''east '''F'''recuently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Se selecciona a la página que haya sido accedida con menor frecuencia. Se implementa mediante un contador. Básicamente, por cada acceso se incrementa el contador de uso de la página. La página víctima será aquella con menor contador. Cuando una página es expulsada a disco su contador pasa a ser cero.&lt;br /&gt;
&lt;br /&gt;
*[[sol_9|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Aproximación discreta LRU ==&lt;br /&gt;
&lt;br /&gt;
Consiste en LFU + LRU. Se usa el bit R. Se itera periódicamente sobre la lista de páginas si R = 0 entonces aumento el contador; si R está activado se desactiva y el contador se pone a cero. Ante una sustitución: prescindir de la que tiene mayor valor en el contador. Ojito! Cuando llega un elemento, el contador se inicializa a 0, puesto que solo se modifica en los checkpoints, no con cada acceso&lt;br /&gt;
&lt;br /&gt;
*[[sol_9.2|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Sustitución por envejecimiento ==&lt;br /&gt;
&lt;br /&gt;
Se emplea un registro R de N bits. Por cada acceso se pone a 1 el bit más significativo. Periódicamente se desplaza hacia la derecha el registro R. La página víctima será la que tenga el menor valor en el registro R (en caso de empate se emplea otro criterio). La información que contienen los bits menos significativos se pierden al realizar desplazamientos. Este criterio permite mantener un historial de acceso a las páginas, para seleccionar como víctima aquella que lleve más tiempo sin ser accedida.&lt;br /&gt;
&lt;br /&gt;
*[[sol_10|Solución]]&lt;br /&gt;
&lt;br /&gt;
= Implementaciones =&lt;br /&gt;
&lt;br /&gt;
En el [[Algoritmos de criterios de reemplazo|Portal de la comunidad]] se encuentran implementados algunos de los anteriores criterios como ayuda para ver su funcionamiento.&lt;br /&gt;
Creo que los algoritmos están bien (coinciden con las soluciones), pero si alguien decide probarlos no estaría mal que los revisase por encima. --[[Usuario:Alexrdp|Alexrdp]] 16:24 6 jun 2011 (UTC)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_reemplazo&amp;diff=2199</id>
		<title>Criterios de reemplazo</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Criterios_de_reemplazo&amp;diff=2199"/>
				<updated>2011-12-19T09:45:12Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Criterio de selección estocástica (aleatoria) */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;La evaluación se hace en base a la ''tasa de fallos de página'', que es el número de fallos de página entre el número de accesos totales a página, con lo que su valor oscila en el rango [0,1].&lt;br /&gt;
&lt;br /&gt;
El fallo de página se produce cuando se accede a una posición de memoria que pertenece a una página de memoria que esta descargada en disco.&lt;br /&gt;
     &lt;br /&gt;
&amp;lt;math&amp;gt;tasa fallos pagina = \frac{total fallos de pagina}{total accesos a pagina}&amp;lt;/math&amp;gt;&lt;br /&gt;
&lt;br /&gt;
También hay que tener en cuenta el contexto, si estamos en arranque en frío o en caliente, así como el cumplimiento del principio de localidad espacial y temporal. &lt;br /&gt;
&lt;br /&gt;
* Arranque en frío : se dan muchos fallos de página al principio, ya que los procesos se acaban de lanzar y ninguno esta cargado en memoria principal.&lt;br /&gt;
* Arranque en caliente : se suponen ya cargadas las páginas de los procesos en memoria principal.&lt;br /&gt;
&lt;br /&gt;
== Criterio de página óptima ==&lt;br /&gt;
&lt;br /&gt;
Este es un criterio teórico que viene a establecer la cota inferior de la ''tasa de fallos de página''. Consiste en escoger la página que mayor tiempo va a tardar en utilizarse. Este es el mejor caso, pero se necesita conocimiento de futuro, de ahí que sea un criterio teórico.&lt;br /&gt;
&lt;br /&gt;
Ejemplo: Secuencia de acceso a página : 2,2,3,1,1,3,4,5,1,1,2,3,4&lt;br /&gt;
          Suponiendo arranque en frío   &lt;br /&gt;
                                         ___1_____2_____3_____4___&lt;br /&gt;
                   memoria principal     |     |     |     |     |&lt;br /&gt;
                    de 4 marcos          |_____|_____|_____|_____|&lt;br /&gt;
&lt;br /&gt;
*[[sol_1|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio de página pésima ==&lt;br /&gt;
&lt;br /&gt;
Este también es teórico y viene a establecer la cota superior de la ''tasa de fallos de página'', para ver lo peor que podría comportarse un criterio. Consiste en seleccionar la página que menor tiempo tardará en usarse.&lt;br /&gt;
&lt;br /&gt;
*[[sol_2|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio de selección estocástica (aleatoria) ==&lt;br /&gt;
&lt;br /&gt;
Se trata también de un criterio teórico, serviría para aproximar la cota media de la ''tasa de fallos de página''. Consiste en seleccionar una página al azar.&lt;br /&gt;
&lt;br /&gt;
== Criterio MRU('''M'''ost '''R'''ecently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Se selecciona la última página a la que se ha accedido. Podría implementarse con una LIFO por orden de acceso.&lt;br /&gt;
&lt;br /&gt;
*[[sol_3|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio por orden de carga FIFO ==&lt;br /&gt;
&lt;br /&gt;
Se selecciona la página que más tiempo lleva cargada en memoria principal. Se implementa con una FIFO por orden de carga, es decir, a medida que se cargan en memoria principal las páginas son añadidas a la cola. Un problema es que suele suceder que las páginas más usadas tienden a estar mucho tiempo en memoria principal y este criterio va contra eso.&lt;br /&gt;
&lt;br /&gt;
*[[sol_5|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio NRU ('''N'''ot '''R'''ecently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Ofrece dos bits para cada página:&lt;br /&gt;
* Bit R : Se pone a 1 si la página ha sido usada (tanto para lectura como para escritura).&lt;br /&gt;
* Bit M : Se pone a 1 si la página es modificada (escritura).&lt;br /&gt;
&lt;br /&gt;
En resumen, siempre se pone a 1 el bit R, y solo se toca M cuando se accede a escritura.&lt;br /&gt;
&lt;br /&gt;
Para seleccionar la página víctima iteramos sobre los marcos cargados en memoria (comenzando por el primero de ellos) buscando el que cumpla lo siguiente, en este orden:&lt;br /&gt;
&lt;br /&gt;
# R=0, M=0&lt;br /&gt;
# R=0, M=1&lt;br /&gt;
# R=1, M=0&lt;br /&gt;
# R=1, M=1&lt;br /&gt;
&lt;br /&gt;
Periódicamente se pone a cero el bit R.&lt;br /&gt;
&lt;br /&gt;
*[[sol_6|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio de 2ª oportunidad ==&lt;br /&gt;
&lt;br /&gt;
Se trata de la combinación de los criterios FIFO y NRU, pero sin emplear el bit M de NRU. Cuando hay que seleccionar una página víctima, se recorre la lista de páginas por orden de carga en memoria hasta encontrar alguna que tenga el bit R a 0. Durante la iteración, si se encuentra una cuyo bit R valga 1, se pone a 0, se retira de la lista y se añade al final (para darle una segunda oportunidad). Cuando se añade una nueva página, se añade al final de la cola con el bit R a 1.&lt;br /&gt;
&lt;br /&gt;
*[[sol_7|Solución]]&lt;br /&gt;
&lt;br /&gt;
;Criterio del reloj: Es una variante en la manera de implementar la 2ª oportunidad. Se emplea una lista circular. En lugar de eliminar y añadir elementos al final de la FIFO, mantenemos un puntero a la página siguiente a la última página víctima seleccionada.&lt;br /&gt;
&lt;br /&gt;
*[[sol_reloj|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio LRU ('''L'''east '''R'''ecently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Es justamente el criterio contrario al MRU. En LRU elegimos la página que más tiempo lleve sin ser accedida. Se implementa mediante una FIFO que mantiene el '''orden de acceso''' a las páginas. Es decir, cada vez que se accede a una página, en caso de estar ya en la FIFO, se retira de la cola y se añade al final.&lt;br /&gt;
&lt;br /&gt;
*[[sol_8|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Criterio LFU ('''L'''east '''F'''recuently '''U'''sed) ==&lt;br /&gt;
&lt;br /&gt;
Se selecciona a la página que haya sido accedida con menor frecuencia. Se implementa mediante un contador. Básicamente, por cada acceso se incrementa el contador de uso de la página. La página víctima será aquella con menor contador. Cuando una página es expulsada a disco su contador pasa a ser cero.&lt;br /&gt;
&lt;br /&gt;
*[[sol_9|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Aproximación discreta LRU ==&lt;br /&gt;
&lt;br /&gt;
Consiste en LFU + LRU. Se usa el bit R. Se itera periódicamente sobre la lista de páginas si R = 0 entonces aumento el contador; si R está activado se desactiva y el contador se pone a cero. Ante una sustitución: prescindir de la que tiene mayor valor en el contador. Ojito! Cuando llega un elemento, el contador se inicializa a 0, puesto que solo se modifica en los checkpoints, no con cada acceso&lt;br /&gt;
&lt;br /&gt;
*[[sol_9.2|Solución]]&lt;br /&gt;
&lt;br /&gt;
== Sustitución por envejecimiento ==&lt;br /&gt;
&lt;br /&gt;
Se emplea un registro R de N bits. Por cada acceso se pone a 1 el bit más significativo. Periódicamente se desplaza hacia la derecha el registro R. La página víctima será la que tenga el menor valor en el registro R (en caso de empate se emplea otro criterio). La información que contienen los bits menos significativos se pierden al realizar desplazamientos. Este criterio permite mantener un historial de acceso a las páginas, para seleccionar como víctima aquella que lleve más tiempo sin ser accedida.&lt;br /&gt;
&lt;br /&gt;
*[[sol_10|Solución]]&lt;br /&gt;
&lt;br /&gt;
= Implementaciones =&lt;br /&gt;
&lt;br /&gt;
En el [[Algoritmos de criterios de reemplazo|Portal de la comunidad]] se encuentran implementados algunos de los anteriores criterios como ayuda para ver su funcionamiento.&lt;br /&gt;
Creo que los algoritmos están bien (coinciden con las soluciones), pero si alguien decide probarlos no estaría mal que los revisase por encima. --[[Usuario:Alexrdp|Alexrdp]] 16:24 6 jun 2011 (UTC)&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Segmentaci%C3%B3n&amp;diff=2189</id>
		<title>Segmentación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Segmentaci%C3%B3n&amp;diff=2189"/>
				<updated>2011-12-18T12:08:38Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Mecanismos */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=Definición=&lt;br /&gt;
Un segmento es un espacio de memoria de tamaño variable, compuesto por:&lt;br /&gt;
*Descriptor: Identificador único del segmento (dentro del espacio de memoria del proceso).&lt;br /&gt;
*Tamaño del segmento&lt;br /&gt;
&lt;br /&gt;
=Funcionamiento=&lt;br /&gt;
&lt;br /&gt;
[[Archivo:Segmentos.png|725px]]&lt;br /&gt;
&lt;br /&gt;
=Características=&lt;br /&gt;
*Cada proceso en ejecución (esté activo, bloqueado o preparado) tiene su tabla de segmentos.&lt;br /&gt;
&lt;br /&gt;
*Solapamiento: 2 segmentos pueden compartir zona de memoria. Ojo! problemas de concurrencia. Habría que usar algún método para su sincronización si se intenta.&lt;br /&gt;
&lt;br /&gt;
*Protección de memoria: añadir 3 bits a la tabla de descriptores de segmentos para los permisos ( r w x ).&lt;br /&gt;
&lt;br /&gt;
*Aspectos materiales : Hay 2 registros que funcionan como dispositivos de traducción segmentada; uno de dirección de comienzo de la tabla de segmentos, y otro para el número de entradas en ella.&lt;br /&gt;
&lt;br /&gt;
*Esto supone dos accesos a memoria física real. La tabla de segmentos ocupa memoria, siendo deseable que permanezcan en cache.&lt;br /&gt;
&lt;br /&gt;
*Cuando un proceso requiere más memoria se crea un nuevo segmento.&lt;br /&gt;
&lt;br /&gt;
*Dos instancias de un mismo proceso pueden compartir segmentos de memoria de instrucciones/código, pero no para datos ya que esto complicaría la gestión.&lt;br /&gt;
&lt;br /&gt;
*No se redimensionan.&lt;br /&gt;
&lt;br /&gt;
*Gestión compleja, sobretodo por su tamaño variable&lt;br /&gt;
&lt;br /&gt;
=Mecanismos=&lt;br /&gt;
Los diferentes mecanismos que nos ofrece la segmentación de memoria son los siguientes.&lt;br /&gt;
==Carga de segmentos a petición==&lt;br /&gt;
Es un mecanismo que permite a un proceso no disponer de todos sus segmentos en memoria principal, se pueden descargar a disco (en la zona de intercambio o swap) segmentos en base a un cierto criterio (ver [[Intro | Memoria virtual]]). &lt;br /&gt;
&lt;br /&gt;
Esta zona de intercambio puede ser:&lt;br /&gt;
&lt;br /&gt;
* Un lugar fijo en el disco (Linux, Unix). El administrador de memoria decide qué segmento se va a descargar&lt;br /&gt;
&lt;br /&gt;
* Un fichero oculto de tamaño variable (Windows).&lt;br /&gt;
&lt;br /&gt;
==Enlace dinámico==&lt;br /&gt;
Uso de llamadas a funciones que están en disco.&lt;br /&gt;
&lt;br /&gt;
Podemos tener referencias a funciones o bibliotecas que no estén en memoria principal (permite ir cargando bajo demanda los segmentos que contengan el código necesario).&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Segmentaci%C3%B3n&amp;diff=2188</id>
		<title>Segmentación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Segmentaci%C3%B3n&amp;diff=2188"/>
				<updated>2011-12-18T12:04:18Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=Definición=&lt;br /&gt;
Un segmento es un espacio de memoria de tamaño variable, compuesto por:&lt;br /&gt;
*Descriptor: Identificador único del segmento (dentro del espacio de memoria del proceso).&lt;br /&gt;
*Tamaño del segmento&lt;br /&gt;
&lt;br /&gt;
=Funcionamiento=&lt;br /&gt;
&lt;br /&gt;
[[Archivo:Segmentos.png|725px]]&lt;br /&gt;
&lt;br /&gt;
=Características=&lt;br /&gt;
*Cada proceso en ejecución (esté activo, bloqueado o preparado) tiene su tabla de segmentos.&lt;br /&gt;
&lt;br /&gt;
*Solapamiento: 2 segmentos pueden compartir zona de memoria. Ojo! problemas de concurrencia. Habría que usar algún método para su sincronización si se intenta.&lt;br /&gt;
&lt;br /&gt;
*Protección de memoria: añadir 3 bits a la tabla de descriptores de segmentos para los permisos ( r w x ).&lt;br /&gt;
&lt;br /&gt;
*Aspectos materiales : Hay 2 registros que funcionan como dispositivos de traducción segmentada; uno de dirección de comienzo de la tabla de segmentos, y otro para el número de entradas en ella.&lt;br /&gt;
&lt;br /&gt;
*Esto supone dos accesos a memoria física real. La tabla de segmentos ocupa memoria, siendo deseable que permanezcan en cache.&lt;br /&gt;
&lt;br /&gt;
*Cuando un proceso requiere más memoria se crea un nuevo segmento.&lt;br /&gt;
&lt;br /&gt;
*Dos instancias de un mismo proceso pueden compartir segmentos de memoria de instrucciones/código, pero no para datos ya que esto complicaría la gestión.&lt;br /&gt;
&lt;br /&gt;
*No se redimensionan.&lt;br /&gt;
&lt;br /&gt;
*Gestión compleja, sobretodo por su tamaño variable&lt;br /&gt;
&lt;br /&gt;
=Mecanismos=&lt;br /&gt;
==Carga de segmentos a petición==&lt;br /&gt;
Es un mecanismo que permite a un proceso no disponer de todos sus segmentos en memoria principal, se pueden descargar a disco (en la zona de intercambio o swap) segmentos en base a un cierto criterio (ver [[Intro | Memoria virtual]]). &lt;br /&gt;
&lt;br /&gt;
Esta zona de intercambio puede ser:&lt;br /&gt;
&lt;br /&gt;
* Un lugar fijo en el disco (Linux, Unix). El administrador de memoria decide qué segmento se va a descargar&lt;br /&gt;
&lt;br /&gt;
* Un fichero oculto de tamaño variable (Windows).&lt;br /&gt;
&lt;br /&gt;
==Enlace dinámico==&lt;br /&gt;
Uso de llamadas a funciones que están en disco.&lt;br /&gt;
&lt;br /&gt;
Podemos tener referencias a funciones o bibliotecas que no estén en memoria principal (permite ir cargando bajo demanda los segmentos que contengan el código necesario).&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_multiprogramables_con_particiones_fijas&amp;diff=2187</id>
		<title>SO multiprogramables con particiones fijas</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_multiprogramables_con_particiones_fijas&amp;diff=2187"/>
				<updated>2011-12-18T11:12:14Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejemplo */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En la administración de memoria con particiones de tamaño fijo consideramos que la memoria se encuentra dividida en porciones fijas de diferente tamaño. La división se realizaría durante la instalación del sistema operativo, y para modificar el esquema de particionamiento necesitaríamos reiniciar el sistema para que surtan efecto los cambios. Por cada partición sólo puede haber un único proceso. Por lo tanto, se pueden ejecutar tantos procesos como particiones haya.&lt;br /&gt;
&lt;br /&gt;
Esta aproximación tiene dos limitaciones importantes, que son:&lt;br /&gt;
&lt;br /&gt;
* Si un proceso necesita más memoria que la partición más grande puede ofrecer, entonces éste no se puede ejecutar.&lt;br /&gt;
* Alto desperdicio de memoria, particularmente en el caso de que un proceso ocupe una partición de tamaño mayor al que necesita.&lt;br /&gt;
&lt;br /&gt;
= Criterios de asignación =&lt;br /&gt;
&lt;br /&gt;
Cuando se lanza un programa, el administrador de memoria tiene que decidir en qué partición de memoria va a cargar el proceso recién creado. Para ello se emplean diferentes criterios.&lt;br /&gt;
&lt;br /&gt;
== Mejor ajuste estático ==&lt;br /&gt;
&lt;br /&gt;
Se adjudica a cada proceso a la menor partición en la que quepa. Si la menor partición en la que cabe estuviera ocupada, dicho proceso tiene que esperar a que se libere. Esta estrategia evita el desperdicio de memoria. Sin embargo, puede retrasar la ejecución de un proceso estando libre otras particiones sin usarse. Este mecanismo se puede implementar con una cola por partición. El orden de complejidad computacional sería &amp;lt;math&amp;gt;O(1)&amp;lt;/math&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
=== Ejemplo ===&lt;br /&gt;
&lt;br /&gt;
 Dada la siguiente configuración de procesos:&lt;br /&gt;
 &lt;br /&gt;
    | H0 |  t  | m(P)|&lt;br /&gt;
 ---------------------&lt;br /&gt;
 P1 |  0 |  7  |  2  |  &lt;br /&gt;
 P2 |  1 |  4  |  7  |&lt;br /&gt;
 P3 |  2 |  5  |  8  |&lt;br /&gt;
 P4 |  3 |  5  | 15  |&lt;br /&gt;
 P5 |  4 |  3  |  3  |&lt;br /&gt;
 P6 |  5 |  2  | 17  |&lt;br /&gt;
 &lt;br /&gt;
 Y la siguiente configuración de memoria:&lt;br /&gt;
 _______&lt;br /&gt;
 |_____| M1 = 8 u.m.&lt;br /&gt;
 |_____| M2 = 8 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |_____| M3 = 16 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |     |&lt;br /&gt;
 |     | M4 = 32 u.m.&lt;br /&gt;
 |_____|&lt;br /&gt;
&lt;br /&gt;
La solución sería:&lt;br /&gt;
&lt;br /&gt;
                             M1&lt;br /&gt;
              P1  &amp;lt;---|---|---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |       P1--&amp;gt;M1&lt;br /&gt;
                              M2&lt;br /&gt;
              P2  |   &amp;lt;---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |       P2--&amp;gt;M2&lt;br /&gt;
                                                M2&lt;br /&gt;
              P3  |   |   &amp;lt;   |   |   |---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |       P3--&amp;gt;M2&lt;br /&gt;
                                        M3&lt;br /&gt;
              P4  |   |   |   &amp;lt;---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |       P4--&amp;gt;M3&lt;br /&gt;
                                                   M1&lt;br /&gt;
              P5  |   |   |   |   &amp;lt;   |   |   |---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |       P5--&amp;gt;M1&lt;br /&gt;
                                          M4 &lt;br /&gt;
              P6  |   |   |   |   |   &amp;lt;---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |       P6--&amp;gt;M4&lt;br /&gt;
             -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---&amp;gt; t&lt;br /&gt;
                  0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20&lt;br /&gt;
&lt;br /&gt;
=== Otro ejemplo ===&lt;br /&gt;
&lt;br /&gt;
 Tenemos los siguientes procesos: m(P1) = 6KB, m(P2) = 1KB, m(P3) = 3KB, m(P4) = 31KB, m(P5) = 30KB;&lt;br /&gt;
 suponemos que la decisión sobre la asignación de procesos a particiones se hace ordenadamente de manera&lt;br /&gt;
 consecutiva según el número del proceso y una memoria de 64 KB divididos en 4 huecos como sigue:&lt;br /&gt;
&lt;br /&gt;
[[solución mejor ajuste estático|Ver solución]]&lt;br /&gt;
&lt;br /&gt;
== Primer ajuste ==&lt;br /&gt;
&lt;br /&gt;
Igual que el anterior, sólo que nuestro proceso pasa a la primera partición libre en la que menor desperdicio de memoria se produzca. Por tanto, los procesos nunca esperan siempre que hay alguna partición libre. Complejidad: O(1)&lt;br /&gt;
&lt;br /&gt;
[[solución primer ajuste|Ver solución]]&lt;br /&gt;
=== Ejemplo ===&lt;br /&gt;
&lt;br /&gt;
 Dada la siguiente configuración de procesos:&lt;br /&gt;
 &lt;br /&gt;
    | H0 |  t  | m(P)|&lt;br /&gt;
 ---------------------&lt;br /&gt;
 P1 |  0 |  7  |  2  |  &lt;br /&gt;
 P2 |  1 |  4  |  7  |&lt;br /&gt;
 P3 |  2 |  5  |  8  |&lt;br /&gt;
 P4 |  3 |  5  | 15  |&lt;br /&gt;
 P5 |  4 |  3  |  3  |&lt;br /&gt;
 P6 |  5 |  2  | 17  |&lt;br /&gt;
 &lt;br /&gt;
 Y la siguiente configuración de memoria:&lt;br /&gt;
 _______&lt;br /&gt;
 |_____| M1 = 8 u.m.&lt;br /&gt;
 |_____| M2 = 8 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |_____| M3 = 16 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |     |&lt;br /&gt;
 |     | M4 = 32 u.m.&lt;br /&gt;
 |_____|&lt;br /&gt;
&lt;br /&gt;
La solución sería:&lt;br /&gt;
&lt;br /&gt;
                             M1&lt;br /&gt;
              P1  &amp;lt;---|---|---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |       P1--&amp;gt;M1&lt;br /&gt;
                              M2&lt;br /&gt;
              P2  |   &amp;lt;---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |       P2--&amp;gt;M2&lt;br /&gt;
                                    M3&lt;br /&gt;
              P3  |   |   &amp;lt;---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |       P3--&amp;gt;M3&lt;br /&gt;
                                     M4&lt;br /&gt;
              P4  |   |   |   &amp;lt;---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |       P4--&amp;gt;M4&lt;br /&gt;
                                            M2&lt;br /&gt;
              P5  |   |   |   |   &amp;lt;   |---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |       P5--&amp;gt;M2&lt;br /&gt;
                                                     M4 &lt;br /&gt;
              P6  |   |   |   |   |   &amp;lt;   |   |   |---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |       P6--&amp;gt;M4&lt;br /&gt;
             -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---&amp;gt; t&lt;br /&gt;
                  0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20&lt;br /&gt;
&lt;br /&gt;
== Mejor ajuste dinámico ==&lt;br /&gt;
&lt;br /&gt;
De entre todos los procesos que pueden asignarse a una partición, se asigna el mayor proceso que quepa en ella. Por tanto, se itera sobre todos los procesos que se quieren cargar en memoria para ver cuál de ellos es el que menor desperdicio produce. Tal y como sucedía con el mejor ajuste estático, los procesos tienen que esperar a que quede libre la partición en la que menor desperdicio se produce. --[[Usuario:Pneira|Pneira]] 13:40 13 dic 2011 (UTC)&lt;br /&gt;
&lt;br /&gt;
El principal inconveniente de este criterio es que los procesos que mayor desperdicio generan van a ser postergados indefinidamente. Complejidad: O(n).&lt;br /&gt;
&lt;br /&gt;
=== Ejemplo ===&lt;br /&gt;
&lt;br /&gt;
 Dada la siguiente configuración de procesos:&lt;br /&gt;
 &lt;br /&gt;
    | H0 |  t  | m(P)|&lt;br /&gt;
 ---------------------&lt;br /&gt;
 P1 |  0 |  7  |  2  |  &lt;br /&gt;
 P2 |  0 |  4  |  7  |&lt;br /&gt;
 P3 |  0 |  5  |  8  |&lt;br /&gt;
 P4 |  1 |  5  | 15  |&lt;br /&gt;
 P5 |  1 |  3  |  3  |&lt;br /&gt;
 P6 |  1 |  2  | 17  |&lt;br /&gt;
 &lt;br /&gt;
 Y la siguiente configuración de memoria:&lt;br /&gt;
 _______&lt;br /&gt;
 |_____| M1 = 8 u.m.&lt;br /&gt;
 |_____| M2 = 8 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |_____| M3 = 16 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |     |&lt;br /&gt;
 |     | M4 = 32 u.m.&lt;br /&gt;
 |_____|&lt;br /&gt;
&lt;br /&gt;
La solución sería:&lt;br /&gt;
&lt;br /&gt;
                                                        M1&lt;br /&gt;
              P1  &amp;lt;   |   |   |   |   |---|---|---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |       P1--&amp;gt;M1&lt;br /&gt;
                          M2&lt;br /&gt;
              P2  &amp;lt;---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |       P2--&amp;gt;M2&lt;br /&gt;
                            M1&lt;br /&gt;
              P3  &amp;lt;---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |       P3--&amp;gt;M1&lt;br /&gt;
                             M3&lt;br /&gt;
              P4  |   &amp;lt;---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |       P4--&amp;gt;M3&lt;br /&gt;
                                        M2  &lt;br /&gt;
              P5  |   &amp;lt;   |   |   |---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |       P5--&amp;gt;M2&lt;br /&gt;
                          M4 &lt;br /&gt;
              P6  |   &amp;lt;---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |       P6--&amp;gt;M4&lt;br /&gt;
             -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---&amp;gt; t&lt;br /&gt;
                  0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20&lt;br /&gt;
&lt;br /&gt;
== Mejor ajuste dinámico con aplazamiento limitado ==&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
=== Ejemplo ===&lt;br /&gt;
&lt;br /&gt;
 Dada la siguiente configuración de procesos:&lt;br /&gt;
 &lt;br /&gt;
    | H0 |  t  | m(P)|&lt;br /&gt;
 ---------------------&lt;br /&gt;
 P1 |  0 |  7  |  2  |  &lt;br /&gt;
 P2 |  0 |  4  |  7  |&lt;br /&gt;
 P3 |  0 |  5  |  8  |&lt;br /&gt;
 P4 |  1 |  5  |  6  |&lt;br /&gt;
 P5 |  1 |  3  |  7  |&lt;br /&gt;
 P6 |  1 |  2  |  5  |&lt;br /&gt;
 &lt;br /&gt;
 Suponiendo que todo proceso puede ser aplazado como máximo una sola vez.&lt;br /&gt;
 &lt;br /&gt;
 Y la siguiente configuración de memoria:&lt;br /&gt;
 _______&lt;br /&gt;
 |_____| M1 = 8 u.m.&lt;br /&gt;
 |_____| M2 = 8 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |_____| M3 = 16 u.m.&lt;br /&gt;
 |     |&lt;br /&gt;
 |     |&lt;br /&gt;
 |     | M4 = 32 u.m.&lt;br /&gt;
 |_____|&lt;br /&gt;
&lt;br /&gt;
La solución sería:&lt;br /&gt;
&lt;br /&gt;
                                                        M2&lt;br /&gt;
              P1  &amp;lt;   |   |   |   |---|---|---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |&lt;br /&gt;
                          M2&lt;br /&gt;
              P2  &amp;lt;---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | &lt;br /&gt;
                            M1&lt;br /&gt;
              P3  &amp;lt;---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |   |   |   | &lt;br /&gt;
                                                         M1&lt;br /&gt;
              P4  |   &amp;lt;   |   |   |   |   |   |   |---|---|---|---|---&amp;gt;   |   |   |   |   |   |   |&lt;br /&gt;
                                            M1                      &lt;br /&gt;
              P5  |   &amp;lt;   |   |   |   |---|---|---&amp;gt;   |   |   |   |   |   |   |   |   |   |   |   |&lt;br /&gt;
                                                                 M2&lt;br /&gt;
              P6  |   &amp;lt;   |   |   |   |   |   |   |   |   |   |---|---&amp;gt;   |   |   |   |   |   |   |&lt;br /&gt;
             -----|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---&amp;gt; t&lt;br /&gt;
                  0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20&lt;br /&gt;
&lt;br /&gt;
== Subparticiones ==&lt;br /&gt;
&lt;br /&gt;
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 hasta que haya sitio para ellos y se asigna la partición madre al proceso grande.&lt;br /&gt;
&lt;br /&gt;
Partición madre: tipo especial de partición que se puede dividir en múltiples particiones menores.&lt;br /&gt;
&lt;br /&gt;
[[Otro ejemplo|Otro ejemplo]]&lt;br /&gt;
&lt;br /&gt;
= Métodos de colocación en memoria =&lt;br /&gt;
&lt;br /&gt;
En el momento de lanzamiento hay que realizar la carga del código del proceso en memoria. Hay diferentes estrategias de colocación, que son:&lt;br /&gt;
&lt;br /&gt;
*'''Montaje absoluto''': El compilador genera un ejecutable que sólo pueda ser cargado en una cierta posición de memoria. Básicamente, las instrucciones de memoria emplean direccionamiento fijo. Se asigna una dirección de memoria fija en tiempo de compilación de manera que cuando se lance el programa tiene que cargarse obligatoriamente en la posición de memoria para la que fue compilada. Por tanto, se trata de un método poco flexible pues requiere la recompilación del programa para ejecutar el proceso en una posición de memoria diferente. Se emplea para la carga del ejecutable en el que se encuentra el sistema operativo nada más comenzar el arranque.&lt;br /&gt;
&lt;br /&gt;
* '''Carga con reubicación''': Es un mecanismo más flexible al anterior. Básicamente, en tiempo de compilación se genera un ejecutable que supone que la posición de memoria de comienzo del proceso va a ser la dirección 0. Luego, en el momento de lanzamiento, se reajustan las instrucciones de acceso a memoria que hay en el código del proceso al cargarlo en una cierta partición. Este reajuste consiste en sumar a la dirección de memoria que hay en el código de cada instrucción de memoria la dirección de comienzo de la partición en la que se va a cargar el procesos. Aunque es un método más flexible que el anterior, no permite migrar de una partición a otra una vez cargado el proceso en memoria.&lt;br /&gt;
&lt;br /&gt;
* '''Reubicación dinámica''': Es el mecanismo más flexible de los tres. De nuevo, en tiempo de compilación se genera un ejecutable que supone que la posición de memoria de comienzo del proceso va a ser la dirección 0. Se supone la existencia de un registro en la arquitectura en el que se carga la posición de memoria de comienzo de la partición. En '''tiempo de ejecución''' se va a sumar a la posición de memoria a la que se quiere acceder la dirección de memoria del registro que contiene el lugar en el que comienza la partición. A diferencia de la carga con reubicación, permite la migración de un proceso de una partición a otra, para ello lo que hay que hacer es modificar el registro y mover el código del proceso a la nueva partición en la que se quiere colocar.&lt;br /&gt;
&lt;br /&gt;
** '''Reubicación dinámica parcial''': Es una variante del anterior, en la que existe también un registro límite.&lt;br /&gt;
&lt;br /&gt;
= Mecanismos de protección de memoria =&lt;br /&gt;
&lt;br /&gt;
Es necesario proteger el SO frente a procesos; y proteger a los procesos entre sí.&lt;br /&gt;
&lt;br /&gt;
* '''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&lt;br /&gt;
&lt;br /&gt;
* '''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. Los registros de posición inicial y final sólo pueden ser modificados en modo supervisor, por tanto, es el sistema operativo en que durante la conmutación de procesos establece el valor de estos registros.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2180</id>
		<title>SO monoprogramables</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2180"/>
				<updated>2011-12-17T13:36:41Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Solapamiento: */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En los sistemas operativos monoprogramables la administración de memoria es muy sencilla ya que solo hay un proceso en ejecución que puede usar todo el espacio disponible, la gestión de memoria se limita casi a comprobar si el proceso cabe en el espacio libre en la memoria. El SO se coloca como bloque al principio o al final de la memoria (memoria del sistema), y el resto para el proceso a ejecutar (memoria del proceso):&lt;br /&gt;
                       _______________________                       _______________________ &lt;br /&gt;
                     /|                       | 0                  0|                       |\&lt;br /&gt;
                    | |  zona de memoria del  |                     | zona del S.O en RAM   | |&lt;br /&gt;
                    | |   sistema operativo   |                     |_______________________| | &lt;br /&gt;
                    | |_______________________|                     |                       |\|                      &lt;br /&gt;
                    |/|                       |                     |  zona de memoria del  | | &lt;br /&gt;
       Sistema \    | |                       |                     |  usuario (ejecución   | |    &amp;lt; IBM PC&lt;br /&gt;
       clásico /    | |  zona de memoria del  |                     |  de procesos)         | |    &lt;br /&gt;
                    | |       usuario         |                     |_______________________| | &lt;br /&gt;
                    | |    (ejecución de      |                     |                       |\|&lt;br /&gt;
                    | |       procesos)       |                     |  zona de Lectura      | |  &lt;br /&gt;
                    | |                       |                     |                       | | &lt;br /&gt;
                     \|_______________________| N                  N|_______________________|/        &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solapamiento: ==&lt;br /&gt;
Si el proceso no cabe en el espacio libre en memoria puede recurrirse a 2 estrategias para ejecutarlo:&lt;br /&gt;
*'''Ejecución en cadena:''' El programa se divide en varios &amp;quot;subprogramas&amp;quot; y se ejecutan en cadena. Esto se consigue haciendo que cada programa termine su ejecución solicitando que se ejecute el siguiente.&lt;br /&gt;
*'''Fragmentar el programa en módulos de solapamiento o recubrimiento:''' Dichos módulos se van cargando en memoria según se necesite, algunos S.O. permiten que los submodulos también se dividan, dando lugar a una estructura en árbol.&lt;br /&gt;
&lt;br /&gt;
         '''______'''&lt;br /&gt;
       ''' |      |'''  &lt;br /&gt;
        '''|      |'''  Datos permanentes: Datos globales,&lt;br /&gt;
        '''|      |'''  programa principal y subprogramas comunes&lt;br /&gt;
        '''|      |&lt;br /&gt;
        '''|      |'''&lt;br /&gt;
       ''' |______|'''_______________________________________________________&lt;br /&gt;
        |      |         __|__          __|__          __|__         __|__            /&lt;br /&gt;
        |      |       ''' |     |        |     |        |     |       |     |'''          |&lt;br /&gt;
        |      |        '''|  A  |        |     |        |  C  |       |  D  |'''          |&lt;br /&gt;
        |      |        '''|_____|        |     |        |     |       |_____|'''         &amp;lt;         Módulos de solapamiento o recubrimiento (A, B, C, D)&lt;br /&gt;
        |      |                       '''|  D  |        |_____|'''                        |&lt;br /&gt;
        |      |                       '''|     |'''                                       |&lt;br /&gt;
        |______|                       '''|_____|'''                                        \&lt;br /&gt;
&lt;br /&gt;
== Protección de memoria: ==&lt;br /&gt;
&lt;br /&gt;
Los sistemas operativos monoprogramables tienen debilidades en cuanto a protección de memoria. Para evitar que un proceso entre en el área del SO, se puede recurrir al uso de:&lt;br /&gt;
*'''Bits de protección''': se le asocia a cada palabra un bit (1 para S.O. y 0 para proceso) para comprobar si la posición de memoria es de SO o del proceso. Este sistema no exige que la región protegida sea contigua, con lo que el sistema operativo puede marcar como suyas algunas posiciones de memoria de subprocesos especiales lo que permite que los mismos accedan de forma controlada a datos y subprogramas del núcleo.&lt;br /&gt;
&lt;br /&gt;
*'''Registros valla o registros límite''': En el limite entre la zona del sistema operativo y la zona para la ejecución de procesos se carga un registro con la primera posición de memoria que ocupa el proceso. Este sistema es mas sencillo y barato que el anterior, pero solo protege una zona (entre la posición de memoria 0 y la posición de memoria del registro) y son necesarios circuitos comparadores rápidos para evitar retrasar la ejecución de las instrucciones. Su funcionamiento es el siguiente: al intentar acceder a una posición de memoria se comprueba si esta dirección es menor que la dirección del registro valla, si es así se lanza un mensaje de error y si no es así se accede a la posición de memoria deseada.&lt;br /&gt;
&lt;br /&gt;
 Ejemplo práctico: &lt;br /&gt;
 Pablo tiene una computadora cuya memoria principal tiene una capacidad de 640KB. El SO (MS-DOS) ocupa el principio de la memoria, dejando libre una &lt;br /&gt;
 zona de 512KB para el proceso conveniente. &lt;br /&gt;
 Esto nos impide jugar al Sensible Soccer, por ejemplo, ya que ocupa 560KB. Una posible solución sería instalar un SO menos pesado, como una version &lt;br /&gt;
 más antigua de MS-DOS.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2179</id>
		<title>SO monoprogramables</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2179"/>
				<updated>2011-12-17T13:36:24Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Solapamiento: */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En los sistemas operativos monoprogramables la administración de memoria es muy sencilla ya que solo hay un proceso en ejecución que puede usar todo el espacio disponible, la gestión de memoria se limita casi a comprobar si el proceso cabe en el espacio libre en la memoria. El SO se coloca como bloque al principio o al final de la memoria (memoria del sistema), y el resto para el proceso a ejecutar (memoria del proceso):&lt;br /&gt;
                       _______________________                       _______________________ &lt;br /&gt;
                     /|                       | 0                  0|                       |\&lt;br /&gt;
                    | |  zona de memoria del  |                     | zona del S.O en RAM   | |&lt;br /&gt;
                    | |   sistema operativo   |                     |_______________________| | &lt;br /&gt;
                    | |_______________________|                     |                       |\|                      &lt;br /&gt;
                    |/|                       |                     |  zona de memoria del  | | &lt;br /&gt;
       Sistema \    | |                       |                     |  usuario (ejecución   | |    &amp;lt; IBM PC&lt;br /&gt;
       clásico /    | |  zona de memoria del  |                     |  de procesos)         | |    &lt;br /&gt;
                    | |       usuario         |                     |_______________________| | &lt;br /&gt;
                    | |    (ejecución de      |                     |                       |\|&lt;br /&gt;
                    | |       procesos)       |                     |  zona de Lectura      | |  &lt;br /&gt;
                    | |                       |                     |                       | | &lt;br /&gt;
                     \|_______________________| N                  N|_______________________|/        &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solapamiento: ==&lt;br /&gt;
Si el proceso no cabe en el espacio libre en memoria puede recurrirse a 2 estrategias para ejecutarlo:&lt;br /&gt;
*'''Ejecución en cadena:''' El programa se divide en varios &amp;quot;subprogramas&amp;quot; y se ejecutan en cadena. Esto se consigue haciendo que cada programa termine su ejecución&lt;br /&gt;
  solicitando que se ejecute el siguiente.&lt;br /&gt;
*'''Fragmentar el programa en módulos de solapamiento o recubrimiento:''' Dichos módulos se van cargando en memoria según se necesite, algunos S.O. permiten que los submodulos también se dividan, dando lugar a una&lt;br /&gt;
  estructura en árbol.&lt;br /&gt;
&lt;br /&gt;
         '''______'''&lt;br /&gt;
       ''' |      |'''  &lt;br /&gt;
        '''|      |'''  Datos permanentes: Datos globales,&lt;br /&gt;
        '''|      |'''  programa principal y subprogramas comunes&lt;br /&gt;
        '''|      |&lt;br /&gt;
        '''|      |'''&lt;br /&gt;
       ''' |______|'''_______________________________________________________&lt;br /&gt;
        |      |         __|__          __|__          __|__         __|__            /&lt;br /&gt;
        |      |       ''' |     |        |     |        |     |       |     |'''          |&lt;br /&gt;
        |      |        '''|  A  |        |     |        |  C  |       |  D  |'''          |&lt;br /&gt;
        |      |        '''|_____|        |     |        |     |       |_____|'''         &amp;lt;         Módulos de solapamiento o recubrimiento (A, B, C, D)&lt;br /&gt;
        |      |                       '''|  D  |        |_____|'''                        |&lt;br /&gt;
        |      |                       '''|     |'''                                       |&lt;br /&gt;
        |______|                       '''|_____|'''                                        \&lt;br /&gt;
&lt;br /&gt;
== Protección de memoria: ==&lt;br /&gt;
&lt;br /&gt;
Los sistemas operativos monoprogramables tienen debilidades en cuanto a protección de memoria. Para evitar que un proceso entre en el área del SO, se puede recurrir al uso de:&lt;br /&gt;
*'''Bits de protección''': se le asocia a cada palabra un bit (1 para S.O. y 0 para proceso) para comprobar si la posición de memoria es de SO o del proceso. Este sistema no exige que la región protegida sea contigua, con lo que el sistema operativo puede marcar como suyas algunas posiciones de memoria de subprocesos especiales lo que permite que los mismos accedan de forma controlada a datos y subprogramas del núcleo.&lt;br /&gt;
&lt;br /&gt;
*'''Registros valla o registros límite''': En el limite entre la zona del sistema operativo y la zona para la ejecución de procesos se carga un registro con la primera posición de memoria que ocupa el proceso. Este sistema es mas sencillo y barato que el anterior, pero solo protege una zona (entre la posición de memoria 0 y la posición de memoria del registro) y son necesarios circuitos comparadores rápidos para evitar retrasar la ejecución de las instrucciones. Su funcionamiento es el siguiente: al intentar acceder a una posición de memoria se comprueba si esta dirección es menor que la dirección del registro valla, si es así se lanza un mensaje de error y si no es así se accede a la posición de memoria deseada.&lt;br /&gt;
&lt;br /&gt;
 Ejemplo práctico: &lt;br /&gt;
 Pablo tiene una computadora cuya memoria principal tiene una capacidad de 640KB. El SO (MS-DOS) ocupa el principio de la memoria, dejando libre una &lt;br /&gt;
 zona de 512KB para el proceso conveniente. &lt;br /&gt;
 Esto nos impide jugar al Sensible Soccer, por ejemplo, ya que ocupa 560KB. Una posible solución sería instalar un SO menos pesado, como una version &lt;br /&gt;
 más antigua de MS-DOS.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2178</id>
		<title>SO monoprogramables</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2178"/>
				<updated>2011-12-17T13:36:01Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Protección de memoria: */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En los sistemas operativos monoprogramables la administración de memoria es muy sencilla ya que solo hay un proceso en ejecución que puede usar todo el espacio disponible, la gestión de memoria se limita casi a comprobar si el proceso cabe en el espacio libre en la memoria. El SO se coloca como bloque al principio o al final de la memoria (memoria del sistema), y el resto para el proceso a ejecutar (memoria del proceso):&lt;br /&gt;
                       _______________________                       _______________________ &lt;br /&gt;
                     /|                       | 0                  0|                       |\&lt;br /&gt;
                    | |  zona de memoria del  |                     | zona del S.O en RAM   | |&lt;br /&gt;
                    | |   sistema operativo   |                     |_______________________| | &lt;br /&gt;
                    | |_______________________|                     |                       |\|                      &lt;br /&gt;
                    |/|                       |                     |  zona de memoria del  | | &lt;br /&gt;
       Sistema \    | |                       |                     |  usuario (ejecución   | |    &amp;lt; IBM PC&lt;br /&gt;
       clásico /    | |  zona de memoria del  |                     |  de procesos)         | |    &lt;br /&gt;
                    | |       usuario         |                     |_______________________| | &lt;br /&gt;
                    | |    (ejecución de      |                     |                       |\|&lt;br /&gt;
                    | |       procesos)       |                     |  zona de Lectura      | |  &lt;br /&gt;
                    | |                       |                     |                       | | &lt;br /&gt;
                     \|_______________________| N                  N|_______________________|/        &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solapamiento: ==&lt;br /&gt;
Si el proceso no cabe en el espacio libre en memoria puede recurrirse a 2 estrategias para ejecutarlo:&lt;br /&gt;
*Ejecución en cadena:&lt;br /&gt;
  El programa se divide en varios &amp;quot;subprogramas&amp;quot; y se ejecutan en cadena. Esto se consigue haciendo que cada programa termine su ejecución&lt;br /&gt;
  solicitando que se ejecute el siguiente.&lt;br /&gt;
*Fragmentar el programa en módulos de solapamiento o recubrimiento:&lt;br /&gt;
  Dichos módulos se van cargando en memoria según se necesite, algunos S.O. permiten que los submodulos también se dividan, dando lugar a una&lt;br /&gt;
  estructura en árbol.&lt;br /&gt;
&lt;br /&gt;
         '''______'''&lt;br /&gt;
       ''' |      |'''  &lt;br /&gt;
        '''|      |'''  Datos permanentes: Datos globales,&lt;br /&gt;
        '''|      |'''  programa principal y subprogramas comunes&lt;br /&gt;
        '''|      |&lt;br /&gt;
        '''|      |'''&lt;br /&gt;
       ''' |______|'''_______________________________________________________&lt;br /&gt;
        |      |         __|__          __|__          __|__         __|__            /&lt;br /&gt;
        |      |       ''' |     |        |     |        |     |       |     |'''          |&lt;br /&gt;
        |      |        '''|  A  |        |     |        |  C  |       |  D  |'''          |&lt;br /&gt;
        |      |        '''|_____|        |     |        |     |       |_____|'''         &amp;lt;         Módulos de solapamiento o recubrimiento (A, B, C, D)&lt;br /&gt;
        |      |                       '''|  D  |        |_____|'''                        |&lt;br /&gt;
        |      |                       '''|     |'''                                       |&lt;br /&gt;
        |______|                       '''|_____|'''                                        \&lt;br /&gt;
&lt;br /&gt;
== Protección de memoria: ==&lt;br /&gt;
&lt;br /&gt;
Los sistemas operativos monoprogramables tienen debilidades en cuanto a protección de memoria. Para evitar que un proceso entre en el área del SO, se puede recurrir al uso de:&lt;br /&gt;
*'''Bits de protección''': se le asocia a cada palabra un bit (1 para S.O. y 0 para proceso) para comprobar si la posición de memoria es de SO o del proceso. Este sistema no exige que la región protegida sea contigua, con lo que el sistema operativo puede marcar como suyas algunas posiciones de memoria de subprocesos especiales lo que permite que los mismos accedan de forma controlada a datos y subprogramas del núcleo.&lt;br /&gt;
&lt;br /&gt;
*'''Registros valla o registros límite''': En el limite entre la zona del sistema operativo y la zona para la ejecución de procesos se carga un registro con la primera posición de memoria que ocupa el proceso. Este sistema es mas sencillo y barato que el anterior, pero solo protege una zona (entre la posición de memoria 0 y la posición de memoria del registro) y son necesarios circuitos comparadores rápidos para evitar retrasar la ejecución de las instrucciones. Su funcionamiento es el siguiente: al intentar acceder a una posición de memoria se comprueba si esta dirección es menor que la dirección del registro valla, si es así se lanza un mensaje de error y si no es así se accede a la posición de memoria deseada.&lt;br /&gt;
&lt;br /&gt;
 Ejemplo práctico: &lt;br /&gt;
 Pablo tiene una computadora cuya memoria principal tiene una capacidad de 640KB. El SO (MS-DOS) ocupa el principio de la memoria, dejando libre una &lt;br /&gt;
 zona de 512KB para el proceso conveniente. &lt;br /&gt;
 Esto nos impide jugar al Sensible Soccer, por ejemplo, ya que ocupa 560KB. Una posible solución sería instalar un SO menos pesado, como una version &lt;br /&gt;
 más antigua de MS-DOS.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2177</id>
		<title>SO monoprogramables</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2177"/>
				<updated>2011-12-17T13:35:46Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Solapamiento: */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En los sistemas operativos monoprogramables la administración de memoria es muy sencilla ya que solo hay un proceso en ejecución que puede usar todo el espacio disponible, la gestión de memoria se limita casi a comprobar si el proceso cabe en el espacio libre en la memoria. El SO se coloca como bloque al principio o al final de la memoria (memoria del sistema), y el resto para el proceso a ejecutar (memoria del proceso):&lt;br /&gt;
                       _______________________                       _______________________ &lt;br /&gt;
                     /|                       | 0                  0|                       |\&lt;br /&gt;
                    | |  zona de memoria del  |                     | zona del S.O en RAM   | |&lt;br /&gt;
                    | |   sistema operativo   |                     |_______________________| | &lt;br /&gt;
                    | |_______________________|                     |                       |\|                      &lt;br /&gt;
                    |/|                       |                     |  zona de memoria del  | | &lt;br /&gt;
       Sistema \    | |                       |                     |  usuario (ejecución   | |    &amp;lt; IBM PC&lt;br /&gt;
       clásico /    | |  zona de memoria del  |                     |  de procesos)         | |    &lt;br /&gt;
                    | |       usuario         |                     |_______________________| | &lt;br /&gt;
                    | |    (ejecución de      |                     |                       |\|&lt;br /&gt;
                    | |       procesos)       |                     |  zona de Lectura      | |  &lt;br /&gt;
                    | |                       |                     |                       | | &lt;br /&gt;
                     \|_______________________| N                  N|_______________________|/        &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solapamiento: ==&lt;br /&gt;
Si el proceso no cabe en el espacio libre en memoria puede recurrirse a 2 estrategias para ejecutarlo:&lt;br /&gt;
*Ejecución en cadena:&lt;br /&gt;
  El programa se divide en varios &amp;quot;subprogramas&amp;quot; y se ejecutan en cadena. Esto se consigue haciendo que cada programa termine su ejecución&lt;br /&gt;
  solicitando que se ejecute el siguiente.&lt;br /&gt;
*Fragmentar el programa en módulos de solapamiento o recubrimiento:&lt;br /&gt;
  Dichos módulos se van cargando en memoria según se necesite, algunos S.O. permiten que los submodulos también se dividan, dando lugar a una&lt;br /&gt;
  estructura en árbol.&lt;br /&gt;
&lt;br /&gt;
         '''______'''&lt;br /&gt;
       ''' |      |'''  &lt;br /&gt;
        '''|      |'''  Datos permanentes: Datos globales,&lt;br /&gt;
        '''|      |'''  programa principal y subprogramas comunes&lt;br /&gt;
        '''|      |&lt;br /&gt;
        '''|      |'''&lt;br /&gt;
       ''' |______|'''_______________________________________________________&lt;br /&gt;
        |      |         __|__          __|__          __|__         __|__            /&lt;br /&gt;
        |      |       ''' |     |        |     |        |     |       |     |'''          |&lt;br /&gt;
        |      |        '''|  A  |        |     |        |  C  |       |  D  |'''          |&lt;br /&gt;
        |      |        '''|_____|        |     |        |     |       |_____|'''         &amp;lt;         Módulos de solapamiento o recubrimiento (A, B, C, D)&lt;br /&gt;
        |      |                       '''|  D  |        |_____|'''                        |&lt;br /&gt;
        |      |                       '''|     |'''                                       |&lt;br /&gt;
        |______|                       '''|_____|'''                                        \&lt;br /&gt;
&lt;br /&gt;
== Protección de memoria: ==&lt;br /&gt;
&lt;br /&gt;
Los sistemas operativos monoprogramables tienen debilidades en cuanto a protección de memoria. Para evitar que un proceso entre en el área del SO, se puede recurrir al uso de:&lt;br /&gt;
**'''bits de protección''': se le asocia a cada palabra un bit (1 para S.O. y 0 para proceso) para comprobar si la posición de memoria es de SO o del proceso. Este sistema no exige que la región protegida sea contigua, con lo que el sistema operativo puede marcar como suyas algunas posiciones de memoria de subprocesos especiales lo que permite que los mismos accedan de forma controlada a datos y subprogramas del núcleo.&lt;br /&gt;
&lt;br /&gt;
**'''Registros valla o registros límite''': En el limite entre la zona del sistema operativo y la zona para la ejecución de procesos se carga un registro con la primera posición de memoria que ocupa el proceso. Este sistema es mas sencillo y barato que el anterior, pero solo protege una zona (entre la posición de memoria 0 y la posición de memoria del registro) y son necesarios circuitos comparadores rápidos para evitar retrasar la ejecución de las instrucciones. Su funcionamiento es el siguiente: al intentar acceder a una posición de memoria se comprueba si esta dirección es menor que la dirección del registro valla, si es así se lanza un mensaje de error y si no es así se accede a la posición de memoria deseada.&lt;br /&gt;
&lt;br /&gt;
 Ejemplo práctico: &lt;br /&gt;
 Pablo tiene una computadora cuya memoria principal tiene una capacidad de 640KB. El SO (MS-DOS) ocupa el principio de la memoria, dejando libre una &lt;br /&gt;
 zona de 512KB para el proceso conveniente. &lt;br /&gt;
 Esto nos impide jugar al Sensible Soccer, por ejemplo, ya que ocupa 560KB. Una posible solución sería instalar un SO menos pesado, como una version &lt;br /&gt;
 más antigua de MS-DOS.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2176</id>
		<title>SO monoprogramables</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=SO_monoprogramables&amp;diff=2176"/>
				<updated>2011-12-17T13:35:26Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;En los sistemas operativos monoprogramables la administración de memoria es muy sencilla ya que solo hay un proceso en ejecución que puede usar todo el espacio disponible, la gestión de memoria se limita casi a comprobar si el proceso cabe en el espacio libre en la memoria. El SO se coloca como bloque al principio o al final de la memoria (memoria del sistema), y el resto para el proceso a ejecutar (memoria del proceso):&lt;br /&gt;
                       _______________________                       _______________________ &lt;br /&gt;
                     /|                       | 0                  0|                       |\&lt;br /&gt;
                    | |  zona de memoria del  |                     | zona del S.O en RAM   | |&lt;br /&gt;
                    | |   sistema operativo   |                     |_______________________| | &lt;br /&gt;
                    | |_______________________|                     |                       |\|                      &lt;br /&gt;
                    |/|                       |                     |  zona de memoria del  | | &lt;br /&gt;
       Sistema \    | |                       |                     |  usuario (ejecución   | |    &amp;lt; IBM PC&lt;br /&gt;
       clásico /    | |  zona de memoria del  |                     |  de procesos)         | |    &lt;br /&gt;
                    | |       usuario         |                     |_______________________| | &lt;br /&gt;
                    | |    (ejecución de      |                     |                       |\|&lt;br /&gt;
                    | |       procesos)       |                     |  zona de Lectura      | |  &lt;br /&gt;
                    | |                       |                     |                       | | &lt;br /&gt;
                     \|_______________________| N                  N|_______________________|/        &lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Solapamiento: ==&lt;br /&gt;
Si el proceso no cabe en el espacio libre en memoria puede recurrirse a 2 estrategias para ejecutarlo:&lt;br /&gt;
**Ejecución en cadena:&lt;br /&gt;
  El programa se divide en varios &amp;quot;subprogramas&amp;quot; y se ejecutan en cadena. Esto se consigue haciendo que cada programa termine su ejecución&lt;br /&gt;
  solicitando que se ejecute el siguiente.&lt;br /&gt;
**Fragmentar el programa en módulos de solapamiento o recubrimiento:&lt;br /&gt;
  Dichos módulos se van cargando en memoria según se necesite, algunos S.O. permiten que los submodulos también se dividan, dando lugar a una&lt;br /&gt;
  estructura en árbol.&lt;br /&gt;
&lt;br /&gt;
         '''______'''&lt;br /&gt;
       ''' |      |'''  &lt;br /&gt;
        '''|      |'''  Datos permanentes: Datos globales,&lt;br /&gt;
        '''|      |'''  programa principal y subprogramas comunes&lt;br /&gt;
        '''|      |&lt;br /&gt;
        '''|      |'''&lt;br /&gt;
       ''' |______|'''_______________________________________________________&lt;br /&gt;
        |      |         __|__          __|__          __|__         __|__            /&lt;br /&gt;
        |      |       ''' |     |        |     |        |     |       |     |'''          |&lt;br /&gt;
        |      |        '''|  A  |        |     |        |  C  |       |  D  |'''          |&lt;br /&gt;
        |      |        '''|_____|        |     |        |     |       |_____|'''         &amp;lt;         Módulos de solapamiento o recubrimiento (A, B, C, D)&lt;br /&gt;
        |      |                       '''|  D  |        |_____|'''                        |&lt;br /&gt;
        |      |                       '''|     |'''                                       |&lt;br /&gt;
        |______|                       '''|_____|'''                                        \&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Protección de memoria: ==&lt;br /&gt;
&lt;br /&gt;
Los sistemas operativos monoprogramables tienen debilidades en cuanto a protección de memoria. Para evitar que un proceso entre en el área del SO, se puede recurrir al uso de:&lt;br /&gt;
**'''bits de protección''': se le asocia a cada palabra un bit (1 para S.O. y 0 para proceso) para comprobar si la posición de memoria es de SO o del proceso. Este sistema no exige que la región protegida sea contigua, con lo que el sistema operativo puede marcar como suyas algunas posiciones de memoria de subprocesos especiales lo que permite que los mismos accedan de forma controlada a datos y subprogramas del núcleo.&lt;br /&gt;
&lt;br /&gt;
**'''Registros valla o registros límite''': En el limite entre la zona del sistema operativo y la zona para la ejecución de procesos se carga un registro con la primera posición de memoria que ocupa el proceso. Este sistema es mas sencillo y barato que el anterior, pero solo protege una zona (entre la posición de memoria 0 y la posición de memoria del registro) y son necesarios circuitos comparadores rápidos para evitar retrasar la ejecución de las instrucciones. Su funcionamiento es el siguiente: al intentar acceder a una posición de memoria se comprueba si esta dirección es menor que la dirección del registro valla, si es así se lanza un mensaje de error y si no es así se accede a la posición de memoria deseada.&lt;br /&gt;
&lt;br /&gt;
 Ejemplo práctico: &lt;br /&gt;
 Pablo tiene una computadora cuya memoria principal tiene una capacidad de 640KB. El SO (MS-DOS) ocupa el principio de la memoria, dejando libre una &lt;br /&gt;
 zona de 512KB para el proceso conveniente. &lt;br /&gt;
 Esto nos impide jugar al Sensible Soccer, por ejemplo, ya que ocupa 560KB. Una posible solución sería instalar un SO menos pesado, como una version &lt;br /&gt;
 más antigua de MS-DOS.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Soluci%C3%B3n_Ejercicio_1&amp;diff=2056</id>
		<title>Solución Ejercicio 1</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Soluci%C3%B3n_Ejercicio_1&amp;diff=2056"/>
				<updated>2011-12-06T17:18:18Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Solución Texto */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=Solucion=&lt;br /&gt;
&lt;br /&gt;
==Solucion Visual==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
[[Discusión:Solución_Ejercicio_1|Solución con tablas]]  // [[Usuario:Migoligon|Migoligon]] 15:19 27 nov 2011 (UTC)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
==Solución Texto==&lt;br /&gt;
Se sigue el algoritmo visto en clase:&lt;br /&gt;
&lt;br /&gt;
 1.Buscar un proceso cuya suma recAsig + recDisp &amp;gt;= recMax&lt;br /&gt;
 2.Suponemos que se asignan dichos recursos y el proceso termina su ejecución. &lt;br /&gt;
   Sumamos sus recursos al vector recDisp y añadimos el proceso a la lista de finalizados.&lt;br /&gt;
 3.Repetir primer paso hasta terminar todos los procesos (siendo un estado estable)&lt;br /&gt;
   o bien hasta el punto en el que no sea posible ninguna asignación de recursos,&lt;br /&gt;
   existiendo pues interbloqueo.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Comprobamos si se puede ejecutar P1:&lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=1 recDisp=1 --&amp;gt; recAsig + recDisp = 2 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  2&amp;gt;=1 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R2: recAsig=1 recDisp=0 --&amp;gt; recAsig + recDisp = 1 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  1&amp;gt;=1 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=0 recDisp=1 --&amp;gt; recAsig + recDisp = 1 / recMax=2      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  1&amp;lt;2 --&amp;gt; No se puede ejecutar&lt;br /&gt;
&lt;br /&gt;
Comprobamos si se puede ejecutar P2:&lt;br /&gt;
      &lt;br /&gt;
      R1: recAsig=0 recDisp=1 --&amp;gt; recAsig + recDisp = 1 / recMax=0      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  1&amp;gt;=0 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R2: recAsig=0 recDisp=0 --&amp;gt; recAsig + recDisp = 0 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  0&amp;lt;1 --&amp;gt; No se puede ejecutar&lt;br /&gt;
&lt;br /&gt;
Comprobamos si se puede ejecutar P3:&lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=1 recDisp=1 --&amp;gt; recAsig + recDisp = 2 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  2&amp;gt;=1 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R2: recAsig=1 recDisp=0 --&amp;gt; recAsig + recDisp = 1 / recMax=1      ==&amp;gt; Dispone de los 3 recursos necesarios, por tanto  &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  1&amp;gt;=1 --&amp;gt; ok                          se puede ejecutar.  &lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=0 recDisp=1 --&amp;gt; recAsig + recDisp = 1 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  1&amp;gt;=1 --&amp;gt; ok &lt;br /&gt;
                  &lt;br /&gt;
===== Ejecutados = [P3]  / Disponibles = [ 2 1 1 ] =====&lt;br /&gt;
&lt;br /&gt;
Comprobamos si se puede ejecutar P1 (Hay nuevos recursos disponibles,los liberados por P3):&lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=1 recDisp=2 --&amp;gt; recAsig + recDisp = 3 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  3&amp;gt;=1 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R2: recAsig=1 recDisp=1 --&amp;gt; recAsig + recDisp = 2 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  2&amp;gt;=1 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=0 recDisp=1 --&amp;gt; recAsig + recDisp = 1 / recMax=2      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  1&amp;lt;2 --&amp;gt; No se puede ejecutar&lt;br /&gt;
&lt;br /&gt;
Comprobamos si se puede ejecutar P2 (Hay nuevos recursos disponibles,los liberados por P3):&lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=0 recDisp=2 --&amp;gt; recAsig + recDisp = 2 / recMax=0      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  2&amp;gt;=0 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R2: recAsig=0 recDisp=1 --&amp;gt; recAsig + recDisp = 1 / recMax=1      ==&amp;gt; Dispone de los 3 recursos necesarios,por tanto&lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  1&amp;gt;=1 --&amp;gt; ok                          se puede ejecutar.&lt;br /&gt;
&lt;br /&gt;
      R2: recAsig=1 recDisp=1 --&amp;gt; recAsig + recDisp = 2 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  2&amp;gt;=1 --&amp;gt; ok&lt;br /&gt;
                                       &lt;br /&gt;
===== Ejecutados = [P3,P2]  / Disponibles = [ 2 1 2 ]=====&lt;br /&gt;
&lt;br /&gt;
Comprobamos si se puede ejecutar P1 (Hay nuevos recursos disponibles,los liberados por P2):&lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=1 recDisp=2 --&amp;gt; recAsig + recDisp = 3 / recMax=1      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  3&amp;gt;=1 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
      R2: recAsig=1 recDisp=1 --&amp;gt; recAsig + recDisp = 2 / recMax=1     ==&amp;gt; Dispone de los 3 recursos necesarios,por tanto  &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  2&amp;gt;=1 --&amp;gt; ok                         se puede ejecutar.  &lt;br /&gt;
&lt;br /&gt;
      R1: recAsig=0 recDisp=2 --&amp;gt; recAsig + recDisp = 2 / recMax=2      &lt;br /&gt;
          ¿recAsig+recDisp &amp;gt;= recMax?  2&amp;gt;=2 --&amp;gt; ok&lt;br /&gt;
&lt;br /&gt;
===== Ejecutados = [P3,P2,P1]  / Disponibles = [ 3 2 2 ]  =====&lt;br /&gt;
&lt;br /&gt;
                                         &lt;br /&gt;
Es una configuración de estado seguro ya que se ejecutan los 3 procesos sin dar lugar a interbloqueos.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Condiciones_para_el_interbloqueo_y_estrategias_de_resoluci%C3%B3n&amp;diff=2053</id>
		<title>Condiciones para el interbloqueo y estrategias de resolución</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Condiciones_para_el_interbloqueo_y_estrategias_de_resoluci%C3%B3n&amp;diff=2053"/>
				<updated>2011-12-05T20:59:00Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Predicción */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Condiciones para que se produzca interbloqueo ==&lt;br /&gt;
&lt;br /&gt;
Según [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman], para que se pueda producir un interbloqueo se tienen que dar la siguientes cuatro condiciones:&lt;br /&gt;
&lt;br /&gt;
* '''Exclusión mutua''': cada recurso está asignado a un único proceso de manera exclusiva.&lt;br /&gt;
* '''Retención y espera''': los procesos que tienen, en un momento dado, recursos asignados con anterioridad, pueden solicitar nuevos recursos.&lt;br /&gt;
&lt;br /&gt;
* '''No apropiación''': los recursos otorgados con anterioridad no pueden ser forzados a dejar un  proceso. El proceso que los posee debe liberarlos en forma explícita. Ni si quiera el sistema operativo puede expropiarselo.&lt;br /&gt;
&lt;br /&gt;
* '''Espera circular''': debe existir una cadena circular de dos o más procesos, cada uno de los cuales espera un recurso poseído por el siguiente miembro de la cadena. Esta condición es una consecuencia potencial de las tres primeras, es decir, dado que se producen las tres primeras condiciones, puede ocurrir una secuencia de eventos que desemboque en un círculo vicioso de espera irresoluble. &lt;br /&gt;
&lt;br /&gt;
Las tres primeras condiciones son necesarias, pero no suficientes para que exista interbloqueo. Sólo las cuatro condiciones en conjunto constituyen una condición necesaria y suficiente para el interbloqueo.&lt;br /&gt;
&lt;br /&gt;
== Estrategias ==&lt;br /&gt;
&lt;br /&gt;
Existen diversas estrategias frente a los interbloqueos, que se pueden agrupar en:&lt;br /&gt;
&lt;br /&gt;
* Omisión&lt;br /&gt;
* Detección y recuperación&lt;br /&gt;
* Prevención&lt;br /&gt;
* Predicción&lt;br /&gt;
&lt;br /&gt;
Que se detallan a continuación.&lt;br /&gt;
&lt;br /&gt;
=== Omisión ===&lt;br /&gt;
&lt;br /&gt;
Considera que la probabilidad de un interbloqueo es muy baja, de modo que se confía en que no se van a producir. Por sorprendente que parezca, los sistemas operativos modernos convencionales suelen aplicar esta estrategia. Por justificar la decisión de los fabricantes de sistemas operativos cabe incidir en que las estrategias de resolución y prevención de interbloqueos tienen un coste alto desde el punto de vista del consumo de recursos de procesamiento y memoria.&lt;br /&gt;
&lt;br /&gt;
=== Detección y Recuperación ===&lt;br /&gt;
&lt;br /&gt;
Esta estrategia permite la detección de una situación de interbloqueo y su consiguiente resolución. De entre las medidas de detección consideramos las siguientes:&lt;br /&gt;
&lt;br /&gt;
* ''Grafo de relación recursos-procesos'': Consiste en la representación gráfica de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución.&lt;br /&gt;
&lt;br /&gt;
* ''Matrices de relación recursos-procesos'': Consiste en la representación matricial de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución.&lt;br /&gt;
&lt;br /&gt;
Tras la detección de un interbloqueo, se pueden aplicar algunas de las siguientes estrategias para resolverlo:&lt;br /&gt;
&lt;br /&gt;
* ''Eliminación'': El sistema operativo selecciona a uno de los procesos que forma parte del interbloqueo y elimina el ciclo acabando con la ejecución de dicho proceso. La selección del proceso se realiza en base a un cierto criterio, por ejemplo, aquel proceso que lleve menos tiempo en ejecución o aquel que sea más voraz consumiendo recursos. Aunque parezca una medida drástica, es la empleada en sistemas operativos convencionales.&lt;br /&gt;
&lt;br /&gt;
* ''Apropiación temporal'': Se retira la asignación de un recurso a un proceso para deshacer el interbloqueo.&lt;br /&gt;
&lt;br /&gt;
* ''Puntos de conformidad'' o ''checkpoints'': Consiste en tomar una imagen del estado del proceso, ya sea periódicamente o a instancia del propio proceso, de manera que si se produce un interbloqueo se vuelve a un estado de la ejecución anterior. Son muy poco usados ya que tienen un elevado coste en memoria y existe la posibilidad de que un proceso permanezca indefinidamente sin progresar.&lt;br /&gt;
&lt;br /&gt;
=== Prevención ===&lt;br /&gt;
&lt;br /&gt;
La prevención apunta a una serie de estrategias que eviten el interbloqueo. Concretamente, son cuatro las estrategias de prevención posibles en base a los  principios que [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman] estableció como interbloqueo. Dichas estrategias son:&lt;br /&gt;
&lt;br /&gt;
* ''Supresión de exclusión mutua'': un proceso no puede tener acceso exclusivo a un recurso.&lt;br /&gt;
* ''Supresión de retención y espera'' (1ª estrategia de Havender): El proceso debe tener asignado todos los recursos necesarios al inicio y no liberarlos hasta que éste finalice. Esto presenta un inconveniente: si un recurso sólo se utiliza al final, estará ocupado durante toda la ejecución, no permitiendo ser usado por otros procesos.&lt;br /&gt;
* ''Supresión de no apropiación'' (2ª estrategia de Havender): Si un proceso está en ejecución y no puede obtener un recurso, dicho proceso libera todos los recursos que está usando y espera a que todos los que necesita estén disponibles. Problemas: se puede perder trabajo, además de presentar una carga extra la realización de peticiones &lt;br /&gt;
* ''Supresión de espera circular'' (3ª estrategia de Havender): Si todos los recursos comunes a varios procesos se solicitan siempre en el mismo orden no se producen interbloqueos.&lt;br /&gt;
&lt;br /&gt;
=== Predicción ===&lt;br /&gt;
&lt;br /&gt;
El sistema operativo observa la evolución que siguen los procesos, y predice una posible situación de interbloqueo. Si detecta una alta probabilidad de que suceda, adopta una trayectoria de ejecución nueva para los procesos involucrados de manera que se garantice que no va a suceder un interbloqueo.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Condiciones_para_el_interbloqueo_y_estrategias_de_resoluci%C3%B3n&amp;diff=2052</id>
		<title>Condiciones para el interbloqueo y estrategias de resolución</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Condiciones_para_el_interbloqueo_y_estrategias_de_resoluci%C3%B3n&amp;diff=2052"/>
				<updated>2011-12-05T20:12:52Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Detección y Recuperación */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Condiciones para que se produzca interbloqueo ==&lt;br /&gt;
&lt;br /&gt;
Según [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman], para que se pueda producir un interbloqueo se tienen que dar la siguientes cuatro condiciones:&lt;br /&gt;
&lt;br /&gt;
* '''Exclusión mutua''': cada recurso está asignado a un único proceso de manera exclusiva.&lt;br /&gt;
* '''Retención y espera''': los procesos que tienen, en un momento dado, recursos asignados con anterioridad, pueden solicitar nuevos recursos.&lt;br /&gt;
&lt;br /&gt;
* '''No apropiación''': los recursos otorgados con anterioridad no pueden ser forzados a dejar un  proceso. El proceso que los posee debe liberarlos en forma explícita. Ni si quiera el sistema operativo puede expropiarselo.&lt;br /&gt;
&lt;br /&gt;
* '''Espera circular''': debe existir una cadena circular de dos o más procesos, cada uno de los cuales espera un recurso poseído por el siguiente miembro de la cadena. Esta condición es una consecuencia potencial de las tres primeras, es decir, dado que se producen las tres primeras condiciones, puede ocurrir una secuencia de eventos que desemboque en un círculo vicioso de espera irresoluble. &lt;br /&gt;
&lt;br /&gt;
Las tres primeras condiciones son necesarias, pero no suficientes para que exista interbloqueo. Sólo las cuatro condiciones en conjunto constituyen una condición necesaria y suficiente para el interbloqueo.&lt;br /&gt;
&lt;br /&gt;
== Estrategias ==&lt;br /&gt;
&lt;br /&gt;
Existen diversas estrategias frente a los interbloqueos, que se pueden agrupar en:&lt;br /&gt;
&lt;br /&gt;
* Omisión&lt;br /&gt;
* Detección y recuperación&lt;br /&gt;
* Prevención&lt;br /&gt;
* Predicción&lt;br /&gt;
&lt;br /&gt;
Que se detallan a continuación.&lt;br /&gt;
&lt;br /&gt;
=== Omisión ===&lt;br /&gt;
&lt;br /&gt;
Considera que la probabilidad de un interbloqueo es muy baja, de modo que se confía en que no se van a producir. Por sorprendente que parezca, los sistemas operativos modernos convencionales suelen aplicar esta estrategia. Por justificar la decisión de los fabricantes de sistemas operativos cabe incidir en que las estrategias de resolución y prevención de interbloqueos tienen un coste alto desde el punto de vista del consumo de recursos de procesamiento y memoria.&lt;br /&gt;
&lt;br /&gt;
=== Detección y Recuperación ===&lt;br /&gt;
&lt;br /&gt;
Esta estrategia permite la detección de una situación de interbloqueo y su consiguiente resolución. De entre las medidas de detección consideramos las siguientes:&lt;br /&gt;
&lt;br /&gt;
* ''Grafo de relación recursos-procesos'': Consiste en la representación gráfica de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución.&lt;br /&gt;
&lt;br /&gt;
* ''Matrices de relación recursos-procesos'': Consiste en la representación matricial de los recursos asignados a los procesos y los recursos que dichos procesos requieren para finalizar su ejecución.&lt;br /&gt;
&lt;br /&gt;
Tras la detección de un interbloqueo, se pueden aplicar algunas de las siguientes estrategias para resolverlo:&lt;br /&gt;
&lt;br /&gt;
* ''Eliminación'': El sistema operativo selecciona a uno de los procesos que forma parte del interbloqueo y elimina el ciclo acabando con la ejecución de dicho proceso. La selección del proceso se realiza en base a un cierto criterio, por ejemplo, aquel proceso que lleve menos tiempo en ejecución o aquel que sea más voraz consumiendo recursos. Aunque parezca una medida drástica, es la empleada en sistemas operativos convencionales.&lt;br /&gt;
&lt;br /&gt;
* ''Apropiación temporal'': Se retira la asignación de un recurso a un proceso para deshacer el interbloqueo.&lt;br /&gt;
&lt;br /&gt;
* ''Puntos de conformidad'' o ''checkpoints'': Consiste en tomar una imagen del estado del proceso, ya sea periódicamente o a instancia del propio proceso, de manera que si se produce un interbloqueo se vuelve a un estado de la ejecución anterior. Son muy poco usados ya que tienen un elevado coste en memoria y existe la posibilidad de que un proceso permanezca indefinidamente sin progresar.&lt;br /&gt;
&lt;br /&gt;
=== Prevención ===&lt;br /&gt;
&lt;br /&gt;
La prevención apunta a una serie de estrategias que eviten el interbloqueo. Concretamente, son cuatro las estrategias de prevención posibles en base a los  principios que [http://en.wikipedia.org/wiki/Edward_G._Coffman,_Jr. Coffman] estableció como interbloqueo. Dichas estrategias son:&lt;br /&gt;
&lt;br /&gt;
* ''Supresión de exclusión mutua'': un proceso no puede tener acceso exclusivo a un recurso.&lt;br /&gt;
* ''Supresión de retención y espera'' (1ª estrategia de Havender): El proceso debe tener asignado todos los recursos necesarios al inicio y no liberarlos hasta que éste finalice. Esto presenta un inconveniente: si un recurso sólo se utiliza al final, estará ocupado durante toda la ejecución, no permitiendo ser usado por otros procesos.&lt;br /&gt;
* ''Supresión de no apropiación'' (2ª estrategia de Havender): Si un proceso está en ejecución y no puede obtener un recurso, dicho proceso libera todos los recursos que está usando y espera a que todos los que necesita estén disponibles. Problemas: se puede perder trabajo, además de presentar una carga extra la realización de peticiones &lt;br /&gt;
* ''Supresión de espera circular'' (3ª estrategia de Havender): Si todos los recursos comunes a varios procesos se solicitan siempre en el mismo orden no se producen interbloqueos.&lt;br /&gt;
&lt;br /&gt;
=== Predicción ===&lt;br /&gt;
&lt;br /&gt;
El sistema operativo observa la evolución que siguen los procesos, y predice una posible situación de interbloqueo. Si detecta una alta probabilidad de que sucede, adopta una trayectoria de ejecución de los procesos involucrados en el posible interbloqueo de manera que se garantice que no va a suceder.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mensajer%C3%ADa&amp;diff=2022</id>
		<title>Mensajería</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mensajer%C3%ADa&amp;diff=2022"/>
				<updated>2011-12-02T09:29:28Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Denominación Directa */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Un mensaje es un contenedor que se emplear para intercambiar información entre dos o más procesos. Los mensajes tienen un cierto formato generalmente compuesto por una cabecera, que contiene información sobre la fuente y el destinatario, y un cuerpo, que contiene información específica.&lt;br /&gt;
&lt;br /&gt;
Los mecanismos de mensajería se refiere al conjunto de funcionalidades que permiten al sistema operativo realizar la entrega de un mensaje a uno o varios procesos. Mediante dicho mecanismo también es posible resolver problemas de concurrencia.&lt;br /&gt;
&lt;br /&gt;
Los sistemas operativos generalmente ofrecen dos llamadas al sistema para que un proceso pueda enviar y recibir mensajes:&lt;br /&gt;
&lt;br /&gt;
* '''send(mensaje, destino)''': Para enviar un mensaje&lt;br /&gt;
* '''recv(mensaje)'''': Para recibir un mensaje&lt;br /&gt;
&lt;br /&gt;
Cualquier proceso que necesita comprobar si tiene mensajes para ser procesados por él debe invocar la llamada al sistema '''recv'''.&lt;br /&gt;
&lt;br /&gt;
== Formas de identificación ==&lt;br /&gt;
&lt;br /&gt;
Para identificar la fuente y el destino de nuestro mensaje se pueden emplear dos estrategias.&lt;br /&gt;
&lt;br /&gt;
=== Denominación Directa ===&lt;br /&gt;
&lt;br /&gt;
En este caso se emplea un ID que permite identificar a la fuente y al destinatario de manera unívoca en el sistema, por ejemplo, el PID de un proceso. La denominación directa permite tres configuraciones:&lt;br /&gt;
&lt;br /&gt;
* ''Unicast'', de manera que la comunicación sucede entre una fuente y un destinatario.&lt;br /&gt;
* ''Broadcast'', el emisor envía un mensaje a '''todos''' los procesos existentes en el sistema.&lt;br /&gt;
* ''Multicast'', el emisor envía un mensaje a un grupo de procesos, siendo un grupo un subconjunto de procesos existentes en el sistema. El sistema operativo debe ofrecer llamadas al sistema que permitan a los procesos crear grupos y suscribirse a ellos. Un proceso puede suscribirse a tantos grupos como le sea necesario.&lt;br /&gt;
&lt;br /&gt;
El principal inconveniente de la denominación directa es que se pierde el mensaje si el destino no se encuentra.&lt;br /&gt;
&lt;br /&gt;
=== Denominación Indirecta ===&lt;br /&gt;
&lt;br /&gt;
Se emplea un elemento intermediario denominado ''buzón''. El sistema operativo ofrece llamadas al sistema que permiten la creación y destrucción de buzones, por ejemplo, '''CreateMailbox''' y '''DestroyMailbox'''. Una vez creado el buzón, se emplea éste para realizar la comunicación entre procesos.&lt;br /&gt;
&lt;br /&gt;
El sistema operativo debe de comprobar que la identidad de la fuente de un mensaje es correcta, de lo contrario un proceso podría suplantar la identidad de otro.&lt;br /&gt;
&lt;br /&gt;
== Formas de transmisión ==&lt;br /&gt;
&lt;br /&gt;
Distinguimos tres formas de transmisión: Transmisión por copia, transmisión por referencia y transmisión por copia en caso de escritura.&lt;br /&gt;
&lt;br /&gt;
=== Transmisión por copia ===&lt;br /&gt;
&lt;br /&gt;
Si se emplea ''denominación directa'', al invocar el receptor la llamada ''recv'', el mensaje se copia de espacio de memoria del emisor al espacio de receptor. Esta forma de implementar la transmisión tiene un coste de orden lineal &amp;lt;math&amp;gt;O(n)&amp;lt;/math&amp;gt;.&lt;br /&gt;
&lt;br /&gt;
Si se emplea ''denominación indirecta'', al invocar ''send'' el emisor, el mensaje se copia del espacio de emisor al espacio del buzón, que se encuentra en el espacio de memoria del sistema operativo. Una vez que el receptor invoca ''receive'', se copia el mensaje al espacio de memoria que el receptor ha habilitado para almacenar el mensaje.&lt;br /&gt;
&lt;br /&gt;
=== Transmisión por referencia ===&lt;br /&gt;
&lt;br /&gt;
Es una mejora frente al mecanismo de transmisión por copia. Básicamente, en lugar de copiar el mensaje, lo que supone un coste de &amp;lt;math&amp;gt;O(n)&amp;lt;/math&amp;gt;, se le devuelve al receptor una dirección de memoria en la que se encuentra el mensaje, lo que supone únicamente 4 u 8 bytes dependiendo del tamaño de palabra del procesador (si es de 32-bits o 64-bits).&lt;br /&gt;
&lt;br /&gt;
Si se emplea junto a la '''denominación directa''', el sistema operativo le devuelve al receptor un puntero a la dirección en la que se encuentra el mensaje. Si el mensaje está en el espacio del emisor, son necesarios mecanismos explícitos de compartición de memoria entre procesos, ya que dos procesos cualquiera no comparten memoria. Si el mensaje está en el espacio del sistema operativo, éste debe ofrecer a los procesos mecanismos para acceder a su espacio de memoria-&lt;br /&gt;
&lt;br /&gt;
Si se emplea junto a la '''denominación indirecta''', el emisor crea un mensaje en el espacio del sistema operativo y se le ofrece un puntero al receptor.&lt;br /&gt;
&lt;br /&gt;
=== Transmisión por copia de escritura ===&lt;br /&gt;
&lt;br /&gt;
El mensaje sólo se copia si se modifica por emisor o receptor.&lt;br /&gt;
&lt;br /&gt;
== Formas de comunicación ==&lt;br /&gt;
&lt;br /&gt;
* Comportamiento del emisor, '''send()'''&lt;br /&gt;
** ''Síncrona'': el proceso emisor que realiza el send() queda bloqueado hasta que el receptor llama a recv()&lt;br /&gt;
** ''Asíncrona'': suponemos una estructura de datos con capacidad de almacenamiento limitada, dependiente del proceso destinatario o en el buzón del SO. Al ser enviados, los mensajes irán encolándose para que el proceso receptor pueda gestionarlos cuando pueda. De esta manera se aumenta el rendimiento pero se requiere de políticas adicionales de tratamiento de los mensajes si la capacidad de almacenamiento de la estructura de datos se ve sobrepasada(PE, eliminación de mensajes, realocalización de memoria, etc..)&lt;br /&gt;
&lt;br /&gt;
* Comportamiento del receptor, '''recv()'''&lt;br /&gt;
** ''Bloqueante'': una llamada a recv() sin mensajes a procesar pasa el proceso llamante a estado bloqueado. Un send() de otro proceso que añada un mensaje a la cola del proceso bloqueado hace que éste pase a estado preparado.&lt;br /&gt;
** ''No bloqueante'': una llamada a recv() sin mensajes a procesar devuelve un mensaje de error, pero la ejecución del proceso llamante continúa.&lt;br /&gt;
&lt;br /&gt;
Entendemos por proceso llamante a aquel que hace uso de las llamadas send() y recv().&lt;br /&gt;
&lt;br /&gt;
== Formato de los mensajes ==&lt;br /&gt;
&lt;br /&gt;
=== Fijo ===&lt;br /&gt;
&lt;br /&gt;
Los procesos acuerdan emplear un formato fijo para sus mensajes.&lt;br /&gt;
&lt;br /&gt;
'''Ejemplo''': Simple Network Time Protocol.&amp;lt;ref&amp;gt; Véase http://tools.ietf.org/html/rfc4330, sección 4, Message Format.&amp;lt;/ref&amp;gt;&lt;br /&gt;
&lt;br /&gt;
                           1                   2                   3&lt;br /&gt;
       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&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |LI | VN  |Mode |    Stratum    |     Poll      |   Precision    |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                          Root  Delay                           |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                       Root  Dispersion                         |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                     Reference Identifier                       |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      |                    Reference Timestamp (64)                    |&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      |                    Originate Timestamp (64)                    |&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      |                     Receive Timestamp (64)                     |&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      |                     Transmit Timestamp (64)                    |&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                 Key Identifier (optional) (32)                 |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      |                 Message Digest (optional) (128)                |&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      |                                                                |&lt;br /&gt;
      +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
&lt;br /&gt;
=== Variable ===&lt;br /&gt;
&lt;br /&gt;
* Type-Length-Value&lt;br /&gt;
&lt;br /&gt;
'''Ejemplo''': Usado en Netlink para la codificación de atributos de un mensaje.&amp;lt;ref&amp;gt;Ver Communicating between the kernel and user-space in Linux using Netlink Sockets (http://1984.lsi.us.es/~pablo/docs/spae.pdf)&amp;lt;/ref&amp;gt;&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
|+ align=&amp;quot;center&amp;quot; style=&amp;quot;background:DarkSlateBlue; color:white&amp;quot;|'''Type-Length-Value'''&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 0&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 1&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 2&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 3&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 4&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 5&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 6&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 7&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 8&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 9&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 10&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 11&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 12&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 13&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 14&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 15&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 16&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 17&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 18&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 19&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 20&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 21&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 22&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 23&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 24&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 25&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 26&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 27&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 28&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 29&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 30&lt;br /&gt;
! width=&amp;quot;15 px&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | 31&lt;br /&gt;
&lt;br /&gt;
|-&lt;br /&gt;
| colspan=16, align=&amp;quot;center&amp;quot;| Length &lt;br /&gt;
| colspan=16, align=&amp;quot;center&amp;quot;| Type&lt;br /&gt;
|-&lt;br /&gt;
| colspan=32, align=&amp;quot;center&amp;quot;| Value &lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
* Text-based human-readable.&lt;br /&gt;
&lt;br /&gt;
#Comma-Separated Value (CSV). http://en.wikipedia.org/wiki/Comma-separated_values&lt;br /&gt;
#Extensible Markup Language (XML). http://en.wikipedia.org/wiki/XML&lt;br /&gt;
#JavaScript Object Notation (JSON). http://en.wikipedia.org/wiki/JSON&lt;br /&gt;
&lt;br /&gt;
=== Mixto ===&lt;br /&gt;
&lt;br /&gt;
Los procesos acuerdan emplear mensaje con partes cuyo formato es fijo, como por ejemplo una cabecera inicial, seguido de partes de tamaño variable.&lt;br /&gt;
&lt;br /&gt;
'''Ejemplo''': Internet Protocol (IPv4).&amp;lt;ref&amp;gt;Ver http://www.ietf.org/rfc/rfc791.txt, sección 3.1.&amp;lt;/ref&amp;gt;&lt;br /&gt;
                                    &lt;br /&gt;
    0                   1                   2                   3   &lt;br /&gt;
    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 &lt;br /&gt;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
   |Version|  IHL  |Type of Service|          Total Length         |&lt;br /&gt;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
   |         Identification        |Flags|      Fragment Offset    |&lt;br /&gt;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
   |  Time to Live |    Protocol   |         Header Checksum       |&lt;br /&gt;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
   |                       Source Address                          |&lt;br /&gt;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
   |                    Destination Address                        |&lt;br /&gt;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
   |                    Options                    |    Padding    |&lt;br /&gt;
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+&lt;br /&gt;
   /                                                               /&lt;br /&gt;
   /                         Payload                               /&lt;br /&gt;
   /                                                               /&lt;br /&gt;
   /////////////////////////////////////////////////////////////////&lt;br /&gt;
&lt;br /&gt;
== Mensajería a través de la red ==&lt;br /&gt;
&lt;br /&gt;
* Unicidad del destinatario&lt;br /&gt;
* Fiabilidad en la transmisión&lt;br /&gt;
* 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.&lt;br /&gt;
&lt;br /&gt;
** Little Endian: Bytes menos significativo al principio.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int main(void)&lt;br /&gt;
{&lt;br /&gt;
        int a = 10, i;&lt;br /&gt;
        char *p = &amp;amp;a;&lt;br /&gt;
&lt;br /&gt;
        for (i=0; i&amp;lt;sizeof(a); i++) {&lt;br /&gt;
                printf(&amp;quot;posición %d: %.2x\n&amp;quot;, i, p[i]);&lt;br /&gt;
        }&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Muestra el siguiente resultado en un PC:&lt;br /&gt;
&lt;br /&gt;
 posición 0: 0a (n+3)&lt;br /&gt;
 posición 1: 00 (n+2)&lt;br /&gt;
 posición 2: 00 (n+1)&lt;br /&gt;
 posición 3: 00 (n)&lt;br /&gt;
&lt;br /&gt;
** Big Endian: Bytes menos significativo al final.&lt;br /&gt;
&lt;br /&gt;
 posición 0: 00 (n)&lt;br /&gt;
 posición 1: 00 (n+1)&lt;br /&gt;
 posición 2: 00 (n+2)&lt;br /&gt;
 posición 3: 0a (n+3)&lt;br /&gt;
&lt;br /&gt;
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).&lt;br /&gt;
&lt;br /&gt;
En little-endian, la implementación de ntohl es la siguiente:&lt;br /&gt;
&lt;br /&gt;
#define __constant_ntohl(x) ___constant_swab32((__be32)(x)&lt;br /&gt;
&lt;br /&gt;
Ver /usr/include/linux/byteorder/little_endian.h &lt;br /&gt;
&lt;br /&gt;
mientras que en big-endian es:&lt;br /&gt;
&lt;br /&gt;
#define __constant_ntohl(x) ((__u32)(__be32)(x))&lt;br /&gt;
&lt;br /&gt;
Si empleamos formato textuales, como CSV, XML o JSON, que codifican la información en bytes, no tenemos este problema.&lt;br /&gt;
&lt;br /&gt;
==Referencias==&lt;br /&gt;
&amp;lt;references/&amp;gt;&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sem%C3%A1foros&amp;diff=1985</id>
		<title>Semáforos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sem%C3%A1foros&amp;diff=1985"/>
				<updated>2011-12-01T16:42:19Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Planificador de procesos: Diagrama de estados simplicado */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Planificador de procesos: Diagrama de estados simplicado =&lt;br /&gt;
&lt;br /&gt;
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]]&lt;br /&gt;
&lt;br /&gt;
= Semáforos =&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Los semáforos son un tipo de datos que están compuestos por dos atributos:&lt;br /&gt;
&lt;br /&gt;
* Un contador, que siempre vale &amp;gt;= 0.&lt;br /&gt;
* Una lista de procesos(lista formada por el PCB de cada proceso), inicialmente vacía.&lt;br /&gt;
&lt;br /&gt;
Y disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
down(semáforo s)&lt;br /&gt;
{&lt;br /&gt;
       si s.contador == 0:&lt;br /&gt;
              añade proceso a s.lista&lt;br /&gt;
              proceso a estado bloqueado&lt;br /&gt;
       sino:&lt;br /&gt;
              s.contador--&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
up(semáforo s)&lt;br /&gt;
{&lt;br /&gt;
       si hay procesos en s.lista&lt;br /&gt;
              retira proceso de s.lista&lt;br /&gt;
              proceso a estado preparado&lt;br /&gt;
       sino:&lt;br /&gt;
              s.contador++&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Además, se disponen de un constructor y un destructor que permiten la creación y la liberación de un semáforo.&lt;br /&gt;
&lt;br /&gt;
=== Ejemplo de uso de semáforos ===&lt;br /&gt;
&lt;br /&gt;
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:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
semaforo a = semaforo.create(1);&lt;br /&gt;
semaforo b = semaforo.create(0);&lt;br /&gt;
&lt;br /&gt;
/* código del hilo A */&lt;br /&gt;
while (1) {&lt;br /&gt;
       a.down();&lt;br /&gt;
       printf(&amp;quot;hilo A\n&amp;quot;);&lt;br /&gt;
       b.up();&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
/* código del hilo B */&lt;br /&gt;
while (1) {&lt;br /&gt;
       b.down();&lt;br /&gt;
       printf(&amp;quot;hilo B\n&amp;quot;);&lt;br /&gt;
       a.up();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Tipos de semáforos ===&lt;br /&gt;
&lt;br /&gt;
Dependiendo de la función que cumple el semáforo, vamos a diferenciar los siguientes tipos:&lt;br /&gt;
&lt;br /&gt;
* 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.&lt;br /&gt;
* Semáforo contador, permiten llevar la cuenta del número de unidades de recurso compartido disponible, que va desde 0 hasta N.&lt;br /&gt;
* 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.&lt;br /&gt;
&lt;br /&gt;
=== Ventajas e inconvenientes ===&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Los inconvenientes asociados al uso de semáforos son los siguientes:&lt;br /&gt;
&lt;br /&gt;
* Los programadores tienden a usarlos incorrectamente, de manera que no resuelven de manera adecuada el problema de concurrencia o dan lugar a interbloqueos.&lt;br /&gt;
* No hay nada que obligue a los programadores a usarlos.&lt;br /&gt;
* Los compiladores no ofrecen ningún mecanismo de comprobación sobre el correcto uso de los semáforos.&lt;br /&gt;
* Son independientes del recurso compartido al que se asocian.&lt;br /&gt;
&lt;br /&gt;
Debido a estos inconvenientes, se desarrollaron los [[Monitores|monitores]].&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sem%C3%A1foros&amp;diff=1984</id>
		<title>Semáforos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sem%C3%A1foros&amp;diff=1984"/>
				<updated>2011-12-01T16:41:39Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Planificador de procesos: Diagrama de estados simplicado */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Planificador de procesos: Diagrama de estados simplicado =&lt;br /&gt;
&lt;br /&gt;
Para comprender apropiadamente cómo funcionan los semáforos es importante recordar cómo funciona el [[Diagrama de estados simplificado|diagrama de estados de los procesos]]&lt;br /&gt;
&lt;br /&gt;
= Semáforos =&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Los semáforos son un tipo de datos que están compuestos por dos atributos:&lt;br /&gt;
&lt;br /&gt;
* Un contador, que siempre vale &amp;gt;= 0.&lt;br /&gt;
* Una lista de procesos(lista formada por el PCB de cada proceso), inicialmente vacía.&lt;br /&gt;
&lt;br /&gt;
Y disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
down(semáforo s)&lt;br /&gt;
{&lt;br /&gt;
       si s.contador == 0:&lt;br /&gt;
              añade proceso a s.lista&lt;br /&gt;
              proceso a estado bloqueado&lt;br /&gt;
       sino:&lt;br /&gt;
              s.contador--&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
up(semáforo s)&lt;br /&gt;
{&lt;br /&gt;
       si hay procesos en s.lista&lt;br /&gt;
              retira proceso de s.lista&lt;br /&gt;
              proceso a estado preparado&lt;br /&gt;
       sino:&lt;br /&gt;
              s.contador++&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Además, se disponen de un constructor y un destructor que permiten la creación y la liberación de un semáforo.&lt;br /&gt;
&lt;br /&gt;
=== Ejemplo de uso de semáforos ===&lt;br /&gt;
&lt;br /&gt;
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:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
semaforo a = semaforo.create(1);&lt;br /&gt;
semaforo b = semaforo.create(0);&lt;br /&gt;
&lt;br /&gt;
/* código del hilo A */&lt;br /&gt;
while (1) {&lt;br /&gt;
       a.down();&lt;br /&gt;
       printf(&amp;quot;hilo A\n&amp;quot;);&lt;br /&gt;
       b.up();&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
/* código del hilo B */&lt;br /&gt;
while (1) {&lt;br /&gt;
       b.down();&lt;br /&gt;
       printf(&amp;quot;hilo B\n&amp;quot;);&lt;br /&gt;
       a.up();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Tipos de semáforos ===&lt;br /&gt;
&lt;br /&gt;
Dependiendo de la función que cumple el semáforo, vamos a diferenciar los siguientes tipos:&lt;br /&gt;
&lt;br /&gt;
* 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.&lt;br /&gt;
* Semáforo contador, permiten llevar la cuenta del número de unidades de recurso compartido disponible, que va desde 0 hasta N.&lt;br /&gt;
* 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.&lt;br /&gt;
&lt;br /&gt;
=== Ventajas e inconvenientes ===&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Los inconvenientes asociados al uso de semáforos son los siguientes:&lt;br /&gt;
&lt;br /&gt;
* Los programadores tienden a usarlos incorrectamente, de manera que no resuelven de manera adecuada el problema de concurrencia o dan lugar a interbloqueos.&lt;br /&gt;
* No hay nada que obligue a los programadores a usarlos.&lt;br /&gt;
* Los compiladores no ofrecen ningún mecanismo de comprobación sobre el correcto uso de los semáforos.&lt;br /&gt;
* Son independientes del recurso compartido al que se asocian.&lt;br /&gt;
&lt;br /&gt;
Debido a estos inconvenientes, se desarrollaron los [[Monitores|monitores]].&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sem%C3%A1foros&amp;diff=1983</id>
		<title>Semáforos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Sem%C3%A1foros&amp;diff=1983"/>
				<updated>2011-12-01T16:40:17Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Planificador de procesos: Diagrama de estados simplicado */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Planificador de procesos: Diagrama de estados simplicado =&lt;br /&gt;
&lt;br /&gt;
Para comprender apropiadamente cómo funcionan los semáforos es importante recordar cómo funciona el [[Solución de los ejercicios de concurrencia|Solución]]&lt;br /&gt;
&lt;br /&gt;
= Semáforos =&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Los semáforos son un tipo de datos que están compuestos por dos atributos:&lt;br /&gt;
&lt;br /&gt;
* Un contador, que siempre vale &amp;gt;= 0.&lt;br /&gt;
* Una lista de procesos(lista formada por el PCB de cada proceso), inicialmente vacía.&lt;br /&gt;
&lt;br /&gt;
Y disponen de dos operaciones básicas que pasamos a describir en pseudocódigo:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
down(semáforo s)&lt;br /&gt;
{&lt;br /&gt;
       si s.contador == 0:&lt;br /&gt;
              añade proceso a s.lista&lt;br /&gt;
              proceso a estado bloqueado&lt;br /&gt;
       sino:&lt;br /&gt;
              s.contador--&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
up(semáforo s)&lt;br /&gt;
{&lt;br /&gt;
       si hay procesos en s.lista&lt;br /&gt;
              retira proceso de s.lista&lt;br /&gt;
              proceso a estado preparado&lt;br /&gt;
       sino:&lt;br /&gt;
              s.contador++&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Además, se disponen de un constructor y un destructor que permiten la creación y la liberación de un semáforo.&lt;br /&gt;
&lt;br /&gt;
=== Ejemplo de uso de semáforos ===&lt;br /&gt;
&lt;br /&gt;
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:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
semaforo a = semaforo.create(1);&lt;br /&gt;
semaforo b = semaforo.create(0);&lt;br /&gt;
&lt;br /&gt;
/* código del hilo A */&lt;br /&gt;
while (1) {&lt;br /&gt;
       a.down();&lt;br /&gt;
       printf(&amp;quot;hilo A\n&amp;quot;);&lt;br /&gt;
       b.up();&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
/* código del hilo B */&lt;br /&gt;
while (1) {&lt;br /&gt;
       b.down();&lt;br /&gt;
       printf(&amp;quot;hilo B\n&amp;quot;);&lt;br /&gt;
       a.up();&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Tipos de semáforos ===&lt;br /&gt;
&lt;br /&gt;
Dependiendo de la función que cumple el semáforo, vamos a diferenciar los siguientes tipos:&lt;br /&gt;
&lt;br /&gt;
* 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.&lt;br /&gt;
* Semáforo contador, permiten llevar la cuenta del número de unidades de recurso compartido disponible, que va desde 0 hasta N.&lt;br /&gt;
* 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.&lt;br /&gt;
&lt;br /&gt;
=== Ventajas e inconvenientes ===&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
Los inconvenientes asociados al uso de semáforos son los siguientes:&lt;br /&gt;
&lt;br /&gt;
* Los programadores tienden a usarlos incorrectamente, de manera que no resuelven de manera adecuada el problema de concurrencia o dan lugar a interbloqueos.&lt;br /&gt;
* No hay nada que obligue a los programadores a usarlos.&lt;br /&gt;
* Los compiladores no ofrecen ningún mecanismo de comprobación sobre el correcto uso de los semáforos.&lt;br /&gt;
* Son independientes del recurso compartido al que se asocian.&lt;br /&gt;
&lt;br /&gt;
Debido a estos inconvenientes, se desarrollaron los [[Monitores|monitores]].&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mecanismos_de_sincronizaci%C3%B3n&amp;diff=1976</id>
		<title>Mecanismos de sincronización</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Mecanismos_de_sincronizaci%C3%B3n&amp;diff=1976"/>
				<updated>2011-12-01T09:03:57Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Optimistas */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Optimistas =&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
El siguiente ejemplo muestra el código ejecutado por dos hilos: h&amp;lt;sub&amp;gt;x&amp;lt;/sub&amp;gt; y h&amp;lt;sub&amp;gt;y&amp;lt;/sub&amp;gt; de un mismo proceso.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int tabla[3] = { 100, 101, 102 };  /* tabla compartida por ambos hilos hx y hy. */&lt;br /&gt;
&lt;br /&gt;
/* actividad del hilo */&lt;br /&gt;
void *actividad_hilo(void *ptr)&lt;br /&gt;
{&lt;br /&gt;
        int i;&lt;br /&gt;
&lt;br /&gt;
        while(1) {&lt;br /&gt;
            for (i=0; i&amp;lt;3; i++) {&lt;br /&gt;
                  actualiza_tabla(i);&lt;br /&gt;
                  sleep((random() % 10) + 1);    /* hilo pasa a estado bloqueado durante 1 a 10 segundos. */&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
        return NULL;&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
int main(void)&lt;br /&gt;
{&lt;br /&gt;
        pthread_t hilo1, hilo2;&lt;br /&gt;
&lt;br /&gt;
        pthread_create(&amp;amp;hilo1, NULL, actividad_hilo, NULL);  /* creación hilo&amp;lt;sub&amp;gt;x&amp;lt;/sub&amp;gt;. */&lt;br /&gt;
        pthread_create(&amp;amp;hilo2, NULL, actividad_hilo, NULL);  /* creación hilo&amp;lt;sub&amp;gt;y&amp;lt;/sub&amp;gt;. */&lt;br /&gt;
        pthread_join(hilo1, NULL);&lt;br /&gt;
        pthread_join(hilo2, NULL);&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
void actualiza_tabla(int i) {&lt;br /&gt;
        int tmp;&lt;br /&gt;
retry:&lt;br /&gt;
        tmp = tabla[i];            /* almaceno el valor de la variable compartida en una temporal. */&lt;br /&gt;
        tmp++;                     /* actualizo la varible temporal. */&lt;br /&gt;
        if (tabla[i]+1 != tmp) {   /* compruebo si la variable compartida ha sido modificada */&lt;br /&gt;
            goto retry;            /* mientras operaba con la variable temporal. */&lt;br /&gt;
        }&lt;br /&gt;
        tabla[i]=tmp;&lt;br /&gt;
}&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Los inconvenientes de este tipo de mecanismo son dos:&lt;br /&gt;
&lt;br /&gt;
* Se consume más memoria, pues hay que realizar una copia del recurso compartido para efectuar la actualización.&lt;br /&gt;
* En situaciones de coincidencia, se tiene que volver a realizar la operación, por tanto, se desperdician recursos de procesamiento.&lt;br /&gt;
&lt;br /&gt;
En base al ejemplo anterior, hay que garantizar que la operación de comprobación y actualización es '''atómica'''. Se dice que una operación es '''atómica''' cuando es indivisible, es decir, que no quedamos en una situación intermedia al ejecutar dicha operación.&lt;br /&gt;
&lt;br /&gt;
Como ventaja, este tipo de mecanismo nos ofrece un mayor grado de paralelismo, por tanto, una mayor tasa de transferencia, siempre que se emplee en una situación donde la frecuencia de concurrencia sea baja.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
= Pesimista =&lt;br /&gt;
Este mecanismo debe emplearse si se considera que la frecuencia de acceso al recurso compartido es alta.&lt;br /&gt;
&lt;br /&gt;
En este mecanismo disponemos de tres partes:&lt;br /&gt;
&lt;br /&gt;
* El protocolo de entrada, en el que se emplea un mecanismo que no permite continuar con la ejecución si otro u otros procesos están accediendo al recurso compartido.&lt;br /&gt;
* La sección crítica, en el que se se realizan las operaciones pertinentes con el recurso compartido.&lt;br /&gt;
* El protocolo de salida, en el que se vuelve a permitir el acceso al recurso compartido.&lt;br /&gt;
&lt;br /&gt;
El siguiente ejemplo muestra como se implementa el control de concurrencia pesimista para 2 hilos, h&amp;lt;sub&amp;gt;x&amp;lt;/sub&amp;gt; y h&amp;lt;sub&amp;gt;y&amp;lt;/sub&amp;gt;:&lt;br /&gt;
&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
   int compartida = 1;&lt;br /&gt;
   protocolo_de_entrada();     /* no permito acceso a variable compartida. */&lt;br /&gt;
   compartida++;               /* sección crítica: actualización de la variable compartida. */&lt;br /&gt;
   protocolo_de_salida();      /* vuelvo a permitir acceso a la variable compartida. */&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
Los protocolos de entrada y salida son, generalmente, operaciones costosas en términos de recursos de procesamiento pues requieren el uso de instrucciones atómicas cuyo tiempo de ejecución es alto.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
== Implementación del control de concurrencia pesimista ==&lt;br /&gt;
&lt;br /&gt;
El control de concurrencia pesimista se puede implementar de dos formas mediante:&lt;br /&gt;
&lt;br /&gt;
* 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, tiempo que está siendo desaprovechado por el procesador.&lt;br /&gt;
* Espera no ocupada o bloqueante, mediante '''semáforos''', '''monitores''' o '''mensajería'''. 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.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Concurrencia_de_procesos&amp;diff=1973</id>
		<title>Concurrencia de procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Concurrencia_de_procesos&amp;diff=1973"/>
				<updated>2011-11-30T09:27:57Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Sección crítica */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;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.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
 proceso A |--  --  --&lt;br /&gt;
           |&lt;br /&gt;
 proceso B |  --  --  --&lt;br /&gt;
           |_____________&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
= Formas de interacción entre procesos =&lt;br /&gt;
&lt;br /&gt;
Hay dos formas básicas de interacción entre los procesos:&lt;br /&gt;
&lt;br /&gt;
* '''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.&lt;br /&gt;
&lt;br /&gt;
* '''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.&lt;br /&gt;
&lt;br /&gt;
= Mecanismos de arbitraje =&lt;br /&gt;
&lt;br /&gt;
Los mecanismos de arbitraje que ofrece el sistema operativo son básicamente dos:&lt;br /&gt;
&lt;br /&gt;
* 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.&lt;br /&gt;
&lt;br /&gt;
* Mecanismos de '''mensajería''': el sistema operativo ofrece mecanismos de comunicación entre procesos mediante mensajes. El intercambio de mensajes entre procesos permite coordinarlos.&lt;br /&gt;
&lt;br /&gt;
= Programación concurrente = &lt;br /&gt;
&lt;br /&gt;
El término programación concurrente se emplea con frecuencia para referirse a un conjunto de programas que funcionan en cooperación.&lt;br /&gt;
&lt;br /&gt;
Hay tres formas de interacción entre procesos cooperativos:&lt;br /&gt;
&lt;br /&gt;
*Concurencia: 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.&lt;br /&gt;
&lt;br /&gt;
*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.&lt;br /&gt;
&lt;br /&gt;
*Comunicación:  El S.O. transmite mensajes entre los procesos, que se usan para intercambiar, enviar o recibir información.&lt;br /&gt;
&lt;br /&gt;
Se le llama programación concurrente ya que la concurrencia fue la primera forma de iterar recursos entre procesos cooperativos.&lt;br /&gt;
&lt;br /&gt;
= Sección crítica =&lt;br /&gt;
&lt;br /&gt;
La sección crítica es aquella zona donde un proceso está usando un recurso compartido.&lt;br /&gt;
&lt;br /&gt;
Para evitar interferencias en el uso de un recurso y con ello se produzcan resultados no deseados, se debe garantizar la exclusión mutua de procesos.&lt;br /&gt;
&lt;br /&gt;
Ésta exclusión de procesos, se debe realizar de forma coordinada y eficiente, para ello se requiere:&lt;br /&gt;
&lt;br /&gt;
*No más de un proceso por sección crítica y recurso compartido.&lt;br /&gt;
&lt;br /&gt;
*El mismo proceso no puede usar el mismo recurso compartido indefinidamente.&lt;br /&gt;
&lt;br /&gt;
*Todo proceso debe entrar antes o después a usar el recurso.&lt;br /&gt;
&lt;br /&gt;
*Si el recurso está sin uso, cualquiera que lo requiera dispondrá de él inmediatamente.&lt;br /&gt;
&lt;br /&gt;
*Si hay varios esperando usar el recurso y éste se libera, uno de los que estaba esperando lo usará durante un tiempo determinado.&lt;br /&gt;
&lt;br /&gt;
Para llevar ésto a cabo se necesita un protocolo que indique cuando el recurso está libre y cuando está siendo ocupado.&lt;br /&gt;
&lt;br /&gt;
= Tipos de mecanismos de sincronización =&lt;br /&gt;
&lt;br /&gt;
Los mecanismos de sincronización los podemos catalogar en dos categorías:&lt;br /&gt;
&lt;br /&gt;
*[[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.&lt;br /&gt;
&lt;br /&gt;
*[[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''.&lt;br /&gt;
&lt;br /&gt;
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.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Concurrencia_de_procesos&amp;diff=1962</id>
		<title>Concurrencia de procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Concurrencia_de_procesos&amp;diff=1962"/>
				<updated>2011-11-29T09:22:09Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Formas de interacción entre procesos */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;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.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
 proceso A |--  --  --&lt;br /&gt;
           |&lt;br /&gt;
 proceso B |  --  --  --&lt;br /&gt;
           |_____________&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
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.&lt;br /&gt;
&lt;br /&gt;
= Formas de interacción entre procesos =&lt;br /&gt;
&lt;br /&gt;
Hay dos formas básicas de interacción entre los procesos:&lt;br /&gt;
&lt;br /&gt;
* '''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.&lt;br /&gt;
&lt;br /&gt;
* '''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.&lt;br /&gt;
&lt;br /&gt;
= Mecanismos de arbitraje =&lt;br /&gt;
&lt;br /&gt;
Los mecanismos de arbitraje que ofrece el sistema operativo son básicamente dos:&lt;br /&gt;
&lt;br /&gt;
* 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.&lt;br /&gt;
&lt;br /&gt;
* Mecanismos de '''mensajería''': el sistema operativo ofrece mecanismos de comunicación entre procesos mediante mensajes. El intercambio de mensajes entre procesos permite coordinarlos.&lt;br /&gt;
&lt;br /&gt;
= Programación concurrente = &lt;br /&gt;
&lt;br /&gt;
El término programación concurrente se emplea con frecuencia para referirse a un conjunto de programas que funcionan en cooperación.&lt;br /&gt;
&lt;br /&gt;
Hay tres formas de interacción entre procesos cooperativos:&lt;br /&gt;
&lt;br /&gt;
*Concurencia: 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.&lt;br /&gt;
&lt;br /&gt;
*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.&lt;br /&gt;
&lt;br /&gt;
*Comunicación:  El S.O. transmite mensajes entre los procesos, que se usan para intercambiar, enviar o recibir información.&lt;br /&gt;
&lt;br /&gt;
Se le llama programación concurrente ya que la concurrencia fue la primera forma de iterar recursos entre procesos cooperativos.&lt;br /&gt;
&lt;br /&gt;
= Sección crítica =&lt;br /&gt;
&lt;br /&gt;
La sección crítica es aquella zona donde un proceso está usando un recurso compartido.&lt;br /&gt;
&lt;br /&gt;
Para evitar interferencias en el uso de un recurso y con ello se produzcan resultados no deseados, se debe garantizar la exclusión mutua de procesos.&lt;br /&gt;
&lt;br /&gt;
Ésta exclusión de procesos, se debe realizar de forma coordinada y eficiente, para ello se requiere:&lt;br /&gt;
&lt;br /&gt;
*No más de un proceso por sección crítica y recurso compartido.&lt;br /&gt;
&lt;br /&gt;
*El mismo proceso no puede usar el mismo recurso compartido indefinidamente.&lt;br /&gt;
&lt;br /&gt;
*Todo proceso debe entrar antes o después a usar el recurso.&lt;br /&gt;
&lt;br /&gt;
*Si el recurso está sin uso, cualquiera que lo requiera dispondrá de él inmediatamente.&lt;br /&gt;
&lt;br /&gt;
*Si hay varios esperando usar el recurso y éste se libera, uno de los que estaban esperando lo usarán durante un tiempo determinado.&lt;br /&gt;
&lt;br /&gt;
Para llevar ésto a cabo se necesita un protocolo que indique cuando el recurso está libre y cuando está siendo ocupado.&lt;br /&gt;
&lt;br /&gt;
= Tipos de mecanismos de sincronización =&lt;br /&gt;
&lt;br /&gt;
Los mecanismos de sincronización los podemos catalogar en dos categorías:&lt;br /&gt;
&lt;br /&gt;
*[[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.&lt;br /&gt;
&lt;br /&gt;
*[[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''.&lt;br /&gt;
&lt;br /&gt;
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.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1723</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1723"/>
				<updated>2011-11-09T09:56:30Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;                                      #1&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);    #2&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {                       #3&lt;br /&gt;
    write(fd, &amp;quot;%d&amp;quot;, sizeof(int));            #4&lt;br /&gt;
}&lt;br /&gt;
close(fd);                                   #5&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;                        #1&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {                       #2&lt;br /&gt;
    contador+=2;                             #3&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);  #4&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18&lt;br /&gt;
&lt;br /&gt;
#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 3]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1722</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1722"/>
				<updated>2011-11-09T09:54:50Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;                                      #1&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);    #2&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {                       #3&lt;br /&gt;
    write(fd, &amp;quot;%d&amp;quot;, sizeof(int));            #4&lt;br /&gt;
}&lt;br /&gt;
close(fd);                                   #5&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;    #1&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {    #2&lt;br /&gt;
    contador+=2;    #3&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);    #4&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18&lt;br /&gt;
&lt;br /&gt;
#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 3]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1721</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1721"/>
				<updated>2011-11-09T08:25:47Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;    #1&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);    #2&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {    #3&lt;br /&gt;
    write(fd, &amp;quot;%d&amp;quot;, sizeof(int));    #4&lt;br /&gt;
}&lt;br /&gt;
close(fd);    #5&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;    #1&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {    #2&lt;br /&gt;
    contador+=2;    #3&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);    #4&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18&lt;br /&gt;
&lt;br /&gt;
#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 3]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1720</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1720"/>
				<updated>2011-11-09T08:22:45Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;                                                                #1&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);    #2&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {                                           #3&lt;br /&gt;
    write(fd, &amp;quot;%d&amp;quot;, sizeof(int));                            #4&lt;br /&gt;
}&lt;br /&gt;
close(fd);                                                          #5&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;                                          #1&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {                                           #2&lt;br /&gt;
    contador+=2;                                                #3&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);       #4&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18&lt;br /&gt;
&lt;br /&gt;
#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 3]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1719</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1719"/>
				<updated>2011-11-09T08:14:02Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#1 int fd;&lt;br /&gt;
#2 fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
#3 for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
#4  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
      }&lt;br /&gt;
#5 close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
#1 int fd, contador = 0;&lt;br /&gt;
#2 for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
#3   contador+=2;&lt;br /&gt;
      }&lt;br /&gt;
#4 printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18&lt;br /&gt;
&lt;br /&gt;
#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 3]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1718</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1718"/>
				<updated>2011-11-09T08:10:32Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18&lt;br /&gt;
&lt;br /&gt;
#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer-planif-procesos-3|Ver solución del ejercicio 3]]&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1700</id>
		<title>Ejercicios planificación de procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1700"/>
				<updated>2011-11-08T16:15:05Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 5 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Ejercicio 1 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   1&lt;br /&gt;
 P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt;   3   6&lt;br /&gt;
 P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt;   4   2&lt;br /&gt;
&lt;br /&gt;
Realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
* Índice de penalización (no apropiativo)&lt;br /&gt;
[[sol-ejer1-planif-procesos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 2 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   6&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acceso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza temporal de ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* Turno rotatorio estricto, suponiendo que el quantum es de 2 unidades de tiempo.&lt;br /&gt;
* Por prioridades, suponiendo que A &amp;lt; B &amp;lt; C.&lt;br /&gt;
* Turno rotatorio proporcional al número de procesos, suponiendo que el quantum es de 2 unidades de tiempo. Si hay dos o más procesos el quantum pasa a ser de una unidad de tiempo.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer2-planif-procesos|Ver solución ejercicio 2]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 3 =&lt;br /&gt;
&lt;br /&gt;
En un planificador multinivel con realimentación se dispone de dos colas:&lt;br /&gt;
&lt;br /&gt;
* La primera cola tiene procesos que reciben un ''quantum'' de 4 unidades de tiempo.&lt;br /&gt;
* La segunda cola tiene procesos que reciben un ''quantum'' de 2 unidades de tiempo. Los procesos en esta cola reciben dos oportunidades de ejecución. Por tanto, se itera dos veces sobre esta cola antes de pasar a la primera cola.&lt;br /&gt;
&lt;br /&gt;
Los procesos que acaban de ser lanzados pasan inicialmente a la segunda cola. Si consumen completamente el ''quantum'' una vez, promocionan a la primera cola. Si dejan de consumir completamente el ''quantum'' una vez, descienden a la segunda.&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
     H0  t&lt;br /&gt;
 Pa   0  4&lt;br /&gt;
 Pb   1  4&lt;br /&gt;
 Pc   2  12&lt;br /&gt;
 Pd   3  12&lt;br /&gt;
&lt;br /&gt;
Suponga que los procesos A y B bloquean por operación de E/S tras 1 unidad de ejecución. Los procesos C y D no bloquean. Los tiempos de bloqueo por E/S son de 1 unidad de tiempo. Represente graficamente la evolución temporal de la asignación del procesador.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer3-planif-procesos|Ver solución ejercicio 3]]&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 4 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2010/11 del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#Turno rotatorio con compensacion con quantum de 2 unidades de tiempo.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
*En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un unico proceso, insertelo delante de este.&lt;br /&gt;
&lt;br /&gt;
*Si dos o mas procesos pasan de estado preparado a la vez, considere que el orden de insercion en la cola de preparados es el siguiente: 1ºA 2ºB 3ºC&lt;br /&gt;
&lt;br /&gt;
*Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo ( que en este ejercicio se trata de 2 unidades de tiempo)&lt;br /&gt;
&lt;br /&gt;
*En toda decisión del planificador tenga en cuenta a los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;br /&gt;
&lt;br /&gt;
''[[sol-ejer4-planif-procesos|Ver solución ejercicio 4]]''&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 5 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
#Turno rotatorio con compensación con ''quantum'' de 2 unidades de tiempo.&lt;br /&gt;
* En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un único proceso, insértelo delante de éste.&lt;br /&gt;
* Si dos o más procesos pasan a estado preparado a la vez, considere que el orden de inserción de preparados en la cola es el siguiente: 1º-A, 2º-B.&lt;br /&gt;
* Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo (que en este ejercicio se trata de 3 unidades de tiempo.&lt;br /&gt;
* En toda decisión del planificador tenga en cuenta los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1699</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1699"/>
				<updated>2011-11-08T16:14:44Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18&lt;br /&gt;
&lt;br /&gt;
#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1698</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1698"/>
				<updated>2011-11-08T16:14:30Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 3 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
'''#Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18'''&lt;br /&gt;
&lt;br /&gt;
'''#Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica'''&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1697</id>
		<title>Ejercicios otros aspectos de la planificación</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_otros_aspectos_de_la_planificaci%C3%B3n&amp;diff=1697"/>
				<updated>2011-11-08T16:13:52Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;== Ejercicio 1 ==&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0&lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1&lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2&lt;br /&gt;
| 1&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 3&lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 4&lt;br /&gt;
| 2&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Suponiendo un sistema operativo multiprocesador sobre dos procesadores, realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer1-otros-aspectos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 2 ==&lt;br /&gt;
''[Este ejercicio fue parte del primer Control de Evaluación Contínua del Curso 2010/11, del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#El siguiente, el más corto apropiativo en un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica. (''[[sol-ejer2-1-otros-aspectos|Ver solución]]'')&lt;br /&gt;
#Por prioridades apropiativo en tiempo real, suponiendo que C &amp;lt; B &amp;lt; A. No olvide los tiempos de bloqueo de los procesos A y B. (''[[sol-ejer2-2-otros-aspectos|Ver solución]]'')&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Plazo&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 6&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 15&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Ejercicio 3 ==&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
'''1 - Por prioridades apropiativo en tiempo real, suponiendo que B&amp;gt;A. No olvide los tiempos de bloqueo de los procesos A y B. Considere que los plazos de ejecucion de proceso A es 16 y de proceso B es 18'''&lt;br /&gt;
&lt;br /&gt;
'''2 - Suponiendo un sistema multiprocesador con dos procesadores. No olvide los tiempos de bloqueo de los procesos A y B. Considere asignación dinámica'''&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1696</id>
		<title>Ejercicios planificación de procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1696"/>
				<updated>2011-11-08T16:11:07Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 5 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Ejercicio 1 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   1&lt;br /&gt;
 P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt;   3   6&lt;br /&gt;
 P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt;   4   2&lt;br /&gt;
&lt;br /&gt;
Realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
* Índice de penalización (no apropiativo)&lt;br /&gt;
[[sol-ejer1-planif-procesos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 2 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   6&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acceso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza temporal de ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* Turno rotatorio estricto, suponiendo que el quantum es de 2 unidades de tiempo.&lt;br /&gt;
* Por prioridades, suponiendo que A &amp;lt; B &amp;lt; C.&lt;br /&gt;
* Turno rotatorio proporcional al número de procesos, suponiendo que el quantum es de 2 unidades de tiempo. Si hay dos o más procesos el quantum pasa a ser de una unidad de tiempo.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer2-planif-procesos|Ver solución ejercicio 2]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 3 =&lt;br /&gt;
&lt;br /&gt;
En un planificador multinivel con realimentación se dispone de dos colas:&lt;br /&gt;
&lt;br /&gt;
* La primera cola tiene procesos que reciben un ''quantum'' de 4 unidades de tiempo.&lt;br /&gt;
* La segunda cola tiene procesos que reciben un ''quantum'' de 2 unidades de tiempo. Los procesos en esta cola reciben dos oportunidades de ejecución. Por tanto, se itera dos veces sobre esta cola antes de pasar a la primera cola.&lt;br /&gt;
&lt;br /&gt;
Los procesos que acaban de ser lanzados pasan inicialmente a la segunda cola. Si consumen completamente el ''quantum'' una vez, promocionan a la primera cola. Si dejan de consumir completamente el ''quantum'' una vez, descienden a la segunda.&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
     H0  t&lt;br /&gt;
 Pa   0  4&lt;br /&gt;
 Pb   1  4&lt;br /&gt;
 Pc   2  12&lt;br /&gt;
 Pd   3  12&lt;br /&gt;
&lt;br /&gt;
Suponga que los procesos A y B bloquean por operación de E/S tras 1 unidad de ejecución. Los procesos C y D no bloquean. Los tiempos de bloqueo por E/S son de 1 unidad de tiempo. Represente graficamente la evolución temporal de la asignación del procesador.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer3-planif-procesos|Ver solución ejercicio 3]]&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 4 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2010/11 del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#Turno rotatorio con compensacion con quantum de 2 unidades de tiempo.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
*En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un unico proceso, insertelo delante de este.&lt;br /&gt;
&lt;br /&gt;
*Si dos o mas procesos pasan de estado preparado a la vez, considere que el orden de insercion en la cola de preparados es el siguiente: 1ºA 2ºB 3ºC&lt;br /&gt;
&lt;br /&gt;
*Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo ( que en este ejercicio se trata de 2 unidades de tiempo)&lt;br /&gt;
&lt;br /&gt;
*En toda decisión del planificador tenga en cuenta a los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;br /&gt;
&lt;br /&gt;
''[[sol-ejer4-planif-procesos|Ver solución ejercicio 4]]''&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 5 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
'''1 - Turno rotatorio con compensación con ''quantum'' de 2 unidades de tiempo.'''&lt;br /&gt;
* En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un único proceso, insértelo delante de éste.&lt;br /&gt;
* Si dos o más procesos pasan a estado preparado a la vez, considere que el orden de inserción de preparados en la cola es el siguiente: 1º-A, 2º-B.&lt;br /&gt;
* Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo (que en este ejercicio se trata de 3 unidades de tiempo.&lt;br /&gt;
* En toda decisión del planificador tenga en cuenta los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1695</id>
		<title>Ejercicios planificación de procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1695"/>
				<updated>2011-11-08T16:10:58Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 5 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Ejercicio 1 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   1&lt;br /&gt;
 P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt;   3   6&lt;br /&gt;
 P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt;   4   2&lt;br /&gt;
&lt;br /&gt;
Realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
* Índice de penalización (no apropiativo)&lt;br /&gt;
[[sol-ejer1-planif-procesos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 2 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   6&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acceso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza temporal de ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* Turno rotatorio estricto, suponiendo que el quantum es de 2 unidades de tiempo.&lt;br /&gt;
* Por prioridades, suponiendo que A &amp;lt; B &amp;lt; C.&lt;br /&gt;
* Turno rotatorio proporcional al número de procesos, suponiendo que el quantum es de 2 unidades de tiempo. Si hay dos o más procesos el quantum pasa a ser de una unidad de tiempo.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer2-planif-procesos|Ver solución ejercicio 2]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 3 =&lt;br /&gt;
&lt;br /&gt;
En un planificador multinivel con realimentación se dispone de dos colas:&lt;br /&gt;
&lt;br /&gt;
* La primera cola tiene procesos que reciben un ''quantum'' de 4 unidades de tiempo.&lt;br /&gt;
* La segunda cola tiene procesos que reciben un ''quantum'' de 2 unidades de tiempo. Los procesos en esta cola reciben dos oportunidades de ejecución. Por tanto, se itera dos veces sobre esta cola antes de pasar a la primera cola.&lt;br /&gt;
&lt;br /&gt;
Los procesos que acaban de ser lanzados pasan inicialmente a la segunda cola. Si consumen completamente el ''quantum'' una vez, promocionan a la primera cola. Si dejan de consumir completamente el ''quantum'' una vez, descienden a la segunda.&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
     H0  t&lt;br /&gt;
 Pa   0  4&lt;br /&gt;
 Pb   1  4&lt;br /&gt;
 Pc   2  12&lt;br /&gt;
 Pd   3  12&lt;br /&gt;
&lt;br /&gt;
Suponga que los procesos A y B bloquean por operación de E/S tras 1 unidad de ejecución. Los procesos C y D no bloquean. Los tiempos de bloqueo por E/S son de 1 unidad de tiempo. Represente graficamente la evolución temporal de la asignación del procesador.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer3-planif-procesos|Ver solución ejercicio 3]]&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 4 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2010/11 del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#Turno rotatorio con compensacion con quantum de 2 unidades de tiempo.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
*En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un unico proceso, insertelo delante de este.&lt;br /&gt;
&lt;br /&gt;
*Si dos o mas procesos pasan de estado preparado a la vez, considere que el orden de insercion en la cola de preparados es el siguiente: 1ºA 2ºB 3ºC&lt;br /&gt;
&lt;br /&gt;
*Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo ( que en este ejercicio se trata de 2 unidades de tiempo)&lt;br /&gt;
&lt;br /&gt;
*En toda decisión del planificador tenga en cuenta a los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;br /&gt;
&lt;br /&gt;
''[[sol-ejer4-planif-procesos|Ver solución ejercicio 4]]''&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 5 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
'''1 - Turno rotatorio con compensación con ''quantum'' de 2 unidades de tiempo.'''&lt;br /&gt;
* En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un único proceso, insértelo delante de éste.&lt;br /&gt;
* Si dos o más procesos pasan a estado preparado a la vez, considere que el orden de inserción de preparados en la cola es el siguiente: 1º-A, 2º-B.&lt;br /&gt;
* Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo (que en este ejercicio se trata de 3 unidades de tiempo.&lt;br /&gt;
* En toda decisión del planificador tenga en cuenta los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1694</id>
		<title>Ejercicios planificación de procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1694"/>
				<updated>2011-11-08T16:10:38Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 5 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Ejercicio 1 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   1&lt;br /&gt;
 P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt;   3   6&lt;br /&gt;
 P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt;   4   2&lt;br /&gt;
&lt;br /&gt;
Realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
* Índice de penalización (no apropiativo)&lt;br /&gt;
[[sol-ejer1-planif-procesos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 2 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   6&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acceso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza temporal de ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* Turno rotatorio estricto, suponiendo que el quantum es de 2 unidades de tiempo.&lt;br /&gt;
* Por prioridades, suponiendo que A &amp;lt; B &amp;lt; C.&lt;br /&gt;
* Turno rotatorio proporcional al número de procesos, suponiendo que el quantum es de 2 unidades de tiempo. Si hay dos o más procesos el quantum pasa a ser de una unidad de tiempo.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer2-planif-procesos|Ver solución ejercicio 2]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 3 =&lt;br /&gt;
&lt;br /&gt;
En un planificador multinivel con realimentación se dispone de dos colas:&lt;br /&gt;
&lt;br /&gt;
* La primera cola tiene procesos que reciben un ''quantum'' de 4 unidades de tiempo.&lt;br /&gt;
* La segunda cola tiene procesos que reciben un ''quantum'' de 2 unidades de tiempo. Los procesos en esta cola reciben dos oportunidades de ejecución. Por tanto, se itera dos veces sobre esta cola antes de pasar a la primera cola.&lt;br /&gt;
&lt;br /&gt;
Los procesos que acaban de ser lanzados pasan inicialmente a la segunda cola. Si consumen completamente el ''quantum'' una vez, promocionan a la primera cola. Si dejan de consumir completamente el ''quantum'' una vez, descienden a la segunda.&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
     H0  t&lt;br /&gt;
 Pa   0  4&lt;br /&gt;
 Pb   1  4&lt;br /&gt;
 Pc   2  12&lt;br /&gt;
 Pd   3  12&lt;br /&gt;
&lt;br /&gt;
Suponga que los procesos A y B bloquean por operación de E/S tras 1 unidad de ejecución. Los procesos C y D no bloquean. Los tiempos de bloqueo por E/S son de 1 unidad de tiempo. Represente graficamente la evolución temporal de la asignación del procesador.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer3-planif-procesos|Ver solución ejercicio 3]]&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 4 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2010/11 del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#Turno rotatorio con compensacion con quantum de 2 unidades de tiempo.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
*En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un unico proceso, insertelo delante de este.&lt;br /&gt;
&lt;br /&gt;
*Si dos o mas procesos pasan de estado preparado a la vez, considere que el orden de insercion en la cola de preparados es el siguiente: 1ºA 2ºB 3ºC&lt;br /&gt;
&lt;br /&gt;
*Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo ( que en este ejercicio se trata de 2 unidades de tiempo)&lt;br /&gt;
&lt;br /&gt;
*En toda decisión del planificador tenga en cuenta a los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;br /&gt;
&lt;br /&gt;
''[[sol-ejer4-planif-procesos|Ver solución ejercicio 4]]''&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 5 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
'''Turno rotatorio con compensación con ''quantum'' de 2 unidades de tiempo.'''&lt;br /&gt;
* En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un único proceso, insértelo delante de éste.&lt;br /&gt;
* Si dos o más procesos pasan a estado preparado a la vez, considere que el orden de inserción de preparados en la cola es el siguiente: 1º-A, 2º-B.&lt;br /&gt;
* Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo (que en este ejercicio se trata de 3 unidades de tiempo.&lt;br /&gt;
* En toda decisión del planificador tenga en cuenta los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	<entry>
		<id>https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1693</id>
		<title>Ejercicios planificación de procesos</title>
		<link rel="alternate" type="text/html" href="https://1984.lsi.us.es/wiki-ssoo/index.php?title=Ejercicios_planificaci%C3%B3n_de_procesos&amp;diff=1693"/>
				<updated>2011-11-08T16:10:21Z</updated>
		
		<summary type="html">&lt;p&gt;Lorruimor: /* Ejercicio 5 */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;= Ejercicio 1 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   1&lt;br /&gt;
 P&amp;lt;sub&amp;gt;D&amp;lt;/sub&amp;gt;   3   6&lt;br /&gt;
 P&amp;lt;sub&amp;gt;E&amp;lt;/sub&amp;gt;   4   2&lt;br /&gt;
&lt;br /&gt;
Realice la traza de la ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* FIFO (no apropiativo)&lt;br /&gt;
* SJF (apropiativo y no apropiativo)&lt;br /&gt;
* Índice de penalización (no apropiativo)&lt;br /&gt;
[[sol-ejer1-planif-procesos|Ver solución ejercicio 1]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 2 =&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
      H0  t&lt;br /&gt;
 P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt;   0   3&lt;br /&gt;
 P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt;   1   5&lt;br /&gt;
 P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt;   2   6&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea por operación de E/S&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acceso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza temporal de ejecución de dichos procesos para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
* Turno rotatorio estricto, suponiendo que el quantum es de 2 unidades de tiempo.&lt;br /&gt;
* Por prioridades, suponiendo que A &amp;lt; B &amp;lt; C.&lt;br /&gt;
* Turno rotatorio proporcional al número de procesos, suponiendo que el quantum es de 2 unidades de tiempo. Si hay dos o más procesos el quantum pasa a ser de una unidad de tiempo.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer2-planif-procesos|Ver solución ejercicio 2]]&lt;br /&gt;
&lt;br /&gt;
= Ejercicio 3 =&lt;br /&gt;
&lt;br /&gt;
En un planificador multinivel con realimentación se dispone de dos colas:&lt;br /&gt;
&lt;br /&gt;
* La primera cola tiene procesos que reciben un ''quantum'' de 4 unidades de tiempo.&lt;br /&gt;
* La segunda cola tiene procesos que reciben un ''quantum'' de 2 unidades de tiempo. Los procesos en esta cola reciben dos oportunidades de ejecución. Por tanto, se itera dos veces sobre esta cola antes de pasar a la primera cola.&lt;br /&gt;
&lt;br /&gt;
Los procesos que acaban de ser lanzados pasan inicialmente a la segunda cola. Si consumen completamente el ''quantum'' una vez, promocionan a la primera cola. Si dejan de consumir completamente el ''quantum'' una vez, descienden a la segunda.&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuración de procesos:&lt;br /&gt;
&lt;br /&gt;
     H0  t&lt;br /&gt;
 Pa   0  4&lt;br /&gt;
 Pb   1  4&lt;br /&gt;
 Pc   2  12&lt;br /&gt;
 Pd   3  12&lt;br /&gt;
&lt;br /&gt;
Suponga que los procesos A y B bloquean por operación de E/S tras 1 unidad de ejecución. Los procesos C y D no bloquean. Los tiempos de bloqueo por E/S son de 1 unidad de tiempo. Represente graficamente la evolución temporal de la asignación del procesador.&lt;br /&gt;
&lt;br /&gt;
[[sol-ejer3-planif-procesos|Ver solución ejercicio 3]]&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 4 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2010/11 del 23 de marzo de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dada la siguiente configuracion de procesos:&lt;br /&gt;
&lt;br /&gt;
{| border=&amp;quot;2&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;0&amp;quot; style=&amp;quot;margin: 1em 1em 1em 0; background: #f9f9f9; border: 1px #aaa solid; border-collapse: collapse; font-size: 95%;&amp;quot;&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | Proceso&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | H&amp;lt;sub&amp;gt;0&lt;br /&gt;
! width=&amp;quot;50&amp;quot; style=&amp;quot;background:#efefef;&amp;quot; | t&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;A&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 0 &lt;br /&gt;
| 3&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;B&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 1 &lt;br /&gt;
| 5&lt;br /&gt;
|-&lt;br /&gt;
| P&amp;lt;sub&amp;gt;C&amp;lt;/sub&amp;gt; &lt;br /&gt;
| 2 &lt;br /&gt;
| 6&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
Teniendo en cuenta el siguiente comportamiento:&lt;br /&gt;
&lt;br /&gt;
* El proceso A cada 1 unidad de tiempo de ejecución bloquea .&lt;br /&gt;
* El proceso B cada 3 unidades de tiempo de ejecución bloquea.&lt;br /&gt;
&lt;br /&gt;
Suponga que el tiempo de bloqueo de todos los procesos es de 2 unidades de tiempo debido al tiempo de acesso al dispositivo de E/S.&lt;br /&gt;
&lt;br /&gt;
Realice la traza de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación: &lt;br /&gt;
&lt;br /&gt;
#Turno rotatorio con compensacion con quantum de 2 unidades de tiempo.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
*En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un unico proceso, insertelo delante de este.&lt;br /&gt;
&lt;br /&gt;
*Si dos o mas procesos pasan de estado preparado a la vez, considere que el orden de insercion en la cola de preparados es el siguiente: 1ºA 2ºB 3ºC&lt;br /&gt;
&lt;br /&gt;
*Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo ( que en este ejercicio se trata de 2 unidades de tiempo)&lt;br /&gt;
&lt;br /&gt;
*En toda decisión del planificador tenga en cuenta a los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;br /&gt;
&lt;br /&gt;
''[[sol-ejer4-planif-procesos|Ver solución ejercicio 4]]''&lt;br /&gt;
&lt;br /&gt;
=Ejercicio 5 =&lt;br /&gt;
''[Este ejercicio formó parte del Primer Parcial de Evaluación Contínua del curso 2011/12 del 8 de Noviembre de 2011]''&lt;br /&gt;
&lt;br /&gt;
Dado el código de los siguientes procesos:&lt;br /&gt;
&lt;br /&gt;
'''Código proceso A:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd;&lt;br /&gt;
fd = open(&amp;quot;fichero.txt&amp;quot;, O_WRONLY, 0600);&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  write(fd, &amp;quot;%d&amp;quot;, sizeof(int));&lt;br /&gt;
}&lt;br /&gt;
close(fd);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
'''Código proceso B:'''&lt;br /&gt;
&amp;lt;source lang=&amp;quot;c&amp;quot;&amp;gt;&lt;br /&gt;
int fd, contador = 0;&lt;br /&gt;
for(int i=0;i&amp;lt;2;i++) {&lt;br /&gt;
  contador+=2;&lt;br /&gt;
}&lt;br /&gt;
printf(&amp;quot;el contador vale: %d\n&amp;quot;, contador);&lt;br /&gt;
&amp;lt;/source&amp;gt;&lt;br /&gt;
&lt;br /&gt;
De manera teórica, suponga que la ejecución de cada línea de código toma una unidad de tiempo. Considere que las llamadas '''write''' y '''printf''' son bloqueantes puesto que suponen accesos a dispositivos de E/S, siendo los tiempos de bloqueo de 3 unidades de tiempo. Suponga que ambos procesos se lanzan a la vez, pero el planificador da paso en primer lugar al proceso A.&lt;br /&gt;
&lt;br /&gt;
Realize la traza temporal de ejecución de dichos procesos y los índices de penalización para los siguientes criterios de planificación:&lt;br /&gt;
&lt;br /&gt;
'''Turno rotatorio con compensación con ''quantum'' de 2 unidades de tiempo.'''&lt;br /&gt;
   * En caso de que un proceso haya consumido el 50% de su quantum y en la cola de procesos preparados haya un único proceso, insértelo delante de éste.&lt;br /&gt;
   * Si dos o más procesos pasan a estado preparado a la vez, considere que el orden de inserción de preparados en la cola es el siguiente: 1º-A, 2º-B.&lt;br /&gt;
   * Recuerde que un proceso en estado bloqueado se inserta en la cola de preparados una vez que pasa el tiempo de bloqueo (que en este ejercicio se trata de 3 unidades de tiempo.&lt;br /&gt;
   * En toda decisión del planificador tenga en cuenta los procesos que justo acaban de pasar a estado preparado tras un bloqueo.&lt;/div&gt;</summary>
		<author><name>Lorruimor</name></author>	</entry>

	</feed>