JERARQUIA DE PROCESOS RESULTANTE

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).

Señala que todos los procesos

hijos ejecutan la aplicaci´on kcalc y que la ejecuci´on de xload nunca se

produce.

wait que cambia el estado del proceso padre a bloqueado hasta que el proceso hijo termine.

Se observa que los procesos terminan en el orden contrario al que se han creado, es decir, primero termina el ´ultimo proceso creado y el ´ultimo proceso en terminar es el inicial. Esto ocurre gracias a la llamada al sistema

ACTIVIDAD 1

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.

Código:

#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 = rand()%25+1;
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 en ejecucion de kcalc: %ld\n", (rand()%50+1)-ini);
}
printf ("Tiempo total: %ld\n", (rand()%25+1)-ini);
return 0;
}

PRACTICAS 1-15

Practica 1 Matando un proceso en modo grafico

Practica 2 Matando un proceso por línea de comandos

Practica 3 Matando un proceso por medio de scripts

Practica 4 Ver los procesos de usuario desde línea de comandos

Practica 5 Mostrando los porcentajes de uso de memoria de los procesos

Practica  6 Ejecución de procesos de manera concurrente

Prac7 Uso del comando jobs (viendo estado de procesos)

Practica 8 Pausar tareas y 9 Muestra de reinicio de procesos

Practica 10 Crear una lista FIFO

Practica 11 Agregando un proceso a una lista FIFO

Practica 12 Creado listas con mknod

PRACTICA 13 Observar listas de procesos creadas hasta ahora

PRACTICA 14  Eliminando una lista

Practica 15 Ver árbol de procesos

LIFO Y FIFO

FIFO
(primero en llegar primero en salir)

se utiliza en estructuras de datos para implementar colas. La implementación puede efectuarse con ayuda de arrays o vectores, o bien mediante el uso de punteros yasignación dinámica de memoria.

Si se implementa mediante vectores el número máximo de elementos que puede almacenar está limitado al que se haya establecido en el código del programa antes de la compilación (cola estática) o durante su ejecución (cola pseudoestática ó dinámica). Sea cual sea la opción elegida, el número de elementos que podrá almacenar la cola quedará determinado durante toda la ejecución del programa. Así, el sistema debe reservar el tamaño de memoria necesario para acoger todos los datos, sea cual sea el número de elementos usados.

En algunas aplicaciones, esto supone un problema ya que puede desconocerse el número de elementos a contener en la cola. La sencilla solución de reservar más memoria de la que se supone que se necesitará, puede conducir a un despilfarro de la memoria (la cola puede esté llena, aprovechando toda la memoria reservada; o bien, nunca terminar de llenarse, ocupando recursos innecesarios en memoria). Sin embargo, si se usa asignación dinámica de memoria, el número máximo no está declarado en tiempo de compilación sino en tiempo de ejecución, es decir, se reserva memoria a medida que se necesite expandir el tamaño de la cola (adaptándose al tamaño necesario en cada momento en función de los elementos que hay en la cola), haciendo un mejor uso de la memoria disponible.

Uno de los usos de las colas es la exploración "en anchura" de un árbol binario de búsqueda. Otro uso típico de las colas, es la gestión de descargas de una aplicación P2P.

LIFO

estructura  LIFO  (ultimo en entrar primero en salir).

Podemos comparar esta estructura con una pila de platos colocada sobre un muelle. Cuando

se añade un nuevo plato en lo alto de la pila, los demás bajan, cuando se retira un plato de la pila,

los demás suben.igual que en el caso de las colas, van a existir dos punteros, uno que indica la posición tope

de la pila, denominado puntero de pila, y otro que señala su base, denominado  base de pila,   y que mantiene el mismo valor mientras existe la pila. Cuando la pila esta vacía el puntero de pila tiene el mismo valor que la base de pila.

La pila es una de las estructuras más importantes en computación. Se usa en cálculos, para

pasar de un lenguaje de computador a otro y, para transferir el control de una parte del programa

a otra.

EXAMEN

