/*
    Este programa intenta ser una pequeña muestra del funcionamiento de un planificador Round Robin
    ----------------------------------------------------------------------------   
    Un proceso padre crea n procesos en abanico.
    El proceso padre cumple la funcion de ser un proceso planificador de procesos Round Robin.
    El proceso planificador le asigna cinco segundos de ejecucion a cada proceso 
           hijo en el orden en el cual fueron creados.
    La ejecucion de los procesos hijos solo muestra por pantalla su PID.
    ----------------------------------------------------------------------------
    Se usa la señal SIGALRM para representar el quantum de tiempo del planificador RR,
    El padre setea la alarma (quantum) para enviar la señal SIGALRM cada 5 segundos, cuando se  
   cumple el tiempo, la alarma interrumpe y el planificador detiene el proceso hijo que esta en ejecucion
    y pone en ejecucion al siguiente hijo en forma de rueda circular.
    ----------------------------------------------------------------------------
    Se usa la señal SIGSTOP para detener el proceso en background y la señal SIGCOINT
    para reanudar su ejecucion en foreground.
*/


// para ejecutar el codigo hay que pasarle desde la linea de comando la cantidad de 
// procesos hijos que se van a crear, por ejemplo si compilo con
// $ cc planRR.c
// ejecutar
// con $ ./a.out 5

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>

void FuncionAlarma(void) ; // funcion que se ejecuta cuando se recibe la señal SIGALRM	

int numproces ; // cantidad de procesos hijos
pid_t vecpid[100]; // vector de pids de procesos
int ent; // indice del vector de pids de procesos

int main(int argc, char **argv) //prototipo de la funcion main que le permite recibir argumentos desde la linea de comandos
{
   pid_t pid  ; // variable pid retornada por el fork()
   int i ;
   numproces = atoi(argv[1]); //convierte en entero lo que recibio en string desde linea de comandos y lo almacena en la variable 
   
   for ( i = 0 ; i < numproces ; i++) // ciclo creador de procesos hijos en abanico
    {
       pid = fork() ;
       if (pid == 0) break; // el hijo creado sale del ciclo 
       vecpid[i] = pid;
    } 

    if (i == numproces ) // cuando i = numproces es el padre y ya creo todos los hijos 
    { // codigo que ejecuta el padre
      sleep(1) ; //magico romerizado     
      signal(SIGALRM, (void *) FuncionAlarma) ; // el padre realaciona la señal SIGALRM
                                                // con la funcion FuncionAlarma
      printf(" \n\n  Padre i = %d pid %d Administrando RR \n",i,getpid()); //cuestiones del codigo para darle color a la salida por pantalla
      ent = 0 ;
      while(1) // ciclo de ejecucion del padre
       {
           printf(" \n\n  Padre reanuda al  hijo %d pid = %d \n",ent,vecpid[ent]);
           kill(vecpid[ent],SIGCONT) ; // el padre pone le da continuacion de ejecucion al hijo vecpid[ent]
                                       // enviandole la señal SIGCONT
           alarm(5) ; // setea la señal SIGALRM para que sea enviada a los 5 segundos.
           printf(" ----------------Padre pausado\n");
           pause() ; // el padre se pausa esperando la señal SIGALRM
           ent = ( ent + 1 ) % numproces ; // ent queda apuntando al proximo proceso 
       } 
    }
    else
    { //codigo que ejecutan los hijos
       printf("\n --------- hijo i = %d pid %d detenido en background \n",i,getpid());       
       raise(SIGSTOP); // el hijo se detiene en background enviandose la senial a si mismo
       while(1) // ciclo de ejecucion del hijo
           {
             printf(" --------------- hijo i = %d pid %d ejecutando \n\n",i,getpid());
             int i ;
             for( i = 1 ; i < 6 ; i++ ) { printf(" %d\n",getpid()) ; sleep(1) ;}
           }
    }
    exit(0) ; 
}

void FuncionAlarma(void)
{
           printf("----------Padre detiene en background %d  al hijo pid = %d\n\n",ent , vecpid[ent]);
           kill(vecpid[ent],SIGSTOP) ; //el padre detiene en background al  hijo vecpid[ent]                     
}