Mostrando entradas con la etiqueta Sistemas Operativos. Mostrar todas las entradas
Mostrando entradas con la etiqueta Sistemas Operativos. Mostrar todas las entradas

Llamado: (Algoritmo de Dijkstra)

Este algoritmo se usa para evitar interbloqueos en el sistema, básicamente procede de la siguiente manera: cada proceso declara el máximo de recursos a utilizar y cada vez que se hace una solicitud de asignación de recursos, se determina si al asignar los recursos se deja en un estado inseguro y de ser así se pospone la asignación, de lo contrario, se asignan los recursos solicitados.

Asignación

Se determina si hay disponiboles
Se valida que no exceda su máximo declarado
Se verifica que si se concede la petición, el sistema quede en estado seguro
Si no se cumple cualquiera de estas condiciones, el proceso queda suspendido hasta que exista una liberación de recursos.

Desventajas

Se necesita saber desde un principio el máximo de recursos que usará cada proceso
Este proceso implica un retardo en cada asignación de recursos, lo que puede degradar el sistema si se manejan muchos recursos y/o procesos
Se requiere una garantía de devolución: c/proceso liberará los recursos asignados


proceso\recursoR1 (7)R2(7)R3(7)
MaximosP1531
P2323
P3231
P4503
AsignadosP1331
P2222
P3011
P4001
NecesariosP1200
P2101
P3220
P4502
Disponibles212

La terminal es muy sencilla y a la vez sumamente poderosa, te permite interactuar con el sistema operativo sin necesidad de una interfaz gráfica ¿no es acaso maravillosa?

Si bien las distribuciones Linux hacen cada vez más completas y funcionales sus GUI (del inglés graphical user interface), la terminal siempre ha estado y estará allí para ayudarte y no lo contrario, como quizá hayas pensado. De hecho, en algunas distribuciones es el primer contacto entre el usuario y el sistema.

¿Cuando instalaste Linux por primera vez imaginaste que podrías administrar todo tu sistema desde una simple línea de comandos?. Si comienzas a usar la terminal con regularidad, no solo le perderás el miedo, sino que notaras que es una potente herramienta que permite mantener y en algunos casos hasta salvar tu instalación de esos indeseables problemas que ocurren justo después de una gran actualización del sistema, por solo nombrar un ejemplo.

Anteriormente les habíamos hablado de algunos comandos básicos, a continuación te presentamos 10 más para que sigas aprendiendo sobre las bondades de la terminal en Linux.

Cat


Cat (de concatenar), es una maravillosa utilidad que nos permite visualizar el contenido de un archivo de texto sin la necesidad de un editor. Para utilizarlo solo debemos mencionarlo junto al archivo que deseamos visualizar:

$ cat prueba.txt

Ls


Ls (de listar), permite listar el contenido de un directorio o fichero. La sintaxis es:

$ ls /home/directorio


El comando ls tiene varias opciones que permiten organizar la salida, lo que resulta particularmente útil cuando es muy grande. Por ejemplo, puedes usar -a para mostrar los archivos ocultos y -l para mostrar los usuarios, permisos y la fecha de los archivos. Así como para todos los comandos Linux, estas opciones pueden combinarse, terminando en algo como:

$ ls -la /home/directorio

Cd


Cd (de change directory o cambiar directorio), es como su nombre lo indica el comando que necesitarás para acceder a una ruta distinta de la que te encuentras. Por ejemplo, si estas en el directorio /home y deseas acceder a /home/ejercicios, seria:

$ cd /home/ejercicios


Si estás en /home/ejercicios y deseas subir un nivel (es decir ir al directorio /home), ejecutas:

$ cd ..

Touch


Touch crea un archivo vacío, si el archivo existe actualiza la hora de modificación. Para crear el archivo prueba1.txt en /home, seria:

$ touch /home/prueba1.txt

Mkdir


Mkdir (de make directory o crear directorio), crea un directorio nuevo tomando en cuenta la ubicación actual. Por ejemplo, si estas en /home y deseas crear el directorio ejercicios, sería:

