Archive for the ‘Sistemas Operativos’ Category

AIX 5L

Martes, Mayo 13th, 2008

Autores:

• ISRAEL CUEVA HIDALGO.
• Angélica Espinoza.
• Carolina rojas.

AIX 5L
logo aix

AIX 5L v5.2 ofrece mejor rendimiento aún que el galardonado sistema operativo AIX 4 o AIX 5L v5.1 estándar. Le permite gestionar las aplicaciones Linux y AIX en un mismo entorno y puede ayudarle a reducir los ciclos de producción.

AIX 5L es la mejor respuesta a las demandas e-business de una plataforma UNIX industrial, con gran espacio para el crecimiento y con una gran protección de la inversión. AIX 5L representa la nueva generación de AIX y se caracteriza por sus niveles más altos de integración, flexibilidad y rendimiento. Ofrece:
• Una plataforma UNIX sólida y escalable para aplicaciones críticas
• Gran afinidad Linux para ofrecer soluciones flexibles adaptadas a la empresa
• Las conexiones necesarias para e-business y sistemas en red
• Seguridad en la que se puede confiar
• Gestión de sistemas y redes que otorga todo el control al usuario
• Servicio y soporte que ayudan a mantener la continuidad del negocio
• Funciones de capacidad bajo demanda, que significan que sólo se paga por lo que se utiliza

PAGINACIÓN

En sistemas operativos de computadoras, los sistemas de paginación de memoria dividen los programas en pequeñas partes o páginas. Del mismo modo, la memoria es dividida en trozos del mismo tamaño que las páginas llamados marcos de página. De esta forma, la cantidad de memoria desperdiciada por un proceso es el final de su última página, lo que minimiza la fragmentación interna y evita la externa.
En un momento cualquiera, la memoria se encuentra ocupada con páginas de diferentes procesos, mientras que algunos marcos están disponibles para su uso. El sistema operativo mantiene una lista de estos últimos marcos, y una tabla por cada proceso, donde consta en qué marco se encuentra cada página del proceso. De esta forma, las páginas de un proceso pueden no estar contiguamente ubicadas en memoria, y pueden intercalarse con las páginas de otros procesos.
En la tabla de páginas de un proceso, se encuentra la ubicación del marco que contiene a cada una de sus páginas. Las direcciones lógicas ahora se forman como un número de página y de un desplazamiento dentro de esa página (conocido comúnmente como offset). El número de página es usado como un índice dentro de la tabla de páginas, y una vez obtenida la dirección del marco de memoria, se utiliza el desplazamiento para componer la dirección real o dirección física. Este proceso se realiza en una parte del computador específicamente diseñada para esta tarea, es decir, es un proceso hardware y no software.
De esta forma, cuando un proceso es cargado en memoria, se cargan todas sus páginas en marcos libres y se completa su tabla de páginas.

SEGMENTACIÓN

La segmentación (en inglés pipelining, literalmente oleoducto) es un método por el cual se consigue aumentar el rendimiento de algunos sistemas electrónicos digitales. Es aplicado, sobre todo, en microprocesadores. El nombre viene de que para impulsar el gas en un oleoducto a la máxima velocidad es necesario dividir el oleoducto en tramos y colocar una bomba que de un nuevo impulso al gas. El símil con la programación existe en que los cálculos deben ser registrados o sincronizados con el reloj cada cierto tiempo para que la ruta crítica (tramo con más carga o retardo computacional entre dos registros de reloj) se reduzca.
La ruta crítica es en realidad la frecuencia máxima de trabajo alcanzada por el conjunto. A mayor ruta crítica (tiempo o retraso entre registros) menor es la frecuencia máxima de trabajo y a menor ruta crítica mayor frecuencia de trabajo. La una es la inversa de la otra. Repartir o segmentar equitativamente el cálculo hace que esa frecuencia sea la óptima a costa de más área para el almacenamiento o registro de los datos intervinientes y de un retraso o latencia (en ciclos de reloj/tiempo) en la salida del resultado equivalente al número de segmentaciones o registros realizados. La ventaja primordial de este sistema es que, tal y como se muestra en la imagen, una vez el pipe está lleno, es decir, después de una latencia de cuatro en la imagen, los resultados de cada comando vienen uno tras otro cada flanco de reloj y sin latencia extra por estar encadenados dentro del mismo pipe. Todo esto habiendo maximizado la frecuencia máxima de trabajo.

