PRACTICA 2

Estudia el siguiente codigo y escribe la jerarquia de procesos resultante.
Despues, compila y ejecuta el codigo para comprobarlo (deberas añadir llamadas al sistema getpid, getppid y wait para conseguirlo).

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#define L1 2
#define L2 3
int main ()
{
int cont1, cont2;
pid_t pid;
for (cont2= 0; cont2< L2; cont2++)
{
for (cont1= 0; cont1< L1; cont1++)
{
pid= fork();
if (pid== 0)
break;
}
if (pid!= 0) break;
}
printf ("Soy el hijo: %d y Mi padre es: %d.\n", getpid(), getppid());
if (pid!= 0)
for (cont1= 0; cont1< L1; cont1++)
printf ("Fin del proceso%d.\n", wait (NULL));
return 0;
}

DIAGRAMA  DE ARBOL

JERARQUIA DE PROCESOS

Dibuja la jerarquía de procesos que resulta de la ejecución del siguiente código. Introduce las llamadas al sistema wait para que una vez generado el árbol de procesos los hijos sean esperados por sus respectivos padres. Ademas,  haz que se informe de los tiempos de ejecución de las aplicaciones  xload y

 kcalc que se generen así como del tiempo total de ejecución. Para calcular el  tiempo transcurrido, puedes utilizar la función´ time() de la librería estándar  time.h. La llamada time(NULL) devuelve los segundos transcurridos desde

 las 00:00:00 del 1/1/1970 hasta el instante de la llamada.

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

int main (int argc, char *argv[]) {

int i, j;
pid_t pid, nuevo, nuevo1;
time_t ini, fin;
ini= time(NULL);
for (i= 0; i< 2; i++){
pid= getpid();
for (j= 0; j< i+2; j++){
nuevo= fork();
if(nuevo== 0){
break;
nuevo1= fork();
if(nuevo1== 0)
execlp ("xload", "xload", NULL);
}
}if (pid!= getpid())
execlp ("kcalc", "kcalc", NULL);
}
for (i= 0; i< 2; i++)
for (j= 0; j< i+2; j++){ wait(NULL);
}
printf ("Tiempo total: %ld\n", time(NULL)-ini);

printf("soy el hijo %d y mi padre es %d\n",getpid(),getppid());
sleep(3);
return 0;

}

DIAGRAMA DE JERARQUIA DE PROCESOS

PRACTICA5

#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#define lectura 0
#define escritura 1
 
 
int aleatorio(void)
{
       int semilla = (int)time(NULL);
       srand(semilla);
}
 
int hijo(int tub1[2], int tub2[2]){
    int ret;
    int mi_num;
 
    int nu_byte;
    char buf[256]={};
 
    ret = fork();
 
        if (ret == 0){
            /*Tratamiento del nieto*/
            //minumero = aleatorio();
            mi_num= 10;
 
            printf("%d\n",mi_num);
            sprintf(buf,"%d",mi_num);
 
            if( write (tub1[escritura],buf, sizeof(buf)) == -1){
                perror("Fallo write nieto");
                exit(EXIT_FAILURE);
            }
 
            nu_byte = read(tub2[lectura],buf,sizeof(buf));
 
            if (nu_byte == -1){
                perror("Fallo read nieto");
                exit(EXIT_FAILURE);
            }
 
 
 
            close(tub1[escritura]);
            close(tub2[lectura]);
 
            printf("Soy hijo1 con PID=%d, mi numero aleatorio es %d y el del otro proceso es %s\n\n",getpid(),mi_num,buf);
 
 
        }
 
        else if (ret > 0){
            /*Tratamiento del padre*/
 
            //minumero = aleatorio();
            mi_num=12;
 
            printf("%d\n",mi_num);
            sprintf(buf,"%d",mi_num);
 
            if( write (tub2[escritura],buf, sizeof(buf)) == -1){
                perror("Fallo write padre");
                exit(EXIT_FAILURE);
            }
 
            nu_byte = read(tub1[lectura],buf,sizeof(buf));
 
            if (nu_byte == -1){
                perror("Fallo read padre");
                exit(EXIT_FAILURE);
            }
 
 
 
 
            close(tub1[lectura]);
            close(tub2[escritura]);
 
            printf("Soy hijo2 con PID=%d, mi numero aleatorio es %d y el del otro proceso es %s\n\n",getpid(),mi_num,buf);
        }
 
        else if (ret == -1){
           
            perror("Fallo en el segundo fork");
            exit(EXIT_FAILURE);           
        }
}
 
int main (void){
    int ret;
    int ret2;
    int tub1[2];
    int tub2[2];
    int temp;
    int e;
    char buf[256]={};
 
    if (pipe(tub1) == -1){
        perror("Fallo pipe1");
        exit(EXIT_FAILURE);
    }
 
    if (pipe(tub2) == -1){
        perror("Fallo pipe2");
        exit(EXIT_FAILURE);
    }
 
    ret = fork();
 
    if (ret == 0){
       
        hijo(tub1,tub2);
 
    }
 
    else if( ret > 0){
       
 
 
    }
 
    else if (ret == -1){
        perror("Fallo en fork");
        exit(EXIT_FAILURE);
    }
 
    ret = wait (NULL);
 
    while (ret > 0){
        ret = wait(NULL);
    }
 
    if (ret == -1 && errno != ECHILD){
        perror("Fallo en wait");
        exit (EXIT_FAILURE);
    }
 
}