$ mkdir /home/ejercicios


Mkdir tiene una opción bastante útil que permite crear un árbol de directorios completo que no existe. Para eso usamos la opción -p:

$ mkdir -p /home/ejercicios/prueba/uno/dos/tres

Cp


Cp (de copy o copiar), copia un archivo o directorio origen a un archivo o directorio destino. Por ejemplo, para copiar el archivo prueba.txt ubicado en /home a un directorio de respaldo, podemos usar:

$ cp /home/prueba.txt /home/respaldo/prueba.txt


En la sintaxis siempre se especifica primero el origen y luego el destino. Si indicamos un nombre de destino diferente, cp copiará el archivo o directorio con el nuevo nombre.

El comando también cuenta con la opción -r que copia no sólo el directorio especificado sino todos sus directorios internos de forma recursiva. Suponiendo que deseamos hacer una copia del directorio /home/ejercicios que a su vez tiene las carpetas ejercicio1 y ejercicio2 en su interior, en lugar de ejecutar un comando para cada carpeta, ejecutamos:

$ cp -r /home/ejercicios /home/respaldos/

Mv


Mv (de move o mover), mueve un archivo a una ruta específica, y a diferencia de cp, lo elimina del origen finalizada la operación. Por ejemplo:

$ mv /home/prueba.txt /home/respaldos/prueba2.txt


Al igual que cp, en la sintaxis se especifica primero el origen y luego el destino. Si indicamos un nombre de destino diferente, mv moverá el archivo o directorio con el nuevo nombre.

Rm


Rm (de remove o remover), es el comando necesario para borrar un archivo o directorio. Para borrar el archivo prueba.txt ubicado en /home, ejecutamos:

$ rm /home/prueba.txt


Este comando también presenta varias opciones. La opción -r borra todos los archivos y directorios de forma recursiva. Por otra parte, -f borra todo sin pedir confirmación. Estas opciones pueden combinarse causando un borrado recursivo y sin confirmación del directorio que se especifique. Para realizar esto en el directorio respaldos ubicado en el /home, usamos:

$ rm -fr /home/respaldos


Este comando es muy peligroso, por lo tanto es importante que nos documentemos bien acerca de los efectos de estas opciones en nuestro sistema para así evitar consecuencias nefastas.

Pwd


Pwd (de print working directory o imprimir directorio de trabajo), es un conveniente comando que imprime nuestra ruta o ubicación al momento de ejecutarlo, así evitamos perdernos si estamos trabajando con múltiples directorios y carpetas. Su sintaxis seria:

$ pwd

Clear


Clear (de limpiar), es un sencillo comando que limpiara nuestra terminal por completo dejándola como recién abierta. Para ello ejecutamos:

$ clear
Round-robin es un método para seleccionar todos los elementos en un grupo de manera equitativa y en un orden racional, normalmente comenzando por el primer elemento de la lista hasta llegar al último y empezando de nuevo desde el primer elemento. El nombre del algoritmo viene del principio de Round-Robin conocido de otros campos, donde cada persona toma una parte de un algo compartido en cantidades parejas.

Una forma sencilla de entender el Round-robin es imaginar una secuencia para "tomar turnos". En operaciones computacionales, un método para ejecutar diferentes procesos de manera concurrente, para la utilización equitativa de los recursos del equipo, es limitando cada proceso a un pequeño período (quantum), y luego suspendiendo este proceso para dar oportunidad a otro proceso y así sucesivamente. A esto se le denomina comúnmente como Planificación Round-Robin.

Aplicación circular

Round-robin es un algoritmo de planificación de procesos simple de implementar, dentro de un sistema operativo se asigna a cada proceso una porción de tiempo equitativa y ordenada, tratando a todos los procesos con la misma prioridad. En Sistemas operativos, la planificación Round-robin da un tiempo máximo de uso de CPU a cada proceso, pasado el cual es desalojado y retornado al estado de listo, la lista de procesos se planifica por FIFO, del inglés "First In, First Out" (primero en entrar, primero en salir o primero llegado, primero atendido).

