Practica 4

JUAN CARLOS BASILIO OROZCO
SISTEMAS OPERATIVOS
EJERCICIO 4

55. Disponemos de un disco duro de 20 GB de capacidad. Hay establecida sobre él, una única partición que contiene un sistema de ficheros del tipo FAT32 en el que cada agrupamiento (cluster) consta de 16 sectores de 512 bytes cada uno. ¿Cuántos sectores del disco se necesitarán para almacenar cada copia la FAT? Razona tu respuesta.

En primer lugar se calcula lo que ocupa la FAT, que es el tamaño del enlace (32 bits) por el número de entradas de la tabla que, a su vez, es el tamaño del disco dividido por el tamaño del agrupamiento y que en este problema son 20GB/(16 ∗ 512bytes) = 20 ∗ 2¹⁷ entradas. Luego la tabla ocupa 20 ∗ 2¹⁹ ∗ 32bits = 20 ∗ 2¹⁹ bytes.

Si se divide lo que ocupa la tabla por el tamaño del agrupamiento se obtiene el número de agrupamientos que ocupa la tabla: 20 ∗ 2¹⁹/(16 ∗ 512) = 20 ∗

2⁶ = 1280 agrupamientos, que multiplicado por 16, que es el número de sectores por agrupamiento, se obtiene el número total de sectores que es 20480.

56. La policía ha arrestado al sospechoso de un delito. Al analizar el contenido de su ordenador piensan que pueden inculparle pues el contenido del mismo es el siguiente:

Número  De bloque de datos	Contenido
10	he
11	sido
12	yo
13	no
14	sigan
15	buscando

Como experto informático, pides consultar el contenido de la FAT, que es el siguiente:

Número  de entrada en la FAT	Contenido
10	11
11	EOF
12	13
13	10
14	15
15	12

¿Apoyarías la opinión de la policía? Razona tu respuesta.

En un sistema de archivos FAT, los bloques se asignan como una lista enlazada que finaliza con la posición fin de lista EOF. Es posible recuperar datos utilizando los enlaces partiendo desde esa posición EOF hacia atrás.

La reconstrucción de la lista de bloques será:

14 → 15 → 12 → 13 → 10 → 11 → EOF

La información de esa lista de bloques será:

Sigan → buscando → yo → no → he → sido → EOF


En este programa se muestra como el hilo consumidor muestra en pantalla todos los datos producidos por el hilo productor

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