La Sincronización de Procesos

Jueves, Mayo 1st, 2008

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.

Ejecución primera parte

Segunda Ejecución de la Aplicación

Saludos,

SIMULACIÓN DEL ALGORITMO SJF

Miércoles, Abril 30th, 2008

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.

Corrida 1

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á.

Ejecución de los procesos…

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,

gOS; un Sistema Operativo basado en Google??

Martes, Abril 29th, 2008

gOS
gOS, es una nueva distribución basada en el reconocido sabor Linux: Ubuntu Gutsy 7.10, además de eso otra de sus características principales es su utilidad Web 2.0
Esta idea surgió con la finalidad de ofrecer un escritorio simple y más amigable para cualquier usuario común.
Cabe tomar muy en cuenta que este Sistema Operativo no lleva la “g” por hacer referencia a “Google”, sino se trata de un proyecto y la letra “g” se refiere a “green”.

dibujo1.jpg

Esta distribución usa un entorno muy liviano como es el Enlightenment 17 (interfaz gráfica), en lugar de los conocidos entornos de escritorio Gnome o KDE. Consta de una variada lista de programas de escritorio, que se pueden ubicar en la barra inferior de la pantalla, aplicaciones tal como, el OpenOffice para oficina, Skipe para VOIP, Pidgin para chat, Thunderbind para correo, Gnome Baker para grabar CD’s y DVD’s, GIMP para la edición de imagenes, Rhythmbox para reproducción de música, Xine para la edición de videos, Firefox, además de esto incluye el Webrunner, que es un navegador usado para hacer búsquedas directas en google, entre otras aplicaciones.
Además aplicaciones online, y a esto se refiere la utilidad Web 2.0, ya que incluye programas y enlaces a sitios Web 2.0 reconocidos tal como: Google Mail, Google News, Google Calendar, Google Maps, Google Docs, Google Products, Meebo, Youtube, Blogger, facebook, Wikipedia, Faqly, box.net, etc.
Se puede decir que esta distribución no es precisamente pensada en usuarios peso pesado, pero su amigabilidad y sus aplicaciones la hacen una buena alternativa para los usuarios Web 2.0.

Simulación de la Planificación RR

Lunes, Abril 28th, 2008

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).
Ejecución 1
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.
Ejecución 2
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,

ALGORITMOS DE PLANIFICACIÓN

Viernes, Abril 25th, 2008

Planificación FCFS

El algoritmo FCFS(first come – first-served), conocido como primero en llegar, primero en ser atendido.
Dentro de este campo de planificación es el más sencillo, pues es similar a una cola de estructura (FIFO)
Este algoritmo trabaja de la siguiente manera, al entrar un proceso al estado de “listo”, el bloque de control de proceso se ubica en el final de la cola, entonces el cpu al estar libre retirará de esta cola el primer elemento(cabeza).
Es decir, en este algoritmo el tiempo de espera par que un proceso se ejecute es incierto y no mínimo. Pudiendo así ejecutarse dentro de la cpu un proceso que consuma demasiado tiempo, atrasando a otros procesos y dejando la cpu sin trabajo por lapsos de tiempo.
En definitiva este algoritmo hace que los procesos pequeños esperen a que un grande abandone la cpu. Una gran desventaja.

Planificación en SJF
El algoritmo “primero el trabajo más corto” (shortest – job - first). Establece para la planificación una relación entre proceso y ráfaga de la CPU. Es decir, al liberarse la cpu ingresará el proceso con la menor ráfaga de tiempo, el más pequeño primero, y si existiera más de un proceso con igual valor, pues se aplicaría dentro de este el algoritmo anterior(FCFS)
Este algoritmo presenta una gran ventaja, pues el tiempo de espera será mucho menor, pues mientras los procesos de tiempo inferior terminan y ocupan tiempo en operaciones de E/S, el cpu se ocupa de resolver el proceso con mayor tiempo, un algoritmo muy óptimo.
Pero, el mayor problema radica en como saber el tiempo de ráfaga para cada proceso???? Pues no existe manera de saber cual será la siguiente. Pero podemos aproximarnos, diciendo que será similar a las anteriores, que mediante una fórmula matemática podríamos decir que:
Tn +1 =  Tn + (1 - )Tn
De donde Tn es la ráfaga anterior y  es el peso relativo de la historia reciente. Lo que garantiza una aproximación mas considerable.