Pasos de ciclos

Para averiguar los pasos de ciclos de procesos totales se toman todos los números de procesos y se calculan con los procesos necesarios para la realización de estos...

Suponga que hay tres procesos y se desea averiguar cuanto tarda.

proceso A: 3 veces
proceso B: 4 veces
proceso C: 5 veces
siguiendo tp = tProceso + [(tProceso ultimo - tProceso) - (tProceso ultimo - tProceso proximo)] + tProceso \!

Planificación circular

Este algoritmo de planificación, conocido por Round robin, está diseñado especialmente para sistemas de tiempo compartido. Se define un intervalo de tiempo denominado "Quantum", cuya duración varía según el sistema. La cola de procesos se estructura como una cola circular. El planificador la recorre asignando un cuanto de tiempo a cada proceso. La organización de la cola es FIFO. El Quantum se suele implantar mediante un temporizador que genera una interrupción cuando se agota el Quantum de tiempo. Si el proceso agota su ráfaga de CPU antes de finalizar el Quantum, el planificador asigna la CPU inmediatamente a otro proceso. Este algoritmo tiene un tiempo de espera relativamente grande. Sin embargo, garantiza un reparto de la CPU entre todos los usuarios y arroja tiempos de respuesta buenos. Como ejemplo, supongamos los siguientes tres procesos en un instante en el sistema: Proceso Duración de la ráfaga tw P1 24 6 P2 3 4 P3 3 7

¯tw = 5,66: Tiempos de proceso y de espera según la planificación RR.
Vemos que el tiempo de espera podría ser inferior, por ejemplo 3 unidades para el algoritmo SJF. Si tenemos n procesos, y un Quantum de tiempo de q, el resultado es que cada trabajo recibe 1/n de tiempo de CPU en Quantum's de q unidades. Ningún proceso debe esperar más de (n − 1)q unidades de tiempo antes de recibir servicio. El rendimiento del algoritmo depende mucho del tamaño del Quantum. Si se utiliza un valor muy grande el algoritmo tiende a degenerar hacia el FCFS. Si el tamaño del Quantum es muy pequeño, el costo de los constantes cambios de contexto degrada mucho el rendimiento del procesador. Hay que tener en cuenta que el porcentaje relativo de cambio de contexto respecto al cuanto, es el porcentaje relativo de pérdida de la CPU. Una regla empírica dice que el cuanto de tiempo debe ser inferior al 80 % de las ráfagas de CPU.
El Algoritmo del banquero, en sistemas operativos es una forma de evitar el interbloqueo, propuesta por primera vez por Edsger Dijkstra. Es un acercamiento teórico para evitar los interbloqueos en la planificación de recursos. Requiere conocer con anticipación los recursos que serán utilizados por todos los procesos. Esto último generalmente no puede ser satisfecho en la práctica.

Este algoritmo usualmente es explicado usando la analogía con el funcionamiento de un banco. Los clientes representan a los procesos, que tienen un crédito límite, y el dinero representa a los recursos. El banquero es el sistema operativo.

El banco confía en que no tendrá que permitir a todos sus clientes la utilización de todo su crédito a la vez. El banco también asume que si un cliente maximiza su crédito será capaz de terminar sus negocios y devolver el dinero a la entidad, permitiendo servir a otros clientes.

El algoritmo mantiene al sistema en un estado seguro. Un sistema se encuentra en un estado seguro si existe un orden en que pueden concederse las peticiones de recursos a todos los procesos, previniendo el interbloqueo. El algoritmo del banquero funciona encontrando estados de este tipo.

Los procesos piden recursos, y son complacidos siempre y cuando el sistema se mantenga en un estado seguro después de la concesión. De lo contrario, el proceso es suspendido hasta que otro proceso libere recursos suficientes.

Estructuras y complejidad


Se deben utilizar cuatro estructuras de datos para implementar el algoritmo del banquero. Estas codifican el estado del sistema de asignación de recursos. Sea n, el número de procesos del sistema, m el número de tipos de recursos. Se necesita:

