Práctica

ENUNCIADO

La práctica que hay que realizar y que no hay que entregar consiste en generar una serie de procesos cuyas relaciones familiares sigan el esquema siguiente:

Como veis, un padre tiene dos hijos, uno de ellos tiene otros dos hijos, uno de los cuales tiene un hijo. Cuando nace un proceso, crea los hijos que le corresponda crear, duerme cinco segundos para descansar del esfuerzo procreador, espera por la muerte y va sumando los códigos de retorno de sus hijos. Al resultado de la suma le suma, a su vez, la última cifra de su PID. El proceso imprimirá un mensaje del estilo al siguiente:

Soy un proceso nieto (PID=23879). Mi suma es 69.
Soy el proceso padre (PID=23807). Mi suma es 137.

Al acabar, el proceso devuelve un código de retorno igual a la suma previamente calculada. De este modo, el padre de todos los procesos conocerá la suma de las últimas cifras del PID de todos sus descendientes, incluído él mismo.

Nota: no creo que suponga ningún esfuerzo hallar la última cifra de un número, pero, por si acaso, podéis obtenerlas calculando el resto de dividir el número por 10.

COMENTARIOS

La práctica con 0.25 es la de Goku y Son Gohan:

#define _HPUX_SOURCE

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>

void espera(int,char *,int);

int main(int argc,char *argv[])
{
   int pid,retorno,retorno2,i,devolver=0;
   
   if(argc != 1)
      {
      fprintf(stderr,"Uso: %s\n\n",argv[0]);
      return 1;
      }
   
   /* Observad cómo el sangrado reproduce el árbol genealógico. */
   switch(fork())/*primer hijo*/
      {
      case -1:perror("pract4:fork");
              return 2;
      case 0:espera(0,"primer hijo",0);
      }
   switch(fork())/*segundo hijo*/
      {
      case -1: perror("pract4:fork");
               return 3;
      case 0:switch(fork())/*primer nieto*/
                {
                case -1:perror("pract4:fork");
                        return 4;
                case 0:espera(0,"primer nieto",0);
                }
             switch(fork())/*segundo nieto*/
                {
                case -1:perror("pract4:fork");
                        return 5;
                case 0:switch(fork())/*bisnieto*/
                          {
                          case -1:perror("pract4:fork");
                                  return 6;
                          case 0: espera(0,"bisnieto",0);
                          }
                       espera(1,"segundo nieto",1);
                }
             espera(2,"segundo hijo",1);
      }
   espera(2,"padre",1);
}

void espera (int i,char *parentesco,int dormir)
{
   int pid,retorno,retorno2,j;

   if(dormir)sleep(5);

   pid=getpid();
   if(pid==-1)
      {
      perror("pract5:getpid");
      exit(1);
      }

   retorno=pid%10;
   for(j=0;j<i;j++)
      {
      if(wait(&retorno2)==-1)
         {
         perror("pract4:wait");
         exit(1);
         }     
      if(WIFEXITED(retorno2))
         retorno=retorno+WEXITSTATUS(retorno2);
      else
         {
         perror("pract4:WIFEXITED");
         exit(0);
         }
      }
   printf("Soy el %s(pid=%d)y mi suma es: %d \n",parentesco,pid,retorno);
   exit(retorno);
}

MENCIONES ESPECIALES

De Thor´s Storms´ Productions (formado por Thor y Storms) (0.1 ptos.): La solución es original, aunque contiene un error en la espera de los hijos (hay que procrear, dormir y esperar por todos después)...

#define _HPUX_SOURCE

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/wait.h>

int main(int argc, char * argv[] )
{
   char generacion[9];
   int suma;

   /*Primera ejecucion o numero de parametros incorrectos*/
   if(argc!=3) 
   {
       strcpy(generacion, "CREATOR"); /* Como Terminator y kelvinator :) */
   }
   
   else 
   {
       /*Obtenemos el valor de generacion*/
       strcpy(generacion, argv[2]);
  
       /*Actualizamos la generacion*/
       if(strcmp(generacion, "CREATOR")==0)
       {
           strcpy(generacion, "ABUELO");
       }

       else if(strcmp(generacion, "ABUELO")==0)
       {
           strcpy(generacion, "PADRE");
       }

       else if(strcmp(generacion, "PADRE")==0)
       {
           strcpy(generacion, "HIJO");
       }

       else
       {
           fprintf(stdout, "error: generacion no valida\n");
           fflush(stdout);

           exit(1);
       }
   }              

   /*Aportacion propia a la suma*/
   suma=(getpid()%10);

   fprintf(stdout, "Mi generacion es %s, mi pid %i y mi suma es %i\n", generacion, getpid(), suma);
   fflush(stdout);

   /*Si procrea*/
   if((!strcmp(generacion, "CREATOR"))||(!strcmp(argv[1], "PROCREA")))
   {
       pid_t hijo1;
       /*Tener hijo 1*/
       if((hijo1=fork())==-1)
       {
           perror("fork");
          
           exit(1);
       }

       /*Proceso hijo1*/
       else if(hijo1==0)
       {
           /*hijo no procreador*/
           execl(argv[0], argv[0], "NO_PROCREA", generacion, NULL);
       }
     
       /*Proceso padre*/
       else
       {
           int status1;

           sleep(5);

           /*Si no es el PADRE*/
           if(strcmp(generacion, "PADRE"))
           {
               pid_t hijo2;
               int status2;

               /*A por la parejita*/
               if((hijo2=fork())==-1)
               {
                   perror("fork 2");
                   
                   exit(1);
               }
               
               /*Hijo2*/
               else if(hijo2==0)
               {
                   /*hijo procreador*/
                   execl(argv[0], argv[0], "PROCREA", generacion, NULL);
               }
     
               /*Codigo de un padre que no sea PADRE*/
               waitpid(-1, &status2, 0);
               suma=suma+WEXITSTATUS(status2);
           }    
         
           sleep(5);

           /*Esperamos el codigo de retorno de los hijos*/
           waitpid(-1, &status1, 0);
           suma=suma+WEXITSTATUS(status1);

       }        

   }
   
   fprintf(stdout, "Hasta mi, %i, de generacion %s, suma=%i\n", getpid(), generacion, suma);
   fflush(stdout);

   /*Devolvemos la ultima cifra del pid*/
   return suma;

}