Sistemas Operativos

En un sistema multiprogramado, múltiples procesos son mantenidos en memoria principal. Multiprogramación surgió con la idea de tener algún proceso ejecutándose en todo momento con la finalidad de maximizar el uso del CPU. Tiempo Compartido fue concebido con la idea de conmutar o cambiar continuamente el CPU entre procesos de forma tal que los usuarios puedan interactuar con sus programas mientras están corriendo.

A continuacion se hace relacion de la planificacion de procesos con el tema de investigacion, que en nuestro caso es de Server Windows 2003

Realizado por : Patricia Flores
Margarita Nero
Fabricio Sanchez

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

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.

Entre los algoritmos de planifiacción tenemos el SJF, trata de ejecutar los procesos de menor ráfaga primero.
La ventaja que presenta este algoritmo sobre el algoritmo FIFO es que minimiza el tiempo de finalización promedio
Paralelo A
Integrantes:
Margarita Nero
Fabricio Sanchez
Patricia Flores

PROGRAMA EN JAVA

Este algoritmo selecciona al proceso con el próximo tiempo de ejecución más corto. Un proceso corto saltará a la cabeza de la cola. La ejecución de un proceso consiste en ciclos de ejecución de CPU y ciclos de espera por E/S. El algoritmo selecciona aquel proceso cuyo próximo ciclo de ejecución de CPU sea menor. El problema está en conocer dichos valores, pero podemos predecirlos usando la información de los ciclos anteriores ejecutados.

SJF
Proceso Tiempo de llegada Tiempo de Servicio Tiempo de Comienzo Tiempo de Finalización Turnaround Tiempo de Espera
A 0 8 0 8 8 0
B 1 4 8 12 12-1=11 8-1=7
C 2 9 17 26 26-2=24 17-2=15
D 3 5 12 17 17-3=14 12-3=9
Promedio 14.25 10.33

El SJF es probablemente óptimo pues da el mínimo tiempo promedio de espera. El problema está en conocer la duración del próximo requerimiento de CPU para cada proceso. Esta duración puede predecirse suponiendo que el próximo ciclo puede ser similar a los anteriores.

Código Fuente SJF

Paralelo “A”
Integrantes:
Elba Encalada
Leonardo Sarango
Ruth Hidalgo

//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

#include <stdlib.h>
#include <iostream.h>

struct estudiante {
char nombre [20];
int edad;
estudiante *enlace;
};

estudiante *cabeza=NULL;
estudiante *cola=NULL;

void insertar(char *nombre, int edad);
void presentarlista();

int main()
{
char continua = ’s’;
char nombre [20];
int edad;
while (continua == ’s’){
cout<< “Ingrese el nombre y la edad del estudiante”<> nombre >> edad;
insertar(nombre, edad);
cout<> continua;
}

presentarlista();
system(”PAUSE”);
return 0;
}

void insertar(char *nombre, int edad) {
if (cabeza == NULL) { // Si no hay ningún nodo en la lista
cabeza = new estudiante;
cola = cabeza;
}
else { // Si ya hay nodos en la lista
cola->enlace = new estudiante;
cola = cola->enlace;
}
// strcpy (cola->nombre, nombre);
cola->edad = edad;
cola->enlace = NULL;
}

// Rutina que presenta la lista ingresada
void presentarlista(){
estudiante *recorrer=cabeza; // variable auxiliar
while (recorrer != NULL) { // si aun hay elementos en la lista
// presentar el nombre y la edad
cout<< “Nombre: “<nombre << ” edad: “<edad <enlace;
}
}

Integrantes:
Leonardo Saldaña
John Iñiguez
Israel Rodriguez

Paralelo “A”

/*
// SISTEMAS OPERATIVOS - ALGORITMO FIFO
//
// * PARALELO “A”

// * ISRAEL CUEVA.
// * ANGÉLICA ESPINOZA
// * CAROLINA ROJAS
//
*/

#include <stdio.h>
#include <stdlib.h>