Recursos (Available, disponible): Un vectores de longitud m que mantiene la cantidad total de recursos, de cada tipo, que pueden ser utilizados por los procesos. De esta forma, Recursos[i] = k significa que hay una cantidad total k de recursos tipo R_i disponibles.
Demanda (Max): Esta matriz, n\times m, guarda las cantidades máximas de recursos de cada tipo que pueden ser demandadas por cada proceso. Si Max[i][j]=k, el proceso i, puede solicitar, como máximo k instancias del recurso j.
Asignación (allocation): En esta matriz, n x m, número de recursos de cada tipo actualmente asignados a cada proceso. Asignación[i][j] = k significa que el proceso i tiene asignado k unidades del recurso j.
Necesidad (need): Una matriz, n x m, que indica la necesidad restante de recursos de cada proceso. Si Necesidad[i][j] = k, entonces el proceso i puede necesitar k instancias del tipo de recurso j. Observe que Necesidad[i][j] = Max[i][j] - Asignación[i][j].
En términos de complejidad, el algoritmo del banquero es de orden O(n2 × m), donde n es el número de procesos y m la cantidad de recursos.
CISC nació con la finalidad de homogeneizar los diferentes computadores en los años 50 y 60. RISC buscó en los 70 ir un paso más allá y mejorar el rendimiento con instrucciones más simples pero programas más largos y más difíciles de desarrollar.
Tanto CISC como RISC han evolucionado de forma muy notable desde su nacimiento, adoptando mejoras provenientes del contrario en ambos casos y nuevos conjuntos de instrucciones para adaptarse a los usos de los ordenadores. Si bien es cierto que en la época de su creación la diferencia era muy amplia – principalmente debido a las limitaciones técnicas de la época tanto en tamaño de memoria como en velocidad de proceso -, en la actual informática moderna los requisitos son muy diferentes. Los límites en capacidad de almacenamiento son casi inexistentes y los procesadores son capaces de ejecutar millones de instrucciones en un solo segundo.

La gran batalla actual es la de sus dos grandes exponentes, ARM y x86, que han actualizado sus objetivos a lo que les importa a los usuarios del siglo XXI. Veremos que el punto fuerte de ARM está en la eficiencia energética. Un chip ARM consume mucha menos energía que un procesador x86 que tiene en su alto rendimiento su gran virtud, a costa de consumir bastante más energía.
En arquitectura computacional, CISC (del inglés Complex Instruction Set Computer, en español Computador con Conjunto de Instrucciones Complejas) es un modelo de arquitectura de computadores. Los microprocesadores CISC tienen un conjunto de instrucciones que se caracteriza por ser muy amplio y permitir operaciones complejas entre operandos situados en la memoria o en los registros internos, en contraposición a la arquitectura RISC.

Este tipo de arquitectura dificulta el paralelismo entre instrucciones, por lo que, en la actualidad, la mayoría de los sistemas CISC de alto rendimiento implementan un sistema que convierte dichas instrucciones complejas en varias instrucciones simples del tipo RISC, llamadas generalmente microinstrucciones.

Los CISC pertenecen a la primera corriente de construcción de procesadores, antes del desarrollo de los RISC. Ejemplos de ellos son: Motorola 68000, Zilog Z80 y toda la familia Intel x86, AMD x86-64 usada en la mayoría de las computadoras personales actuales.

Hay que hacer notar, sin embargo que la utilización del término CISC comenzó tras la aparición de los procesadores RISC como nomenclatura despectiva por parte de los defensores/creadores de éstos últimos. Véase Retrónimo.
En arquitectura computacional, RISC (del inglés Reduced Instruction Set Computer, en español Computador con Conjunto de Instrucciones Reducidas) es un tipo de diseño de CPU generalmente utilizado en microprocesadores o microcontroladores con las siguientes características fundamentales:

  • Instrucciones de tamaño fijo y presentadas en un reducido número de formatos.
  • Sólo las instrucciones de carga y almacenamiento acceden a la memoria de datos.

Además estos procesadores suelen disponer de muchos registros de propósito general.

