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 argc, char *argv[]) {

  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 proceso de PID %d y mi padre tiene %d de PID.\n",getpid(), getppid());
if (pid!= 0)
for (cont1= 0; cont1< L1; cont1++)
printf ("Fin del proceso de PID %d.\n", wait (NULL));
return 0;
}

JERARQUIA DE PROCESOS xload y kcalc

PRESENTADO POR: Juan Carlos Basilio Orozco
SISTEMAS OPERATIVOS
1701

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.

DIFERENCIA ENTRE FIFO Y LIFO

La pila es una estructura de datos abstracta de tipo LIFO (Last In, First Out). Es decir que el último elementro a ingresar, es el primero en salir. Un ejemplo típico es cuando uno limpia los platos y los va apilando.
A medida que se van ingresando elementos, se enciman y por tanto, para llegar a "sacar" el primero, primero tienen que salir en el orden inverso de ingreso: por el más encima de la pila.

En cambio, una fila (mejor conocido como cola) es una estructura de tipo FIFO (Fist In, First Out). Es decir, el primero en entrar, primero en salir. El ejemplo evidente y sencillo es cualquier cola o fila que se forma en las entidades bancarias o establecimiento. Los elementos de la cola o fila van saliendo a medida en que ingresan.

¿Cuál es mejor? Ninguna. Cada estructura de datos se emplea en muchas situaciones y por ello ninguna es superior sobre la otra. Cada una tiene sus aplicaciones.

PARTE 3 DEL EXAMEN PROBLEMA DE LOS FILOSOFOS Y SUS PALILLOS 




CODIGO


#include <stdio.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define NUM_FILOSOFOS 5

#define PENSANDO 0
#define COMIENDO 1

#define LIBRE 1
#define USADO 0

typedef struct datos_filosofos {
int filosofos[NUM_FILOSOFOS];
int pids[NUM_FILOSOFOS];
int semaforo_id,semaforo_id2;
int memoria_id;
} datos_filosofos;

struct datos_filosofos *p_filosofos;

// Reservar semáforos y memoria compartida
int crea_filosofos(void)
{
int i;
int sem_id,sem_id2,mem_id;

// Crea el área de memoria compartida
if((mem_id=shmget(IPC_PRIVATE,sizeof(datos_filosofos),0774 | IPC_CREAT))==-1)
return -1;

if(!(p_filosofos=(datos_filosofos *)shmat(mem_id,(char *)0,0)))
return -2;

// Crea el set de semáforos para los cubiertos
if((sem_id=semget(IPC_PRIVATE,NUM_FILOSOFOS,0774 | IPC_CREAT))==-1)
return -3;

// Crea el semáforo que evitará el interbloqueo
if((sem_id2=semget(IPC_PRIVATE,1,0774 | IPC_CREAT))==-1)
return -3;

// Inicializa el área de memoria compartida
for(i=0;i<NUM_FILOSOFOS;i++)
{
p_filosofos->filosofos[i]=PENSANDO;
p_filosofos->pids[i]=0;
semctl(sem_id,i,SETVAL,LIBRE);
}

semctl(sem_id2,0,SETVAL,NUM_FILOSOFOS-1);
p_filosofos->semaforo_id=sem_id;
p_filosofos->semaforo_id2=sem_id2;
p_filosofos->memoria_id=mem_id;

return sem_id;
}

// Liberar semáforos y memoria compartida
void elimina_filosofos(void)
{
int i;
int mem_id,sem_id;

mem_id=p_filosofos->memoria_id;
shmdt((char *)p_filosofos);
shmctl(mem_id,IPC_RMID,(struct shmid_ds *)NULL);
for(i=0;i<NUM_FILOSOFOS;i++)
semctl(sem_id,i,IPC_RMID);
}

// Wait
void P(int id,int i)
{
struct sembuf op[3]={i,-1,0};
semop(id,op,1);
}

// Signal
void V(int id,int i)
{
struct sembuf op[3]={i,1,0};
semop(id,op,1);
}