#include "rshmem.h"
#include <stdlib.h>
#include <sys/sem.h>
#include <math.h>
#include <time.h>
#define N 5 
typedef int semaphore;                                                    
int state[N];                                                             
semaphore mutex=1;                                                        
semaphore s[N];                                                           
viod philosopher(int i)                                                   
{
 incrementa (int *mem, int k){
int i;
i=*mem;
TP ; TP ; TP TP ;
TP ; TP TP ; TP ;
TP TP ; TP ; TP
i=i+k;
TP ; TP ; TP TP ;
TP ; TP TP ; TP ;
TP TP ; TP ; TP
*mem=i;

 }

filosofo(FILE *pf, key_t *sclave, int *sfilo, int i, int *comer, int *fin, int *fc){
while (true){                                                             
think();                                                                  
take_forks(i);                                                            
eat();                                                                    
put_forks(i);                                                             
}
}
void take_forks(int i)                                                    
{
down(&mutex);                                                             
state[i] = HUNGRY;                                                        
test(i);                                                                  
up(&mutex);                                                               
down(&s[i]);                                                              
}                                                                                   
void put_forks(i)                                                         
{                               
down(&mutex);                                                             
state[i] = THINKING;                                                      
test(LEFT);                                                               
test(RIGHT);                                                              
up(&mutex);                                                               
}
void test(i)                                                              
{
if(state[i] == HUNGRY && state [LEFT]!= EATING && state [RIGHT]!=EATING){
state[i]=EATING;
up(&s[i]);
}
}

Practica num Aleatorios

#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 tube1[2], int tube2[2]){
    int ret;
    int minumero;

    int numbytes;
    char buf[256]={};

    ret = fork();

        if (ret == 0){
            /*Tratamiento del nieto*/
            //minumero = aleatorio();
            minumero= 10;

            printf("%d\n",minumero);
            sprintf(buf,"%d",minumero);

            if( write (tube1[escritura],buf, sizeof(buf)) == -1){
                perror("Fallo write nieto");
                exit(EXIT_FAILURE);
            }

            numbytes = read(tube2[lectura],buf,sizeof(buf));

            if (numbytes == -1){
                perror("Fallo read nieto");
                exit(EXIT_FAILURE);
            }



            close(tube1[escritura]);
            close(tube2[lectura]);

            printf("Soy hijo2 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);


        }

        else if (ret > 0){
            /*Tratamiento del padre*/

            //minumero = aleatorio();
            minumero=32;

            printf("%d\n",minumero);
            sprintf(buf,"%d",minumero);

            if( write (tube2[escritura],buf, sizeof(buf)) == -1){
                perror("Fallo write padre");
                exit(EXIT_FAILURE);
            }

            numbytes = read(tube1[lectura],buf,sizeof(buf));

            if (numbytes == -1){
                perror("Fallo read padre");
                exit(EXIT_FAILURE);
            }




            close(tube1[lectura]);
            close(tube2[escritura]);

            printf("Soy hijo1 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);
        }

        else if (ret == -1){
            /*Error*/
            perror("Fallo en el segundo fork");
            exit(EXIT_FAILURE);           
        }
}

int main (void){
    int ret;
    int ret2;
    int tube1[2];
    int tube2[2];
    int temp;
    int e;
    char buf[256]={};

    if (pipe(tube1) == -1){
        perror("Fallo pipe1");
        exit(EXIT_FAILURE);
    }

    if (pipe(tube2) == -1){
        perror("Fallo pipe2");
        exit(EXIT_FAILURE);
    }

    ret = fork();

    if (ret == 0){
        /*tratamiento del hijo*/
        hijo(tube1,tube2);

    }

    else if( ret > 0){
        /*tratamiento del abuelo*/


    }

    else if (ret == -1){
        /*error*/
        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

Es el acrónimo de Portable Operating System Interface; la X viene de UNIX como seña de identidad de la API.

El término fue sugerido por Richard Stallman en respuesta a la demanda de la IEEE, que buscaba un nombre fácil de recordar. Una traducción aproximada del acrónimo podría ser "Interfaz de sistema operativo portable".

POSIX.1, Core Services (implementa las llamadas del ANSI C estándar). Incluye:

• Creación y control de procesos.
• Señales.
• Excepciones de punto flotante.
• Excepciones por violación de segmento.
• Excepciones por instrucción ilegal.
• Errores del bus.
• Temporizadores.
• Operaciones de ficheros y directorios (sobre cualquier fs montado).
• Tuberías (Pipes).
• Biblioteca C (Standard C).
• Instrucciones de entrada/salida y de control de dispositivo (ioctl).

TOTALMENTE POSIX-COMPATIBLES

Los siguientes Sistemas Operativos son 100% compatibles con uno o varios estándares POSIX.

• A/UX
• AIX
• BSD/OS
• DSPnano
• HP-UX
• INTEGRITY
• IRIX
• LynxOS
• Mac OS X v10.5 en Procesadores Intel.
• MINIX
• MPE/iX
• QNX (IEEE Std. 1003.13-2003 PSE52;
• RTEMS (POSIX 1003.1-2003 Profile 52)
• Solaris
• Unison RTOS
• UnixWare
• velOSity
• VxWorks (IEEE Std. 1003.13-2003 PSE52

Listado de Código 1.2: Ejemplo de programa con hilos POSIX

#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); }