El objetivo de diseñar máquinas con esta arquitectura es posibilitar la segmentación y el paralelismo en la ejecución de instrucciones y reducir los accesos a memoria. Las máquinas RISC protagonizan la tendencia actual de construcción de microprocesadores. PowerPC, DEC Alpha, MIPS, ARM, SPARC son ejemplos de algunos de ellos.

RISC es una filosofía de diseño de CPU para computadora que está a favor de conjuntos de instrucciones pequeñas y simples que toman menor tiempo para ejecutarse. El tipo de procesador más comúnmente utilizado en equipos de escritorio, el x86, está basado en CISC en lugar de RISC, aunque las versiones más nuevas traducen instrucciones basadas en CISC x86 a instrucciones más simples basadas en RISC para uso interno antes de su ejecución.

La idea fue inspirada por el hecho de que muchas de las características que eran incluidas en los diseños tradicionales de CPU para aumentar la velocidad estaban siendo ignoradas por los programas que eran ejecutados en ellas. Además, la velocidad del procesador en relación con la memoria de la computadora que accedía era cada vez más alta. Esto conllevó la aparición de numerosas técnicas para reducir el procesamiento dentro del CPU, así como de reducir el número total de accesos a memoria.

Terminología más moderna se refiere a esos diseños como arquitecturas de carga-almacenamiento.


El algoritmo SJF (Shortest-Job-First) se basa en los ciclos de vida de los procesos, los cuales transcurren en dos etapas o periodos que son: ciclos de CPU y ciclos de entrada/salida, también conocidos por ráfagas.
La palabra shortest (el más corto) se refiere al proceso que tenga el el próximo ciclo de CPU mas corto. La idea es escoger entre todos los procesos listos el que tenga su próximo ciclo de CPU más pequeño. El SJF se puede comportar de dos formas:
Con Desalojo: Si se incorpora un nuevo proceso a la cola de listos y este tiene un ciclo de CPU menor que el ciclo de CPU del proceso que se está ejecuando,entonces dicho proceso es desalojado y el nuevo proceso toma la CPU.
Sin desalojo: Cuando un proceso toma la CPU, ningún otro proceso podrá apropiarse de ella hasta que que el proceso que la posee termine de ejecutarce.





 ¿Que es el Multiproceso? 

Es la facultad del sistema Opertivo para utilizar Varios procesadores fisicos en el equipo,
repartiendo El tratamiento de los procesos del SO y las Aplicaciones.
Tipos de Multiproceso

Multiproceso Asimètrico 


Un procesador esta reservado para el sistema, mientras que los demas se dedican a las Aplicaciones.
Multiproceso Simètrico

El sistema opertivo y las aplicaciones tiene sus peticiones de ejecución distribuidas en los distintos procesadores. en este ultimo caso, el sistema dispone de un porcentaje de tiempo de procesador, sea el que sea.

Configuraciones tipicas de Multiprosesamiento 


Mucho depende de como se configuran los procesadores multiples en el sistema. Las Configuraciones tipicas son:

Configuracion Maestro/Esclavo


 El sistema de Multiprocesamiento MAESTRO/ESCLAVO es una configuracion Asimetrica, Enterminos Conceptuales es un sistema de un procesador con procesadores "esclavos" adicionesles, cada uno de los cuales esta Administrado por el procesador primario "maestro".

Configuracion Debilmente Acoplada 


La unica diferencia entre un sistema de multiprocesamiento debilmente acoplado y un conjunto de sistemas de procesamineto individiales independientes es que cada procesador se puede comunicar
y cooperar con los demas. Se conoce como debilmente Acoplada por que cada procesador controla sus propios Recursos sus archivos y dispositivos de entrada y salida. Esto significa que cada procesador mantiene sus tablas de comandos y administracion de entrada y salida.

Configuracion Debilmente Acoplada


La configuracion Simetrica se implementa Mejor si todos los procesadores son del mismo tipo. Tiene cuatro ventajas sobre la de debìlmente acoplada:

