Sistemas Operativos

Dentro de los Sistemas Operativos los procesos que se ejecutan son muy variados, algunos utilizan la cpu para realizar de lectura de memoria, u otros campos que competen a la aplicación. Y también los mismos pudieran modificar los datos que leen. Pero que sucede si dos o mas procesos tienen que hacer estas operaciones? Es decir por ejemplo el modificar los datos que un proceso esta leyendo.

Pues es aquí en donde el caos podría entrar, pues la información podría ser modificada sin previo aviso o suceder acciones que no estaban planteadas. Para esto se plantea la Sincronización de Procesos.

Esto consiste en utilizar estructuras algorítmicas que permitan implementar el control de los procesos o hilos que se van a ejecutar de acuerdo a condiciones dadas, para que no se produzca situaciones como Bloqueos, Bloqueos mutuos(inanición) o accesos a secciones críticas del programa que no pueden ser accedidas en ese momento.

Para este control los algoritmos emplean sentencias(o pedazos de código) conocidos como semáforos o monitores.

Semáforos.- Se los considera como variables enteras que poseen solo dos métodos a través de los cuales se puede acceder a ellos. Lo que condiciona la entrada a zonas críticas o uso de recursos.
Monitores.- En cambio son estructuras más avanzadas de alto nivel que permiten mayor control que si son empleados correctamente permiten detectar error de temporización conocidos como timing.

Dentro de este ámbito de la Sincronización se han planteado numerosos casos como el de los filósofos comensales, el barbero dormilón y otros muchos más.

A continuación pueden encontrar una solución a un problema conocido como “El problema de los fumadores de cigarrillos” en donde existen 3 fumadores y un agente. Cada fumador continuamente enrolla un cigarro y luego lo fuma. Pero para enrollar y fumar un cigarrillo, el fumador necesita tres ingredientes: tabaco, papel y cerillos. Donde cada fumador tiene un solo elemento. El agente tiene un suministro infinito de los tres materiales. El agente coloca dos de los ingredientes en la mesa. El fumador que tiene el ingrediente restante hace entonces un cigarrillo y lo fuma, indicando al agente que terminó para que nuevamente coloque 2 nuevos elementos y el ciclo se repite.

El enlace para su descarga esta aquí, la aplicación fue desarrolla en Java bajo NetBeans 6.0. A continuación coloco algunas capturas de pantalla de la corrida del programa.

Saludos,

A continuación pongo en consideración una pequeña simulación del algoritmo “primero el trabajo más corto” (shortest – job - first).
La aplicación esta desarrollada en Java bajo el IDE NetBeans 6.0 y permite crear procesos(en realidad son solo objetos no hilos) que ocuparán cada uno un tiempo de ejecución o uso de CPU determinado por el usuario.

Esto funciona de la siguiente manera al establecer cuantos procesos se realizarán el usuario deberá especificar que tiempo tardará cada uno en terminar, para luego la aplicación planifique su ejecución empezando por el más pequeño.

Una vez encontrado el orden exacto cada proceso ocupará el thread(hilo) central de la aplicación haciéndola detener para que nadie pueda ocuparlo mientras él se ejecuta, además cabe recalcar que por ser una demostración se estima el tiempo en segundos(el hacerlo unidades menores no daría mucha idea de lo que sucede). Luego abandonará el control del hilo y pasará al siguiente. Al terminar todos los procesos la aplicación también terminará.

Puedo decir que este algoritmo presenta varias ventajas pues al realizar los procesos con menor tiempo primero el tiempo de espera disminuye considerablemente aunque en una situación real la única dificultad es el cálculo de la ráfaga de CPU que como mencioné en un post anterior es aproximada.

El programa se puede descargar desde aqui

Saludos,

En post anteriores se detalló el funcionamiento de esta planificación. La misma que consistía en una estructura FIFO de forma circular en donde cada proceso ocuparía la cpu dependiendo de un determinado tiempo conocido como “quantum”.

La aplicación realizada bajo el entorno java simula este algoritmo de la siguiente manera.
Lo primero que se realiza es solicitar la cantidad de procesos que se utilizarán la cpu y de la misma manera el tiempo quantum que podrá estar cada uno dentro, este tiempo se lo deberá dar en segundos(sin fracciones).

