Páginas

NIMADRES

Mostrando entradas con la etiqueta simulacion. Mostrar todas las entradas
Mostrando entradas con la etiqueta simulacion. Mostrar todas las entradas

Simulacion de procesos (Round Robin) en C++


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-Roubin 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". Es 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.

Eh aquí un sencillo algoritmo en C++ que nos ayudara a comprender un poco mejor como funciona este proceso.


#include <iostream>
#define limite 5
using namespace std;

void insertar(char datos[], int tiempo[], int numero){
     for(int i = 0; i < (numero); i++){
         cout<<"inserte el tiempo en el proceso ["<<datos[i]<<"]: ";
         cin>>tiempo[i];
     }
}

int quantum(int tiempo[],int numero){
    int resultado = 0;
    for(int i = 0; i < numero;++i)
      resultado += tiempo[i];
    resultado /= numero;
    return resultado;
}

void RoundRobin(char datos[], int tiempo[], int numero){
    insertar(datos,tiempo, numero);
    int Quantum = quantum(tiempo,numero);
    cout<<"El quantum es: "<< Quantum <<endl;
    int tiempoFinal = 0;
    float sumatoria = 0.0f;
    int metalera = 0;
    int i = 0;
    do{ 
      tiempo[i] != 0 ? tiempo[i] -= Quantum : ++i;
      if(tiempo[i] > 0)
          tiempoFinal += Quantum;
      else{
          tiempoFinal += Quantum+tiempo[i];
          sumatoria += tiempoFinal;
          cout << "el tiempo de proceso de " << datos[i] << ": " 
          << tiempoFinal << endl;
          metalera++;
      }
      i < (numero - 1) ? i++ : i = 0;
    }while(metalera < numero);
    sumatoria /= numero;
    cout << "Tiempo promedio de los procesos es: " 
    << sumatoria << endl;
}


int main(){
    char datos[limite] = {'a','b','c','d','e'};
    int tiempo[limite];
    RoundRobin(datos,tiempo,limite);
    cin.get();
    cin.get();
    return 0;
}

Simulacion de Procesos (Primero Mas Corto) en C++

Otra forma de reducir el sesgo favorable al proceso más largo inherente al FCFS es la política de primero el proceso más corto (SPN, Shortest Process Next), una política no apropiativa en la que se selecciona el proceso con menor tiempo esperado de ejecución. Así pues, un proceso corto saltará a la cabeza de la cola, sobrepasando a trabajos largos.


en este seria básicamente como el FIFO, solo con la pequeña diferencia de tener que acomodar los procesos por el menor tiempo. en este caso yo utilice el ordenmiento rapido para que se acomodara el arreglo del menor a mayor.


#include <iostream>

using namespace std;

#define limite 5
int cont;

void insertar(char datos[],int tiempo[],int l){
    for(int i = 0; i < (l); i++){
        cout << "inserte el tiempo en el proceso [" << datos[i] << "]: ";
        cin >> tiempo[i];
        system("cls");
    }
}
void swap(char datos[],int tiempo[], int i, int j) {
    int auxChar = datos[i];
    int aux = tiempo[i]; 
    datos[i] = datos[j];
    tiempo[i] = tiempo[j];
    datos[j] = aux;
    tiempo[j] = auxChar;
}

void OrdenamientoRapido(char datos[],int tiempo[], int inf, int sup) {
    if (sup > inf) {
        int pivote = tiempo[sup];
        int i = inf - 1;
        int j = sup;
        do {
            while (tiempo[++i] < pivote);
            while (tiempo[--j] > pivote);
            if (i < j) 
               swap(datos,tiempo, i, j);
        } 
        while (i < j);
        swap(datos,tiempo, i, sup);
        OrdenamientoRapido(datos,tiempo, inf, i-1);
        OrdenamientoRapido(datos,tiempo, i+1, sup);
    }
}

int OrdenamientoRapido(char datos[],int tiempo[], int numero) { 
    cont = 0;
    OrdenamientoRapido(datos, 0, numero-1);
    return cont;
}


void primeroMasCorto(char datos[],int tiempo[], int l){
    int intercambio; 
    int tiempoTotal=0;
    float tiempoReturn=0;
    insertar(datos,tiempo,l);
    OrdenamientoRapido(datos,tiempo,0,l);
    for(int j = 0;j < l; j++){
        tiempoTotal += tiempo[j];
        tiempoReturn += tiempoTotal;
        cout<<"\n""tiempo de retorno ["<<datos[j]<<"]: "<<tiempoTotal<<"\t";
    }      
    tiempoReturn = tiempoReturn / l;
    cout<<"\n\nEl tiempo de las entradas son: "<<tiempoReturn;
}

int main(){
    system("title PRIMERO MAS CORTO");
    system("color 0e");
    cout<<"\t\t\tSimulacion proceso de Primero mas Corto en C++"<<endl;
    cout<<"\t\t_______________________________________\n"<<endl;
    char datos[limite] = {'a','b','c','d','e'};
    int tiempo[limite];
    primeroMasCorto(datos,tiempo,limite);
    cin.get();
    cin.get();
    return 0;
}

Simulacion de Procesos (FIFO) en C++


FIFO: First In First Out


Mecanismo de scheduling en el cual los procesos se ordenan en una fila, en la cual se ejecutan cada uno de los procesos hasta su finalizacion secuencialmente. Es tremendamente ineficiente.
Cuando se tiene que elegir a qué proceso asignar la CPU se escoge al que llevara más tiempo listo. El proceso se mantiene en la CPU hasta que se bloquea voluntariamente.
Para implementar el algoritmo sólo se necesita mantener una cola con los procesos listos ordenada por tiempo de llegada. Cuando un proceso pasa de bloqueado a listo se sitúa el último de la cola.
Esta vez mostrare un pequeño código en el cual pueden ver que de hecho el proceso FIFO es uno de los mas fáciles ya que el primero que entra es el primero que sale, tal y como lo dice en su nombre en ingles.


#include <iostream>

using namespace std;

#define limite 5
void insertar(char datos[],int tiempo[],int l){
    for(int i = 0; i < (l); i++){
        cout << "inserte el tiempo en el proceso [" << datos[i] << "]: ";
        cin >> tiempo[i];
        system("cls");
    }
}
void fifo(char datos[],int tiempo[], int l){
    int tiempoTotal = 0;
    float tiempoReturn = 0.0f;
    insertar(datos,tiempo, l);
    for(int j = 0;j < l; j++){
        tiempoTotal += tiempo[j];
        tiempoReturn += tiempoTotal;
        cout <<"\n""tiempo de retorno de["<<datos[j]<<"]: "<<tiempoTotal<<"\t";
    }
    tiempoReturn = tiempoReturn / l;
    cout<<"\nEl tiempo de las entradas son: "<<tiempoReturn;
}
int main(){
    cout<<"\t\t\tSimulacion de FIFO en C++"<<endl;
    cout<<"\t\t_______________________________________\n"<<endl;
    char datos[limite] = {'a','b','c','d','e'};
    int tiempo[limite];
    fifo(datos,tiempo,limite);
    cin.get();
    cin.get();
    return 0;
}