1. Es màs confiable
2. Se utiliza los recursos de efectividad
3. Puede equilibrar las cargas Y
4. Se puede degradar con elegancia en caso de una falla(Forinash, 1987)

En una configuracion simetrica, la programacion del procesador esta descentralizada. Una sola copia de sistema operativo y una tabla global que lista cada proceso y su estado estan almacenadas en un area comun de la memoria, por lo que todos los procesadores tiene acceso a la misma. Cada procesador utiliza el mismo algoritmo de planificacion para seleccionar el proceso que se ejecutara acontinuacion
Según Coffman, para que se pueda producir un interbloqueo se tienen que dar las siguientes cuatro condiciones:

  • Exclusión mutua: cada recurso está asignado a un único proceso de manera exclusiva.
  • Retención y espera: los procesos que tienen, en un momento dado, recursos asignados con anterioridad, pueden solicitar nuevos recursos y esperar a que se le asignen sin liberar antes alguno de los recursos que ya tenía asignados.
  • 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 siquiera el sistema operativo puede expropiárselo.
  • 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.

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.

Estrategias


Existen diversas estrategias frente a los interbloqueos, que se pueden agrupar en:


  • Omisión
  • Detección y recuperación
  • Prevención
  • Predicción



En sistemas operativos, el bloqueo mutuo (también conocido como interbloqueo, traba mortal, deadlock, abrazo mortal) es el bloqueo permanente de un conjunto de procesos o hilos de ejecución en un sistema concurrente que compiten por recursos del sistema o bien se comunican entre ellos. A diferencia de otros problemas de concurrencia de procesos, no existe una solución general para los interbloqueos.

Todos los interbloqueos surgen de necesidades que no pueden ser satisfechas, por parte de dos o más procesos. En la vida real, un ejemplo puede ser el de dos niños que intentan jugar al arco y flecha, uno toma el arco, el otro la flecha. Ninguno puede jugar hasta que alguno libere lo que tomó.

En el siguiente ejemplo, dos procesos compiten por dos recursos que necesitan para funcionar, que sólo pueden ser utilizados por un proceso a la vez. El primer proceso obtiene el permiso de utilizar uno de los recursos (adquiere el lock sobre ese recurso). El segundo proceso toma el lock del otro recurso, y luego intenta utilizar el recurso ya utilizado por el primer proceso, por lo tanto queda en espera. Cuando el primer proceso a su vez intenta utilizar el otro recurso, se produce un interbloqueo, donde los dos procesos esperan la liberación del recurso que utiliza el otro proceso.


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

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

Ventajas e inconvenientes

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

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

Debido a estos inconvenientes, se desarrollaron los monitores.
Un semáforo es una variable especial (o tipo abstracto de datos) que constituye el método clásico para restringir o permitir el acceso a recursos compartidos (por ejemplo, un recurso de almacenamiento del sistema o variables del código fuente) en un entorno de multiprocesamiento (en el que se ejecutarán varios procesos concurrentemente). Fueron inventados por Edsger Dijkstra en 1965 y se usaron por primera vez en el sistema operativo THEOS

Estas instrucciones pueden modificarse para evitar la espera activa, haciendo que la operación P duerma al mismo proceso que la ejecuta si no puede decrementar el valor, mientras que la operación V despierta a un proceso que no es quien la ejecuta. En un pseudolenguaje más entendible, la operación P suele denominarse "wait" o "espera" y la operación V "signal" o "señal".

El porqué de los nombres de estas funciones, V y P, tiene su origen en el idioma holandés. "Verhogen" significa incrementar y "Proberen" probar, aunque Dijkstra usó la palabra inventada prolaag , que es una combinación de probeer te verlagen (intentar decrementar). El valor del semáforo es el número de unidades del recurso que están disponibles (si sólo hay un recurso, se utiliza un "semáforo binario" cuyo valor inicial es 1).

La verificación y modificación del valor, así como la posibilidad de irse a dormir (bloquerse) se realiza en conjunto, como una sola e indivisible acción atómica. El sistema operativo garantiza que al iniciar una operación con un semáforo, ningún otro proceso puede tener acceso al semáforo hasta que la operación termine o se bloquee. Esta atomicidad es absolutamente esencial para resolver los problemas de sincronización y evitar condiciones de competencia.