A continuación el programa generará con un proceso aleatorio los intervalos de tiempo que cada procesa necesita, para demostración esta controlado que no sea ni cero ni un valor mayor a 11(solo para no dejar la máquina trabajando mucho tiempo).

Una vez determinados los procesos serán almacenados en una estructura dinámica en este caso un ArrayList de donde serán extraídos en orden para que pasen a ocupar la CPU.
Algo que vale notar es que cuando un proceso ingresa a la cpu, el programa detiene el Thread principal de la aplicación el número de segundos que indique el quantum, por es mejor no colocar intervalos grandes(mayores 10). Esto da la apariencia d que si fuera un proceso real se estaría ejecutando.

Y finalmente cumplidos los tiempos de cada proceso son eliminados de la estructura hasta que esta quede vacía y se da por terminada la aplicación.

Es importante enfatizar que el problema de este Algoritmo es que el tiempo de entrega de un proceso dependerá mucho del tiempo quantum y en menor cantidad de su tiempo necesario.
Saludos,

La planificación de uso de la CPU, es la base de todo sistema operativo, ya que una planificación correcta permitirá un uso máximo, lo que causaría un rendimiento “optimo”.
Pero, como hace un Sistema Operativo para planificar sus procesos???

Partamos pues de que un proceso necesita una cantidad de tiempo para ser realizado(cambiar de estado a terminado), pero como un mismo proceso no puede ocupar la cpu hasta que termine se permitirá a cada proceso un tiempo de uso de cpu, también conocido como “ráfaga de la cpu”, y para esto se almacenara toda la información del proceso, (como su estado, tiempo de espera, entre otros) dentro de un “bloque de control del proceso” (PCB) que determinará todo el estado de un proceso.

Pero, como “sabe”(literalmente) el Sistema Operativo que proceso es el correcto o más necesario para que utilice la cpu???

Pues a decir verdad cada sistema operativo implementa criterios de planificación, basados en algoritmos que intentan que la cpu no este ociosa(en tiempo de espera Ej. E/S)

Entre los criterios que se emplean para la planificación puedo mencionar:

• Utilización de la CPU.- Tenerla tan ocupada como sea posible. Esto es un 40% en Sistemas ligeros y 90% en sistemas pesados.

• Rendimiento.- Calculado mediante el número de procesos que es capaz de terminar en una unidad de tiempo.

• Tiempo de Entrega.- Se considera como el tiempo desde que un proceso inicia hasta que termina.

• Tiempo de espera.- Lo considero como la suma de periodos de tiempo en la cola de listos.

• Tiempo de Respuesta.- Es el tiempo que se requiere para que un proceso empiece a responder y no el tiempo para dicha respuesta.

Siguiendo estos criterios, se deduce que lo más deseable es que aumenten los dos primeros puntos(Utilización - rendimiento) y disminuyan todos los demás.

Para conseguir este fin se utilizan algoritmos que distribuyen o planifican procesos, por ahora solo los enunciaré para en un próximo post detallarlos:

• FCFS
• SJF
• Procesos por Prioridad
• RR

Saludos,

Algoritmo de Prioridad.

En los algoritmos de planificación existen los siguientes algoritmos:

- Algoritmo FIFO
- Algoritmo SJF
- Algortimo Round Robin
- y támbien está el algoritmo de Prioridad de el cual hemos realizado un Algoritmo y sus corridas que presentamos acontinuación, lo realizamos en Netbeens:

Los procesos tienen prioridades asignadas, y el planificador escogerá aquel proceso con mayor prioridad.

Cuando un proceso debe ser seleccionado, el planificador por prioridades seleccionará aquel proceso que tenga mayor prioridad. Si hay más de un proceso entonces se deberá seguir alguna política de selección.

Un problema que presenta un esquema de planificación por prioridades puro es que los procesos con la prioridad más baja pueden sufrir de inanición o bloqueo indefinido. Un proceso que está listo para correr pero espera porque siempre hay procesos con prioridad más alta.

Para evitar este problema, se puede ir incrementando gradualmente la prioridad de los procesos.

SJF es un caso especial de planificación por Prioridad, donde la prioridad es el inverso del valor estimado del próximo ciclo de CPU ( a menor ciclo, mayor prioridad).

Los resultados del Algoritmo son los siguientes:

Por:
Richar Guaya.
María Fernanda Valverde.