Planificación por Prioridad
Esta clase de algoritmo utiliza como relación entre proceso, tiempo de la cpu y prioridad. De donde el proceso con mayor ráfaga tendrá la menor prioridad y viceversa.
Y donde la cpu podrá ser utilizada por el proceso con mayor prioridad.
Dentro de este algoritmo la prioridad es asignada ya sea interna o externamente. Pero, uno de los problemas que puede presentar esta planificación es la de un bloqueo indefinido. Es decir, pudiera darse el caso que existan procesos de prioridad alta que harían que los procesos de prioridad baja queden bloqueados hasta que logren colocarse en la cpu o perderse cuando nuestro sistema se caiga, es decir una espera indefinida.
Es aquí donde se puede aplicar una técnica conocida como envejecimiento, que ira incrementando la prioridad de los procesos en espera cada determinado tiempo hasta que estos se ejecuten. Y a mi parecer este es una de las mejores soluciones.

Planificación con RR
La planificación por turnos o Round Robin, se basa en una estructura FIFO de forma circular, en donde se asigna a los procesos un intervalo de tiempo para la cpu, conocido como quantum. En donde se establece la regla de que un proceso no podrá estar dos veces seguidas en la cpu a menos que sea el único en el estado de listo.
Este algoritmo trabaja de la siguiente manera, al ingresar el proceso a utilizar la cpu, este estará dentro del tiempo(quantum), si al terminar este tiempo el proceso no ha terminado es colocado al final y se ingresará otro proceso. Pero si el proceso pasa ha estado terminado antes de terminar su quantum, también será extraído de la cpu.
En cambio este algoritmo presenta complicaciones pues el tiempo de entrega de un proceso dependerá mucho más del tiempo(quantum) que de la magnitud del proceso.

Saludos,

PLANIFICACIÓN DE LA CPU

Jueves, Abril 24th, 2008

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,

PRODUCTORES-CONSUMIDORES

Sábado, Abril 19th, 2008

A continuación se presenta el código de las funciones principales en el algoritmo de PRODUCTORES-CONSUMIDORES, en el lenguaje de programación C++.

#define N 100 /*Establecer tamaño del buffer*/
typedef int semaforo; /*int especiales semáforo*/
semaforo mutex = 1; /*acceso o salida región crítica*/
semaforo vacias = N; /*cuenta espacios vacios del buffer*/
semaforo llenas = 0; /*cuenta espacios ocupados del buffer*/

void productor(void)
{
int elem;

while (TRUE)
{
elem = producir_elem(); /*generar elemento para poner en búffer*/
down(&vacias); /*decrementar cuenta de vacias*/
down(&mutex); /*entrar en región crítica*/
insetar_elem(elem); /*inserta un elemento en el búffer*/
up(&mutex); /*salir región crítica*/
up(&llenas); /*incrementar espacios ocupados*/
}
}

void consumidor(void)
{
int elem;

while (TRUE)
{
down(&llenas); /*decrementar espacios ocupados*/
down(&mutex); /*entrar en región crítica*/
elem = sacar_elem(); /*sacar elemento del búffer*/
up(&mutex); /*salir región crítica*/
up(&vacias); /*incrementar cuenta espacios vacios*/
consumir_elem(elem); /*consumir el elemento*/
}
}

Integrantes :
- Alex Gonzaga
- César Montalván

Colas Por Division

Viernes, Abril 18th, 2008

//colas por divison
//sistemas operativos

import java.io.*;