Si hay n recursos, se inicializará el semáforo al número n. Así, cada proceso, al ir solicitando un recurso, verificará que el valor del semáforo sea mayor de 0; si es así es que existen recursos libres, seguidamente acaparará el recurso y decrementará el valor del semáforo.

Cuando el semáforo alcance el valor 0, significará que todos los recursos están siendo utilizados, y los procesos que quieran solicitar un recurso deberán esperar a que el semáforo sea positivo, esto es: alguno de los procesos que están usando los recursos habrá terminado con él e incrementará el semáforo con un signal o V(s).


Inicia se utiliza para inicializar el semáforo antes de que se hagan peticiones sobre él, y toma por argumento a un entero. La operación P cuando no hay un recurso disponible, detiene la ejecución quedando en espera activa (o durmiendo) hasta que el valor del semáforo sea positivo, en cuyo caso lo reclama inmediatamente decrementándolo. V es la operación inversa: hace disponible un recurso después de que el proceso ha terminado de usarlo. Las operaciones P y V han de ser indivisibles (o atómicas), lo que quiere decir que cada una de las operaciones no debe ser interrumpida en medio de su ejecución.

La operación V es denominada a veces subir el semáforo (up) y la operación P se conoce también como bajar el semáforo (down), y también son llamadas signal y wait o soltar y tomar.

Para evitar la espera activa, un semáforo puede tener asociada una cola de procesos (normalmente una cola FIFO). Si un proceso efectúa una operación P en un semáforo que tiene valor cero, el proceso es detenido y añadido a la cola del semáforo. Cuando otro proceso incrementa el semáforo mediante la operación V y hay procesos en la cola asociada, se extrae uno de ellos (el primero que entró en una cola FIFO) y se reanuda su ejecución
Los diferentes estados por los cuales pasa un proceso en un sistema operativo, son los siguientes:


  • Nuevo: Es cuando la creación del proceso es solicitada en espera de la asignación de los recursos necesarios para su ejecución. Por ejemplo, la asignación de memoria RAM para su correcto funcionamiento.
  • Listo: Después de pasar por el estado nuevo, el proceso es creado y se agrega a la lista de procesos listos en espera para su ejecución.
  • En ejecución: De acuerdo al tipo de algoritmo utilizado para la selección de procesos a ejecutar, se seleccionara de la lista de procesos Listos para su ejecución, el tiempo que permanecerá en este estado será respecto al algoritmo seleccionado, el cual puede ser por ejemplo: hasta que se termine su tiempo de vida o el quantum seleccionado para dicho proceso.
  • Bloqueado: En este estado entran los procesos que han sido bloqueados de cualquiera de los anteriores estados. Saldrán de acuerdo a su selección hacia la lista de Listos.
  • Terminado: En este estado entran los procesos que han finalizado o bien han sido eliminados. Las estructuras de estos procesos estarán en espera de ser limpiadas por el sistema operativo.
Un proceso puede informalmente entenderse como un programa en ejecución. Formalmente un proceso es "Una unidad de actividad que se caracteriza por la ejecución de una secuencia de instrucciones, un estado actual, y un conjunto de recursos del sistema asociados".1

Para entender lo que es un proceso y la diferencia entre un programa y un proceso, A. S. Tanenbaum propone la analogía "Un científico computacional con mente culinaria hornea un pastel de cumpleaños para su hija; tiene la receta para un pastel de cumpleaños y una cocina bien equipada con todos los ingredientes necesarios, harina, huevo, azúcar, leche, etcétera." Situando cada parte de la analogía se puede decir que la receta representa el programa (el algoritmo), el científico computacional es el procesador y los ingredientes son las entradas del programa. El proceso es la actividad que consiste en que el científico computacional vaya leyendo la receta, obteniendo los ingredientes y horneando el pastel.

