practica2

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;
    }
return 0;
}

Actividad1

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.

FIFO y LIFO

Colas (FIFO).

Una cola es una estructura de datos en la que el primer dato en entrar es el primer dato en salir. Es decir, es una estructura FIFO (First In First Out). Todo el mundo conocemos como funciona una cola, los nuevos se ponen al final, los servicios se prestan al principio y no está permitido “colarse”. Las mismas reglas se aplican a las colas de datos almacenadas en la memoria de un computador.

Hay varias formas de implementar una cola en la memoria de un computador. Una forma simple consiste en almacenar los datos en posiciones de memoria adyacentes y utilizar punteros para el principio y el fin de la cola. Cuando un elemento se añade a la cola, el puntero de la parte posterior se ajusta para que señale al nuevo elemento. De manera similar, cuando un elemento se elimina de la cola, se ajusta el puntero delantero para que señale al nuevo primer elemento.

El problema de este método para implementar las colas es que las posiciones de memoria que ocupan, varían a medida que se añaden y eliminan elementos de la misma. La solución habitual consiste en asignar un área fija para almacenar la cola y permitir que se mueva en este área de manera circular. Un área de almacenamiento de esta forma se denomina buffer circular , y puede apreciarse en la figura siguiente.

Entre las aplicaciones que tienen las colas se encuentran el almacenamiento de datos en camino, entre un procesador y un periférico, o actuar como punto intermedio en las redes de comunicación de datos.

Pilas (LIFO).

Una pila es una colección ordenada de datos a los que sólo se puede acceder por un extremo, denominado tope o cima de la pila. La pila es una estructura en la que el último elemento en entrar será el primero en salir, es decir, es lo que se denomina estructura LIFO (Last In First Out).

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. Las operaciones que se pueden realizar tanto con las colas como con las pilas, son las siguientes:

· Añadir o eliminar un elemento: Si es una cola podremos añadirlo o eliminarlo al final

de la misma, y si es una pila al principio.

· Acceder al primer elemento: Normalmente es el único al que se va a poder acceder

directamente.

· Acceder al elemento siguiente del último procesado: Este es el mecanismo normal de

acceso tanto a colas como a pilas.

· Saber si está vacía: Están vacías si no contienen ningún elemento.

programa examen

Programa de Examen

#include <./include/rshmem.h>
#include <stdlib.h>
#include <sys/sem.h>
#include <math.h>
#include <time.h>
#define N 5  
#define M 50

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

if (-1==(sfilo[i]=semOpen(sclave[i])))
fprintf(stderr,"no tengo el cualificador del semaforo filosofo %d\n",i);

if (-1==(sfilo[(i+2)%N]=semOpen(sclave[(i+2)%N])))
fprintf(stderr,"no tengo el cualifacador semaforo filosofo %d\n",(i+2)%N);

while(*comer<M){
semWait(sfilo[i]);
(*fc)++;
if (*fc>(N+1)/2)     {
   semSignal(sfilo[i]);
   (*fc)--;
   }

else
   {
   semWait(sfilo[(i+2)%N]);
   incrementa(comer,1);
   (void) fprintf(pf,"[comer:%.2d] el filosofo %d ha comido\n", *comer, (i+1)%N);
   fflush(pf);
   semSignal(sfilo[(i+2)%N]);
   semSignal(sfilo[i]);
   (*fc)--;
   }
}

semClose(sfilo[i]);
semClose(sfilo[(i+2)%N]);
(*fin)++;
exit(1);
}

int main(){

FILE *pf;           
key_t sclave[N+1]; 
int sfilo[N];     
int *comer;   
int *fin;        
int *fc;          
int i;              

printf("1");

if((pf=fopen("fich", "w+"))==NULL){
fprintf(stderr,"error al abrir el fichero para salidas\n");
exit(-1);
}
printf("abre fichero salida");
for(i=0; i<N; i++){
printf("el for ");
if((key_t)-1==(sclave[i]=ftok("filos",'s'+i))){
fprintf(stderr,"main: error crear clave filosofo %d con ftok(%c)\n", i,'s'+i);
exit(1);
}

print("dentro del fo");
if(-1==(sfilo[i]=semCreate(sclave[i],1))){
fprintf(stderr,"main: no pude crear semaforo filosofo %d\n",i);
exit(1);
}
}  
printf("hola");

if(!crearMemoria())
fprintf(stderr,"error de crearMemoria()\n");
comer = (int *) memoria;
*comer = 0;
fin = (int *) comer + sizeof(int);
*fin = 0;
fc = (int *) comer + sizeof(int);
for(i=0; i<N; i++){
if(0==fork())    /* PROCESOS HIJOS */
filosofo(pf, sclave, sfilo, i, comer, fin, fc);
}
while(*fin<5);
fprintf(pf,"no habia comido ningun filososo y ahora han comido %d", *comer);
fclose(pf);
if(!eliminarMemoria())
fprintf(stderr,"error de eliminarMemoria()\n");

for(i=0; i<N; i++)
semClose(sfilo[i]);
exit(0);
}

Programa del PID con funciones random

Programa del PID con funciones random

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

int main (void)
{
int ret,i=1;
int x,y;
x=rand()%1+10;
y=rand()%20+30;
               
        ret=fork();

        if(ret==0)
        {
printf("Yo soy el hijo %d PID=%d, mi numero aletorio es:%d y el otro proceso es: %d\n",i,getpid(),x,y);
printf("Yo soy el hijo %d PID=%d, mi numero aletorio es:%d y el otro proceso es: %d\n",i+1,getpid(),y,x);
        }
        else
        {
printf("No se pueden ejecutar los pid");
}
}

POSIX

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

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

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 de I/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.

Una serie de pruebas acompañan al estándar POSIX. Son llamadas “PCTS” en alusión al acrónimo “Posix Conformance Test Suite”. Desde que la IEEE empezó a cobrar altos precios por la documentación de POSIX y se ha negado a publicar los estándares, ha aumentado el uso del modelo Single Unix Specification. Este modelo es abierto, acepta entradas de todo el mundo y está libremente disponible en Internet. Fue creado por The Open Group.


PROFESOR NO SE LE OLVIDE :
ELEGI EL NUMERO 10 EN PROGRAMA
NOTA: LAS DEMAS PRACTICAS ESTAN EN LAS ANTERIORES ENTRADAS