public class Colas {
public static class ClaseColas { // Declaracion de la clase de Colas
static int max=10; // Numero maximo de la Cola
static int cola[]= new int[max]; // Declaracion del arreglo
static int frente, fin; // Indicadores de inicio y fin de la Cola
static int subir, bajar; //subir y bajar proceso
static int prio=0;// prioridad

ClaseColas() { // Constructor que inicializa el frente y el final de la Cola
frente=0; fin=0;
System.out.println(”Cola inicializada !!!”);
}

public static void Insertar(int dato) {
if(fin==max) { // Esta llena la Cola?
System.out.println(”\nCola llena !!!”);
return;
}
cola[fin++]=dato;
System.out.println(”Dato insertado !!!”);
}

//
public static void Mostrar() {
int i=0;
System.out.println(”\n\n<<>>”);
if(cola==max) System.out.println(”\nCola vacia !!!”);
for(i=cola; i<max; i++) {
cola=cola(i-1)/2;
Prio= frente + cola(i-1)/2;
System.out.println(”cola[”+i+”]=”+” “+cola[i]);
}

public static void Subir() {
int i=0;
System.out.println(”\n\n<<>>”);
if(frente==fin) System.out.println(”\nCola vacia !!!”);
for(i=frente; i<fin; i++) {
System.out.println(”cola[”+i+”]=”+” “+cola[i]);
}

System.out.println(”\nFrente= “+frente);
System.out.println(”Final = “+fin);
System.out.println(”Max = “+max);
}
}

static ClaseColas Cola=new ClaseColas(); // Declaracion del objeto Cola

// Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
System.out.println(”\n\n<<>>”);
System.out.println(”1.- Altas”);
System.out.print(”Opcion? —> “);
op=getInt();

switch(op) {
case 1 : Altas(); break;

case 3 : Cola.Mostrar(); break;
}
}while(op!=0);
}

public static void Altas() throws IOException {
int elemento=0;
System.out.println(”\n\n<<>>”);
System.out.print(”Elemento a insertar? —> “);
elemento=getInt();
Cola.Insertar(elemento); // Invocar el metodo Insertar del objeto Cola
}

}

Integrantes:

Juan Pablo Arrobo
Andrea Espinosa
Jhoanna Simancas

Sistema Operativo CentOS (linux)

Miércoles, Abril 16th, 2008

Dos de las partes más críticas de un kernel son el subsistema de memoria y el planificador. Esto es debido a que estas dos piezas influyen en el diseño y afectan al comportamiento de prácticamente todos los demás elementos del kernel y del sistema operativo. Esta es también la razón por la que es deseable que estas dos piezas tengan un funcionamiento absolutamente correcto y un comportamiento óptimo. El kernel de Linux se utiliza en todo tipo de máquinas, desde pequeños dispositivos empotrados hasta grandes ordenadores (mainframes).
Objetivos de la Planificación
El planificador de Linux intenta conseguir varios objetivos:
Ecuanimidad:
El planificador debería repartir la CPU entre todos los procesos de forma ecuánime. En el nuevo kernel se ha trabajado para garantizar un reparto imparcial del tiempo de CPU entre los procesos.

Volumen de producción y eficiencia:
El planificador debería intentar maximizar tanto el volumen de producción (throughput) como la eficiencia (utilización de la CPU). La forma habitual de incrementar la utilización de la CPU es incrementando el nivel de multiprogramación. Pero esto es beneficioso sólo hasta un cierto punto, a partir del cual se vuelve contraproducente.

Mínima Sobrecarga:
Un planificador debería estar en ejecución el menor tiempo posible. La latencia del planificador debería ser mínima. Pero esta es la parte peliaguda. Generalmente la planificación en sí se considera trabajo no útil. Ahora bien, si la planificación se hace de forma correcta aún a costa de consumir algo más de tiempo puede valer la pena. Pero ¿cómo decidimos cuál es el punto óptimo? La mayoría de los planificadores resuelven este problema utilizando políticas heurísticas.

Hacer cumplir una planificación basada en prioridades:
Planificación basada en prioridades significa que algunos procesos tienen precedencia sobre otros. Como mínimo, el planificador debe distinguir entre procesos limitados por E/S y procesos limitados por CPU. Además, debe implementarse algún mecanismo que tenga en cuenta la edad de los procesos para evitar que algunos no tengan acceso a la CPU (inanición). Linux respeta las prioridades y distingue entre varias categorías de procesos. El kernel de Linux distingue entre trabajos planificados vía batch y tareas interactivas. Todos ellos obtienen una cuota de CPU de acuerdo a sus prioridades. Probablemente alguien ha utilizado alguna vez el comando nice para cambiar la prioridad de un proceso.