Cada proceso tiene su contador de programa, registros y variables, aislados de otros procesos, incluso siendo el mismo programa en ejecución 2 veces. Cuando este último caso sucede, el sistema operativo usa la misma región de memoria de código, debido a que dicho código no cambiará, a menos que se ejecute una versión distinta del programa.

Los procesos son gestionados por el sistema operativo y están formados por:


  • Las instrucciones de un programa destinadas a ser ejecutadas por el microprocesador.
  • Su estado de ejecución en un momento dado, esto es, los valores de los registros de la unidad central de procesamiento para dicho programa.
  • Su memoria de trabajo (memoria crítica), es decir, la memoria que ha reservado y sus contenidos.
  • Otra información que permite al sistema operativo su planificación.

Es un sistema de paginación con el cual, además de las ventajas de la paginación convencional, se busca disminuir los tiempos de respuesta y aumentar la cantidad de programas en memoria. Para lograr estos objetivos se hace uso de un intercambiador perezoso (llamado paginador) el cual carga a memoria solo las páginas que serán utilizadas por el programa en ejecución, de esta manera se logra un menor tiempo de carga y un ahorro en cuanto a espacio utilizado por dicho programa, ya que, por un lado, no necesitamos que todo el programa este en memoria para comenzar su ejecución mientras que, por otra parte, al no estar el programa completo en memoria, disminuimos considerablemente el espacio que éste ocupa.
Ya que el paginador solo busca las páginas que se necesitan para ejecutar algún programa, debemos agregar un bit que nos diga si las referencias de memoria son válidas o no, de lo contrario, al no encontrar una página no podríamos diferenciar si el paginador aún no la carga o si esta es realmente una referencia inválida.

Paginación por demanda

El proceso que se sigue es el siguiente:

  • Se intenta leer la página requerida
  • Si la página requerida ya esta en memoria, simplemente se lee.
  • Si no está en memoria, revisa si la referencia es válida.
  • Si la referencia es inválida, se aborta.
  • Si la referencia es válida, se intenta cargar la página.
  • Cuando la página sea cargada, se reintenta la instrucción.
paginacion por demanda



Al buscar una página, si esta no está en memoria, necesitará ser cargada. A este proceso se le llama fallo de página.

Al iniciar la ejecución de un programa, la tabla de páginas cuenta con todas sus entradas inválidas por lo cual el paginador fallará hasta tener lo necesario para iniciar el programa. Luego de esta carga inicial se comprobará si la siguiente página a utilizar ya está en memoria, en caso de que la página se encuentre, ésta es leída, pero cuando la página no es encontrada (y es una referencia válida) tenemos dos posibilidades:
Si existe un frame libre, se carga y se lee.
Si no tenemos frames libres, se intercambia la página de algún frame por la información a utilizar.

El criterio utilizado para seleccionar qué página será intercambiada varía dependiendo de la implementación del sistema. Muchos de los problemas que presenta el sistema de paginación por demanda son debido a los fallos de página y principalmente a saber cuál es la página más conveniente para intercambiar. Esto se debe a que no podemos saber cuales páginas serán utilizadas prontamente y cuales no se volverán a utilizar

Fallos de páginas

Como hemos visto anteriormente, cuando un proceso requiere una página que no está en memoria se genera un fallo de página. La gran mayoría de las dificultades de la paginación por demanda se deben a cómo los fallos de página son tratados.

Gestión de un fallo de página
En primer lugar, para que los fallos de página puedan ser tratados correctamente necesitamos un sistema que sea capaz de reiniciar una instrucción, de esta manera pasará lo siguiente:

  • Una instrucción necesita una página que no está en memoria.
  • Se genera fallo de página (No se puede satisfacer la instrucción).
  • Se carga a memoria la página requerida.
  • Se reinicia la instrucción



Como vemos en este proceso existe una carga a memoria, éste es uno de los factores determinantes para saber si la paginación por demanda es conveniente o no, puesto que, en el peor de los casos, puede existir una carga en memoria por instrucción lo que nos daría tiempos de ejecución mucho peores que con una paginación regular.