main()
{
int intArregloSuma [10];
int intArregloTiempo [10];
int intArregloTiempoAuxiliar [10];
int intArregloRafagaAcumulada[10];
int intArregloRafaga [10];
int intArregloAuxiliar [10];
int intNumeroProceso = 0;
int intTiempo = 0;
int intSuma = 0;
double dblTep = 0;
double dblTrp = 0;
int cont = 0;
int p=0;
int intRafaga = 0;
int i = 0, j = 0, aux = 0;
int k=0;

// Ingreso de datos
printf(”\n\t\tINGRESO DE DATOS - FIFO”);
printf(”\n\nIngresa el numero de procesos: “);
scanf(”%d”, &intNumeroProceso);
system(”cls”);

for (i=0; i<intNumeroProceso; i++)
{
printf(”\n\t\tINGRESO DE DATOS”);
printf(”\n\nIngresa tiempo de llegada para el proceso [%d]: “,i+1);
scanf(”%d”, &intTiempo);
intArregloTiempo[i] = intTiempo;
intArregloTiempoAuxiliar[i] = intTiempo;
printf(”\nIngresa la  rafaga de CPU para el proceso [%d]: “,i+1);
scanf(”%d”, &intRafaga);
intArregloRafaga[i] = intRafaga;
system(”cls”);
}

//Proceso para ordenar el arreglo
for( i=1; i<intNumeroProceso; i++)
{
j=i;
aux = intArregloTiempo[i];
while(j>0 && aux<intArregloTiempo[j-1])
{
intArregloTiempo[j] = intArregloTiempo[j-1];
j = j-1;
}
intArregloTiempo[j] = aux;
}

//Proceso ordenar la RCPU de acuerdo al tiempo de llegada de los procesos
while(cont<intNumeroProceso)
{
for(k=0;k<intNumeroProceso; k++)
{
if(intArregloTiempoAuxiliar[k] == intArregloTiempo[p])
{
intArregloAuxiliar[cont] = intArregloRafaga[k];
p++;
break;
}
}
cont++;
}

//Presentar Procesos por tiempo
printf(”\nOrden de los tiempos de llegada:”);
for(i=0; i<intNumeroProceso;i++)
{
printf(” |%d| “,intArregloTiempo[i]);
}

// Presentar Acumulacion de las ráfagas
printf(”\nAcumulacion rafagas:\t\t”);
for(i=0; i<intNumeroProceso;i++)
{
intSuma += intArregloAuxiliar[i];
intArregloRafagaAcumulada[i] = intSuma;
printf(”   %d”,intArregloRafagaAcumulada[i]);
}

intSuma = 0;
//Presentar TR por proceso
intArregloSuma[0] = 0;
printf(”\n\n”);
for(i=0; i<intNumeroProceso;i++)
{
intSuma += intArregloAuxiliar[i];
intArregloSuma[i+1] = intSuma;
printf(”\nTR proceso %d: %d”,i+1,intArregloRafagaAcumulada[i]);
}

//Presentar TE por proesos
printf(”\n”);
for(i=0; i<intNumeroProceso;i++)
{
printf(”\nTE proceso %d: %d”,i+1,intArregloSuma[i]-intArregloTiempo[i]);
dblTep += intArregloSuma[i]-intArregloTiempo[i];
dblTrp += intArregloRafagaAcumulada[i];
}
//Presentar Tiempo espera total y tiempo retraso total
printf(”\n\nTEP: %f”,dblTep/intNumeroProceso);
printf(”\nTRP: %f\n\n”,dblTrp/intNumeroProceso);

}

ANALIZANDO EL SISTEMA OPERATIVO SOLARIS Dentro de todas las generaciones que hemos hablado en clases surge un sistema operativo llamado SOLARIS del cual vamos hablar. Solaris es un sistema operativo desarrollado por Sun Microsystems. Es un sistema certificado como una versión de UNIX. Aunque Solaris en sí mismo aún es software propietario, la parte principal del sistema operativo se ha liberado como un proyecto de software libre denominado Opensolaris. Solaris puede considerarse uno de los sistemas operativos más avanzados Dentro de la Historia Este es el primer sistema operativo de Sun nació en 1983 y se llamó inicialmente SunOS. Estaba basado en el sistema UNIX BSD. Más adelante incorporó funcionalidades del System V, convirtiéndose prácticamente en un sistema operativo totalmente basado en System V.Esta versión basada en System V fue publicada en 1992 y fue la primera en llamarse Solaris, más concretamente Solaris 2. Las anteriores fueron llamadas Solaris 1 con efecto retroactivo. SunOS solo tendría sentido a partir de ese momento como núcleo de este nuevo entorno operativo Solaris. De esta forma Solaris 2 contenía SunOS 5.0.  Arquitecturas soportadas Solaris usa una base de código común para las arquitecturas que soporta: SPARC y x86 (incluyendo AMD64/EM64T). También fue portado a la arquitectura PowerPC (en plataforma PReP) en la versión 2.5.1, pero el porte fue cancelado casi tan pronto como fue liberadoSolaris tiene una reputación de ser muy adecuado para el multiprocesamiento simétrico (SMP), soportando un gran número de CPUs. También ha incluido soporte para aplicaciones de 64 bits SPARC desde Solaris 7. Históricamente Solaris ha estado firmemente integrado con la plataforma hardware de Sun, SPARC, con la cual fue diseñado y promocionado como un paquete combinado.De todas formas, también ha soportado sistemas x86 desde la versión Solaris 2.1 y la última versión, Solaris 10, ha sido diseñada con AMD64 en mente, permitiendo a Sun capitalizar en la disponibilidad de CPUs de 64 bits commodities basadas en la arquitectura AMD64. Sun ha promocionado intensamente Solaris con sus estaciones de trabajo de nivel de entrada basadas en AMD64, así como con servidores que en 2006 varían desde modelos dual-core hasta modelos a 16 cores.El código fuente de Solaris (con unas pocas excepciones) ha sido liberado bajo la licencia CDDL (Licencia Común de Desarrollo y Distribución) como un proyecto de software libre bajo el nombre OpenSolaris.La licencia CDDL ha sido aprobada por la Open Source Initiative (OSI) como una licencia open source y por la FSF como una licencia de software libre (aunque incompatible con la popular licencia GPL ).