POSIX

¿QUE ES POSIX ?

Se define una interfase portable para aplicaciones basadas en el popular sistema operativo UNIX

del UNIX. Una parte importante del POSIX aborda las necesidades de las aplicaciones de tiempo real. La portabilidad de estas aplicaciones es hoy en día prácticamente imposible

debido a la gran cantidad de sistemas operativos y núcleos de tiempo real existentes.

(Portable Operating System Interface para UNIX). Familia de estándares relacionados especificados por la IEEE para definir APIs para la compatibilidad de software  entre los diferentes sistemas operativos Unix. El término "POSIX" fue sugerido por Richard Stallman en respuesta a un requerimiento de la IEEE, que deseaba un nombre memorable.

La familia  de estándares POSIX es formalmente designada como IEEE 1003, y el nombre del estándar internacional ISO es ISO/IEC 9945.

Si los diseñadores de programas se adecúan a POSIX, sus aplicaciones podrán ejecutarse en cualquier sistema operativo compatible con POSIX.

Los sistemas operativos que soportan POSIX son:
* A/UX
* AIX
* BSD/OS
* HP-UX
* INTEGRITY
* Irix
* LynxOS
* Mac OS X
* MINIX
* OpenVMS
* QNX
* RTEMS (POSIX 1003.1-2003 Profile 52)
* Solaris
* OpenSolaris
* UnixWare
* VxWorks
* Windows con kernel NT (usados en Windows NT, 2000, 2003; XP, Vista): sólo en algunas ediciones o con determinadas aplicaciones instaladas.

¿DONDE SE USA?

Se estableció en el POSIX un grupo de trabajo de tiempo real. Este grupo desarrolla estándares para añadir al POSIX básico (o UNIX) los servicios de sistema operativo necesarios para poder desarrollar aplicaciones de tiempo real. Estas aplicaciones se

caracterizan porque el funcionamiento correcto no sólo depende de los resultados del cálculo, sino también del instante en el que se generan estos resultados. Con objeto de garantizar que los cálculos se realizan en los instantes requeridos, es preciso que el sistema de tiempo real tenga un comportamiento temporal predecible, y para ello, es preciso también que los servicios del sistema operativo sean capaces de proporcionar el nivel de servicio requerido con un tiempo de respuesta acotado. El objetivo principal del grupo de trabajo de tiempo real del POSIX es "desarrollar estándares que sean los mínimos cambios y adiciones a los estándares POSIX para soportar la portabilidad de

aplicaciones con requerimientos de tiempo real".

EJEMPLO

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

void *thread_function(void *arg) {
  int i;
  for ( i=0; i<20; i++ ) {
    printf("Thread says hi!\n");
    sleep(1);
  }
  return NULL;
}

int main(void) {

  pthread_t mythread;

  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) {
    printf("error creating thread.");
    abort();
  }

  if ( pthread_join ( mythread, NULL ) ) {
    printf("error joining thread.");
    abort();
  }

  exit(0);

}

2. El principal objetivo de este estándar es la portabilidad de las aplicaciones a nivel de código fuente, mediante la unificación de las diferentes versiones

NUMERO DEL EJERCICIO A ESCOGER

ESCOJO ES NUMERO 7 DE LOS EJERCICIOS

PRACTICA4

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


#define NUM_HIJOS 2//
int main(void)
{
int ret,i;

    for(i=1;i<=NUM_HIJOS;i++)
    {
    ret=fork();
    if(ret==0)
    {
printf("Yosoy el hijo %d mi padre es PID: %d,Yo soy PID= %d \n\n",i,getppid(),getpid());

if(i==2){
printf("Soy el hijo 3 mi proceso es= %d ", getpid());}

}
else if(ret>0)
{
ret=wait(NULL);
while(ret>0){
ret=wait(NULL);
}
if (ret==-1 && errno != ECHILD)
{
perror("fallo en wait");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
else if(ret== -1){
perror("fallo el fork");
exit(EXIT_FAILURE);
}
}
}

PRACTICA 3

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


#define NUM_HIJOS 3//
int main(void)
{
int ret,i;

    for(i=0;i<NUM_HIJOS;i++)
    {
    ret=fork();
    if(ret==0)
    {
printf("Yosoy el hijo %d mi padre es PID: %d,Yo soy PID= %d",i,getppid(),getpid());
}
else if(ret>0)
{
ret=wait(NULL);
while(ret>0){
ret=wait(NULL);
}
if (ret==-1 && errno != ECHILD)
{
perror("fallo en wait");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
else if(ret== -1){
perror("fallo el fork");
exit(EXIT_FAILURE);
}
}
}