Tiempo de turnaround, tiempo de espera:
El tiempo de turnaround es la suma del tiempo de servicio y el tiempo de espera en la cola de ejecución (ready). El planificador intenta reducir ambos.


Tiempo de respuesta y variabilidad:

El tiempo de respuesta de un programa debería ser lo menor posible. Además, otro factor importante, que a menudo se olvida, es la variabilidad entre los tiempos de respuesta. No es aceptable que el tiempo de respuesta medio sea bajo pero que algún usuario obtenga ocasionalmente un retraso de, digamos, diez segundos ejecutando un programa interactivo.

Miscelánea:

El planificador intenta también cumplir otros objetivos como la predictibilidad. El comportamiento del planificador debería ser predecible para un conjunto dado de procesos con prioridades asignadas. El rendimiento del planificador debe decaer suavemente al aumentar la carga. Esto es especialmente importante en el caso de Linux al ser muy popular como servidor, ya que los servidores tienden a resultar sobrecargados durante los picos de mayor tráfico.
Linux está basado en la planificación tradicional de Unix añadiendo 2 clases de prioridad para procesos de tiempo real flexibles. Las tres clases de prioridad de Linux son las siguientes:

SCHED_FIFO: hilos de tiempo real con planificación FIFO.

SCHED_RR: hilos de tiempo real con planificación por turno rotatorio.

SCHED_OTHER: hilos que no son de tiempo real y otros.

Dentro de cada clase se utilizan múltiples prioridades, siendo las prioridades de las clases de tiempo real mayores que la de la clase SCHED_OTHER. Para los hilos FIFO, se aplican las siguientes reglas:

1. El sistema no interrumpe la ejecución de un hilo FIFO, excepto en los siguientes casos:

a) Pasa a estar listo otro hilo FIFO de mayor prioridad.

b) El hilo FIFO en ejecución se bloquea a la espera de un evento, como una E/S.

c) El hilo FIFO en ejecución abandona el procesador como resultado de la ejecución de la primitiva sched_yield.

2. Cuando se interrumpe un hilo FIFO en ejecución, pasa a la cola asociada a su prioridad.
3. Cuando un hilo FIFO pasa a listo y tiene mayor prioridad que el hilo que está en ejecución, se expulsa al hilo en ejecución y pasa a ejecutar el hilo de mayor prioridad. Si más de un hilo tiene esta mayor prioridad, se escoge al que lleva más tiempo esperado.

La política SCHED_RR es similar a la SCHED_FIFO, excepto por el uso de un cuanto de tiempo asociada a cada hilo. Cuando un hilo SCHED_RR ha consumido su cuanto de tiempo, pasa a suspendido y se escoge un hilo de tiempo real con una prioridad igual o mayor.

El planificador de Linux necesita un tiempo constante para planificar los procesos de la cola de ejecución (ready). En consecuencia, decimos que tiene complejidad O(1) . No importa cuál sea el número de procesos activos en el sistema Linux, el planificador siempre tarda un tiempo constante para planificar su ejecución. Todas las “partes” - activación, selección del siguiente proceso a ejecutar, conmutación del contexto y sobrecarga de la interrupción del temporizador - del kernel de Linux actual tienen complejidad O(1). Por lo tanto, el nuevo planificador en su conjunto tiene complejidad O(1).

Mejor Soporte para SMP y más escalable
Como hemos mencionado en la introducción, el kernel de Linux puede ejecutarse en casi cualquier cosa desde relojes de pulsera a superordenadores. Los planificadores anteriores presentaban algunos problemas de escalabilidad. Algunos de estos problemas se resolvieron modificando el kernel específicamente para la aplicación y la arquitectura objetivos. Sin embargo, el diseño central del planificador no era muy escalable. El nuevo planificador es mucho más escalable y adecuado para SMP (Symmetric Multi-Processing: Multi-Procesamiento Simétrico). Ahora, el planificador se comporta mucho mejor que antes en sistemas SMP. Uno de los objetivos establecidos por Ingo Molnar, autor del planificador O(1), es que en SMP los procesadores no deberían estar inactivos cuando haya trabajo por hacer. Asimismo, se debería tener cuidado de que los procesos no se planifiquen para ejecución en procesadores diferentes ocasionalmente. De esta forma se evita la sobrecarga debida al relleno de la cache con los datos necesarios cada vez.