Solaris 10

Solaris 10 es la versión más reciente de sistema operativo desarrollado por Sun Microsystems. Solaris es en sí software propietario y ahora la parte principal del sistema operativo se ha liberado como un proyecto de software libre denominado OpenSolaris. Esto no es novedad para Sun pues todas las versiones anteriores eran cerradas.

Sun solaris se ejecuta sobre la arquitectura SPARC en 32 y 64 bits (más conocida como Ultra Sparc) o sobre procesadores x86 (incluidos Intel y AMD).

A comienzos del 2005, Sun Microsystems ha sacado a la luz la version 10 (5.10) de su sistema operativo Solaris con nuevas características.

Þ     Predictive Self-Healing

Sun ha insertado en el núcleo del sistema operativo solaris un sistema denominado “Tecnología preventiva de auto recuperación” (PSH, Predictive Self-Healing). Con esta tecnología se reducen los riesgos y aumenta las disponibilidad del equipo, además PSH permite tomar medidas para reducir daños por futuros peligros que puedan causar el caos en los sistemas y como resultado reducir los tiempos de caída, lo cual significa ahorrar tiempo y dinero.ventajas de las características del PSH del sistema operativo

• Disponibilidad de servicio y sistema mejorado a través de un diagnostico y aislamiento de los componentes defectuosos.
• Diagnostico automatico y reinicio de componentes de hardware y software en milésimas de segundo.
• Administración simplificada para administrar servicios.

Þ     DTrace

Artículo principal: DTrace (Sun Microsystems)Denominado también rastreo dinámico, que busca el fondo y llega a la raíz de los problemas de rendimiento en tiempo real. Dicha herramienta trabaja utilizando sondas inteligentes del sistema que pueden acceder a áreas de más lento rendimiento o con cuellos de botella, estas sondas están dispersados por todo el sistema, que ilumina cada rincón oscuro del sistema solaris. Y además permite visualizar mejor la actividad del núcleo y de la aplicación. Y a la vez ofreciendo una visión operativa y una ganancia operativa no superada aun por otro sistema operativo.

Þ     Solaris Containers

Permite la creación de muchos ambientes privados de ejecución e una sola instancia de solaris. Cada ambiente tiene su propia identidad, independiente del hardware subyacente aunque se comporta como si se estuviera ejecutando en su propio sistema, permitiendo así que la consolidación sea un proceso sencillo, confiable y seguro. Y dado que los recursos del sistema están virtualizados, los administradores pueden incrementar la utilización del hardware, al tiempo que satisfacen los altos picos de demanda.

Þ     ZFS, Zettabyte File System

Artículo principal: ZFS (SISTEMAS DE ARCHIVOS)

Es un nuevo sistema de archivos dinámico del sistema operativo Solaris. Ofrece una administración sencilla que automatiza y consolida complicados conceptos de almacenamiento y por otro lado protege todo los datos con sumas de 64 bits que detectan y corrigen el daño de datos silenciosos. Es el primer sistema de archivos de 128 bits, ofrece una capcidad de 16.000 millones de veces superior a la de los sistemas de 32 o 64 bits, virtualmente es el único sistema de archivos con capacidad de almacenamiento prácticamente ilimitada.

Þ     Process rigths management

Solaris 10 ofrece una solución para el modelo de usuario “todo o nada” mediante la integración de minimos privilegios de seguridad directamente dentro de la base del sistema operativo. Gracias a esta nueva función, Solaris se mantiene como el único sistema operativo UNIX que ofrece este modelo de seguridad completamente integrado dentro de sus componentes del núcleo del sistema operativo, cada aplicación Solaris tiene una lista cerrada de los privilegios especificos impuestos por el núcleo, en lugar de un solo privilegio de raíz todopoderoso.Adicionalmente cada servicio Solaris ha sido convertido para que utilice sólo los privilegios mínimos necesarios, lo cual hace aún más difícil violar el sistema y utilizar los servicios. Los administradores pueden asignar grupos de privilegios por funciones para diferentes tipos de administradores y desarrolladores.Libre de virus por más de 20 años, Solaris incluye la tecnología del Trusted Tolaris ampliamente utilizada por el gobierno de los Estados Unidos para garantizar la seguridad de sus sistemas.

Þ     Sun Update Connection

Utilizando solaris 10 los usuarios disponen de un servicio de actualizaciones que les permitirá estar al día con las innovaciones y el entorno del nuevo ambiente operativo.

Leopoldo Capa

18/04/2008

Algoritmo de Planificación SJF en C

Integrantes
Cabrera Karla
Pulla Cinthia
Ramos Jammil