Wiki de Sistemas Operativos - Contribuciones del usuario [es]

Página con listado de personas que han contribuido

2012-01-29T15:12:06Z

Tomvelber:

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:

* luigarhor
* rafperper
* sergaralo
* josalgrod1
* felgaroje
* luimunlei
* [https://1984.lsi.us.es/wiki-ssoo/index.php/Usuario:Lorruimor Lorruimor]
* albsolnog
* framorexp
* javgarang
* FerGuaTol
* jesgonbel
* fraperdom
* antdomflo
* antmorzam
* migoligon
* danplaseg
* peducemar
* danescsan
* sertrimur
* juamenmor
* tomvelber

Monitores

2011-11-16T18:27:52Z

Tomvelber: /* Ejemplo de uso de un Monitor */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

public int get(void);
public void set(int valor);
private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret;
down(s);
ret = recursoCompartido;
up(s);
return ret;
}

public void set(int valor){
down(s);
recursoCompartido = valor;
up(s);
}
}

</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

== Ejemplo de uso de un Monitor ==

Dado recurso compartido de ejemplo :

* RecursoCompartido r = new RecursoCompartido();

Y dados los dos hilos de ejemplo siguientes:

*Lector (h1):
<source lang="java">
int valor;
while(1){ //1
valor=r.get(); //2
print(valor); //3

}

</source>

*Escritor (h2):
<source lang="java">
int i=0;
while(1){ //1
r.set(); //2
i++; //3

}

</source>

Su traza sería:

Datos del problema: - R.R estricto, con q=4
- El h1 pasa a activo en primer lugar.

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.
* = el proceso bloquea.

recurso procesador
| 1 |2.1|2.2|2.4|---|---|2.4|2.5| 3 | 1 |---|
h1 <xxx|xxx|xxx|xxx|---|---|xxx|xxx|xxx|xxx|---|
|---|---|---|---| 1 |2.1|---|---|---|---|---|
h2 |---|---|---|---<xxx|xxx*---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11

Nota: Los números de la parte superior a las x, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren al número de instrucción qué internamente se ejecutan en el get() y set()
del monitor.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

== Fuentes ==
<references/>

Monitores

2011-11-16T18:17:26Z

Tomvelber: /* Definición */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

public int get(void);
public void set(int valor);
private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret;
down(s);
ret = recursoCompartido;
up(s);
return ret;
}

public void set(int valor){
down(s);
recursoCompartido = valor;
up(s);
}
}

</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

== Ejemplo de uso de un Monitor ==

Dado recurso compartido de ejemplo (expresado en pseudocódigo cercano a Java):

* RecursoCompartido r = new RecursoCompartido();

Y dados los dos hilos de ejemplo siguiente:

*Lector (h1):
<source lang="java">
int valor;
while(1){ //1
valor=r.get(); //2
print(valor); //3

}

</source>

*Escritor (h2):
<source lang="java">
int i=0;
while(1){ //1
r.set(); //2
i++; //3

}

</source>

Su traza sería:

Datos del problema: - R.R estricto, con q=4
- El h1 pasa a activo en primer lugar.

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.
* = el proceso bloquea.

recurso procesador
| 1 |2.1|2.2|2.4|---|---|2.4|2.5| 3 | 1 |---|
h1 <xxx|xxx|xxx|xxx|---|---|xxx|xxx|xxx|xxx|---|
|---|---|---|---| 1 |2.1|---|---|---|---|---|
h2 |---|---|---|---<xxx|xxx*---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11

Nota: Los números de la parte superior a las x, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren al número de instrucción qué internamente se ejecutan en el get() y set()
del monitor.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

== Fuentes ==
<references/>

Monitores

2011-11-16T17:58:03Z

Tomvelber: /* Definición */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

public int get(void);
public void set(int valor);
private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret;
down(s);
ret = recursoCompartido;
up(s);
return ret;
}

public void set(int valor){
down(s);
recursoCompartido = valor;
up(s);
}
}

</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

Ejemplo de la traza de un monitor, dados los dos hilos de ejemplo siguientes :

*Lector (h1):
<source lang="java">
int valor;
while(1){ //1
valor=r.get(); //2
print(valor); //3

}

</source>

*Escritor (h2):
<source lang="java">
int i=0;
while(1){ //1
r.set(); //2
i++; //3

}

</source>
Su traza sería:

Datos del problema: - R.R estricto, con q=4
- El h1 pasa a activo en primer lugar.

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.
* = el proceso bloquea.

recurso procesador
| 1 |2.1|2.2|2.4|---|---|2.4|2.5| 3 | 1 |---|
h1 <xxx|xxx|xxx|xxx|---|---|xxx|xxx|xxx|xxx|---|
|---|---|---|---| 1 |2.1|---|---|---|---|---|
h2 |---|---|---|---<xxx|xxx*---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11

Nota: Los números de la parte superior a las x, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren al número de instrucción qué internamente se ejecutan en el get() y set()
del monitor.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

== Fuentes ==
<references/>

Monitores

2011-11-16T17:49:36Z

Tomvelber: /* Definición */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

public int get(void);
public void set(int valor);
private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret;
down(s);
ret = recursoCompartido;
up(s);
return ret;
}

public void set(int valor){
down(s);
recursoCompartido = valor;
up(s);
}
}

</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

Ejemplo de la traza de un monitor, dados los dos hilos de ejemplo siguientes :

*Lector (h1):
<source lang="java">
int valor;
while(1){ //1
valor=r.get(); //2
print(valor); //3

}