int main()
{
int res;
int i;

// Crea filósofos: reservar memoria, crear semáforos
res=crea_filosofos();
if(res<0)
{
printf("Error %d\n",-res);

return 0;
}

// Crea los filósofos (procesos hijos)
for(i=0;i<NUM_FILOSOFOS;i++)
if(!fork())
{
// Proceso hijo #i
p_filosofos->pids[i]=getpid();
while(1)
{
// Máximo NUM_FILOSOFOS-1 entran a tratar de comer para evitar el interbloqueo
P(p_filosofos->semaforo_id2,0);

// Espera los dos cubiertos
P(p_filosofos->semaforo_id,i);
P(p_filosofos->semaforo_id,(i+1)%NUM_FILOSOFOS);
p_filosofos->filosofos[i]=COMIENDO;
sleep(1);

// Devuelve los dos cubiertos
V(p_filosofos->semaforo_id,i);
V(p_filosofos->semaforo_id,(i+1)%NUM_FILOSOFOS);
p_filosofos->filosofos[i]=PENSANDO;

// Deja que otro trate de comer
V(p_filosofos->semaforo_id2,0);
}
}

// Bucle de espera del proceso padre
while(res!=27)
{
// Muestra informacion
printf("Estado de los filosofos: \n");
for(i=0;i<NUM_FILOSOFOS;i++)
printf("%d[%d] ==> %d\n",i,p_filosofos->pids[i],p_filosofos->filosofos[i]);
res=getchar();
}

// Elimina los procesos hijos
for(i=0;i<NUM_FILOSOFOS;i++)
kill(p_filosofos->pids[i],9);

elimina_filosofos();

return 0;
}

 AQUI SE MUESTRA LOS 3 ARCHIVOS QUE SE CREAN DESPUES DE COMPILAR Y CONSTRUIRLOS EN GEANY

  AQUI SE MUESTRA COMO COMEN LOS FILOSOFOS 1 Y 4

  AQUI SE MUESTRA COMO COMEN LOS FILOSOFOS 1 Y 3

AQUI SE MUESTRA COMO COMEN LOS FILOSOFOS 2 Y 4

AQUI SE MUESTRA COMO COME EL FILOSOFO 2

POSIX

POSIX

 

¿QUÉ ES?

(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 operativosUnix. El término "POSIX" fue sugerido por Richard Stallman en respuesta a un requerimiento de la IEEE, que deseaba un nombre memorable.

DONDE SE OCUPA

Son una familia de estándares de llamadas al sistema operativo definidos por el IEEE y especificados formalmente en el IEEE 1003. Persiguen generalizar las interfaces de los sistemas operativos para que una misma aplicación pueda ejecutarse en distintas plataformas. Estos estándares surgieron de un proyecto de normalización de las API y describen un conjunto de interfaces de aplicación adaptables a una gran variedad de implementaciones de sistemas operativos.

Especifica las interfaces de usuario y software al sistema operativo en 15 documentos diferentes. La línea de comandos estándar y las interfaces de scripting se basaron en Korn Shell. Otros programas a nivel de usuario (user-level), servicios y utilidades incluyen AWK, echo, ed y cientos de otras. Los servicios a nivel de programa requeridos incluyen definición de estándares básicos deI/O, (file, terminal, y servicios de red). También especifican una API para las bibliotecas de threading, que es muy utilizada en una gran variedad de sistemas operativos.

EJEMPLO

*NO TODOS LO SISTEMAS SON COMPATIBLES CON ESTE PROCESO YA QUE SON SELECCIONADAS LAS APLICACIONES DONDE SE PUEDEN EJECUTAR

/* hola.c

Programa que que genera 2 hilos POXIS para

imprimir a pantalla "hola mundo".

compilar:

*/

#include <pthread.h>

#include <stdio.h>

void* imprime_mensaje( void *ptr );

main()

{

pthread_t hilo1, hilo2;

char *mensaje1 = "hola";

char *mensaje2 = "mundo";

/* se generan 2 hilos que se ejecutaran en paralelo con el padre */

pthread_create(&hilo1, NULL, imprime_mensaje, (void*) mensaje1);

/* aquí el hilo padre puede estar haciendo otra cosa en paralelo con 

los 2 hilos POSIX hijos */

/* por ejemplo: */

printf("A lo mejor esto se imprime primero... \n");

pthread_create(&hilo2, NULL, imprime_mensaje, (void*) mensaje2);

sleep(1);

exit(0);

}

void* imprime_mensaje( void *ptr )

{

char *mensaje;

mensaje = (char *) ptr;

printf("%s \n", mensaje);

pthread_exit(0);

} 

PRACTICA 3 Y 4 CONFIGURACIÓN DE PROCESOS

PRACTICA 3 Y 4 CONFIGURACIÓN DE PROCESOS

ARBOL DE PROCESOS DEL PID

ÁRBOL DE PROCESOS DEL PID

¿Qué observas?

Que el proceso tiene un identificador mayor que al del padre,  asi mismo vemos que los procesos son mostrados en un arbol con numeración ascendente en lineas de 3 procesos.  

¿Por qué aparecen mensajes repetidos?

Se debe aque creando un procesos se desencadena asi mismo termina la repeticion del procesos cuando el proceso padre acepte su valor de retorno.

¿Porqué?

Porque dentro de la sintaxis se procede a crear un hijo para poder generar el arbol de prcesos y sea mostardo en pantalla, asi mismo el pipe (tuberia) crea un flujo encadenado de procesos estandares de modo que la salida en este caso de acada hijo se alimenta directamente de la entrada del siguiente.