Planificación batch de trabajos

Esta no es exactamente una característica nueva, pero hay algunos parches que se pueden aplicar para añadir soporte de planificación batch. Los kernels anteriores también soportaban planificación batch en alguna medida. En la actualidad, la planificación batch se realiza utilizando niveles de prioridad. El kernel de Linux utiliza unos cuarenta niveles nice (si bien todos ellos son agrupados en unos cinco niveles de prioridad). Normalmente, los procesos planificados batch hacen uso de la CPU cuando no hay en ejecución muchos procesos interactivos ni procesos limitados por CPU, los cuales tienen mayor prioridad. Los procesos planificados batch obtienen cuantos temporales más largos que los procesos normales. De esta forma también se minimiza el efecto del intercambio frecuente de datos hacia y desde la cache, mejorando, por tanto, el comportamiento de los trabajos batch.

Mejor comportamiento de los trabajos interactivos
Entre los mayores avances del nuevo planificador se encuentran la detección de tareas interactivas y la mejora de su comportamiento. La detección de los trabajos interactivos se realiza en fragmentos de código desacoplados de los que realizan otras tareas de planificación como la gestión de los cuantos temporales. Los trabajos interactivos se detectan con la ayuda de estadísticas de uso. Esto significa que las tareas interactivas tienen buenos tiempos de respuesta bajo cargas de trabajo pesadas, y que los procesos ávidos de CPU no pueden monopolizar el tiempo de CPU. El nuevo planificador detecta las tareas interactivas y les otorga mayor precedencia que a otras tareas. Aún así, una tarea interactiva es planificada con otras tareas interactivas utilizando planificación Round-Robin. Esto es muy adecuado para usuarios de estaciones de trabajo ya que no apreciarán incrementos en los tiempos de respuesta cuando arrancan un trabajo con gran consumo de CPU como, por ejemplo, la codificación de canciones en formato ogg. Hay planes para combinar código O(1) y código expropiativo para mejorar los tiempos de respuesta de las tareas interactivas.

Mayor escalabilidad y soporte para más arquitecturas
Gracias al rediseño a que ha sido sometido, el nuevo planificador es más fácilmente escalable a otras arquitecturas como NUMA (Non-Uniform Memory Access: Acceso a Memoria No-Uniforme) y SMT. La arquitectura NUMA se utiliza en algunos servidores de altas prestaciones y supercomputadores. También se está trabajando en SMT (Symmetric Multi-Threading). SMT es conocido también por un nombre más popular: HyperThreading. Una de las razones es que ahora cada CPU tiene su propia cola de ejecución. Sólo la sub-parte de balanceo de carga tiene una visión “global” del sistema. De esta forma, las modificaciones para una arquitectura determinada tienen que hacerse, principalmente, en la sub-parte de balanceo de carga. También se ha publicado un parche para NUMA recientemente. De hecho, se ha incorporado en Linux 2.5.59. Los procesadores SMT implementan dos (o más) CPUs virtuales en el mismo procesador físico - un procesador “lógico” puede ejecutar código mientras el otro espera por acceso a memoria. Puede interpretarse SMT como una clase de sistema NUMA, puesto que los procesadores hermanos comparten la cache y, por lo tanto, acceden más rápidamente a aquellas direcciones de memoria a las que han accedido recientemente cualquiera de los otros. Se está trabajando también en SMT, pero el nuevo planificador O(1) maneja SMT bastante bien incluso sin ninguna modificación. Recientemente se ha liberado un parche para SMT. Aunque la arquitectura NUMA muestra cierto parecido con la arquitectura SMT, el planificador Linux los trata de forma diferente.

Miscelánea
El planificador da mayor prioridad a los hijos generados con fork() que al padre que los ha generado. Potencialmente, los servidores que utilizan la llamada fork para dar servicio a las peticiones podrían beneficiarse de esta característica. También podría ser útil para las aplicaciones GUI. También hay disponible en el kernel algo de planificación de tiempo real (basada en prioridades).

INTEGRANTES

CABRERA KARLA
PULLA CINTHIA
RAMOS JAMMIL