</source>

*Escritor (h2):
<source lang="java">
int i=0;
while(1){ //1
r.set(); //2
i++; //3

}

</source>
Su traza sería:

Datos del problema: R.R estricto, con q=4

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.

recurso procesador
| 1 |2.1|2.2|2.4|---|---|2.4|2.5| 3 | 1 |---|
h1 <xxx|xxx|xxx|xxx|---|---|xxx|xxx|xxx|xxx|---|
|---|---|---|---| 1 |2.1|---|---|---|---|---|
h2 |---<---|---|---|xxx|xxx|---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11

Nota: Los números de la parte superior a las x, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren al número de instrucción qué internamente se ejecutan en el get() y set()
del monitor.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

== Fuentes ==
<references/>

Monitores

2011-11-16T17:48:55Z

Tomvelber: /* Definición */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

public int get(void);
public void set(int valor);
private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret;
down(s);
ret = recursoCompartido;
up(s);
return ret;
}

public void set(int valor){
down(s);
recursoCompartido = valor;
up(s);
}
}

</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

Ejemplo de la traza de un monitor, dados los dos hilos de ejemplo siguientes :

*Lector (h1):
<source lang="java">
int valor;
while(1){ //1
valor=r.get(); //2
print(valor); //3

}

</source>

*Escritor (h2):
<source lang="java">
int i=0;
while(1){ //1
r.set(); //2
i++; //3

}

</source>
Su traza sería:

Datos del problema: R.R estricto, con q=4

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.

recurso procesador
| 1 |2.1|2.2|2.4|---|---|2.4|2.5| 3 | 1 |---|
Pa <xxx|xxx|xxx|xxx|---|---|xxx|xxx|xxx|xxx|---|
|---|---|---|---| 1 |2.1|---|---|---|---|---|
Pb |---<---|---|---|xxx|xxx|---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11

Nota: Los números de la parte superior a las x, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren al número de instrucción qué internamente se ejecutan en el get() y set()
del monitor.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

== Fuentes ==
<references/>

Monitores

2011-11-16T17:46:47Z

Tomvelber: /* Definición */

Idea desarrollada en los años 70 Brinch-Hansen y Hoare <ref>http://java.sun.com/developer/Books/performance2/chap4.pdf</ref>que notaron los siguientes problemas con respecto al uso de los semáforos:

* Los semáforos son difíciles de usar. Es frecuente que el programador cometa errores al emplearlos.
* El compilador no asiste al programador en el desarrollo de programas concurrentes mediante semáforos, pues no ofrece ningún tipo de validación en tiempo de compilación.
* No hay nada que obligue a usarlos. Puede suceder que el programador los necesite y lo desconozca
* Son independientes del recurso compartido

Los monitores tienen que estar integrados en el lenguaje de programación.

== Definición ==
Un monitor es una estructura del lenguaje cuyas principales características son:

* Los datos son privados.
* Ofrecen una serie de métodos públicos para acceder a dichos datos.
* En cada momento sólo puede haber un proceso activo en algún método del monitor, es decir, ejecutando código de esos métodos públicos del monitor. Seria equivalente a decir que el recurso que queremos compartir se declara como monitor. Los procesos que usan el monitor son independientes unos de otros y cuando deseen usar el recurso, llamarán a los métodos del monitor que implementen la operación que se desea ejecutar.

Permiten organizar procesos en espera mediante:

* Variables de condición: lista de procesos inicialmente vacía.
* Primitivas: ''wait(c)'', añade el proceso p invocante a c y proceso p bloquea; ''signal(c)'', selecciona a uno de los procesos en c y lo pone en preparado.

<source lang="java">

class recursoCompartido {

public int get(void);
public void set(int valor);
private int recursoCompartido;
private Semaforo s = 1;

public int get(void){
int ret;
down(s);
ret = recursoCompartido;
up(s);
return ret;
}

public void set(int valor){
down(s);
recursoCompartido = valor;
up(s);
}
}

</source>

Como vemos, los monitores se implementan con semáforos, son una abstracción de los mismos.

Ejemplo de la traza de un monitor, dados los dos hilos de ejemplo siguientes :

*Lector (h1):
<source lang="java">
int valor;
while(1){ //1
valor=r.get(); //2
print(valor); //3

}

</source>

*Escritor (h2):
<source lang="java">
int i=0;
while(1){ //1
r.set(); //2
i++; //3

}

</source>
Su traza sería:

Datos del problema: R.R estricto, con q=4

< = lanzamiento del proceso
> = finalización del proceso
x = indica que el proceso está asignado al procesador en ese momento.

recurso procesador
| 1 |2.1|2.2|2.4|---|---|2.4|2.5| 3 | 1 |---|
Pa <xxx|xxx|xxx|xxx|---|---|xxx|xxx|xxx|xxx|---|
|---|---|---|---| 1 |2.1|---|---|---|---|---|
Pb |---<---|---|---|xxx|xxx|---|---|---|---|---|
-----|---|---|---|---|---|---|---|---|---|---|---> t
0 1 2 3 4 5 6 7 8 9 10 11

Nota: Los números de la parte superior a las x, indican el número de instrucción que
se está ejecutando en dicho momento. En el caso de los 2.1, 2.2 y sucesivos se
refieren a número de instrucción que internamente se ejecutan en el get() y set()
del monitor.

En la página de [https://1984.lsi.us.es/wiki-ssoo/index.php/Discusi%C3%B3n:Monitores discusión] hay un ejemplo en java.

== Fuentes ==
<references/>