1.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.
FAT = 32 bits
Capacidad = 20 GBAgrupamiento = (16 * 512 Bytes)
Sectores = 16
(Capacidad / agrupamiento) * Sectores
20GB / (16*512)
(20 * 2¹⁷) /
(20* 2¹⁷ * 32)/
(20 * 2¹⁹) / (16 *512)
10485760/8192 = 1280 *16
R = 20480 Sectores
2.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 |
No porque no es culpable ya que en un archivo FAT los bloques se asignan como una lista enlazada que finaliza en EOF y la reconstrucción de estos bloques son:
| Sigan | Buscando | Yo | No | He | sido | |
| 14 | 15 | 12 | 13 | 10 | 11 | EOF |
productor.
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#define MAX 10
#define FIN -1
#define FIN -1
int buffer[MAX];
sem_t huecos, elementos;
int generar_dato (void)
{
return random() %256;
}
int numero_aleatorio(void)
{
return random() %100;
}
sem_t huecos, elementos;
int generar_dato (void)
{
return random() %256;
}
int numero_aleatorio(void)
{
return random() %100;
}
void *productor (void *p)
{
int pos_productor= 0;
int num, dato, n;
n= numero_aleatorio();
printf ("Productor con %d datos\n", n);
for(num= 0; num< n; num++)
{
dato= generar_dato();
sem_wait(&huecos);
buffer[pos_productor]= dato;
pos_productor= (pos_productor+ 1) %MAX;
sem_post (&elementos);
}
sem_wait (&huecos);
buffer[pos_productor]= FIN;
sem_post (&elementos);
pthread_exit (NULL);
}
{
int pos_productor= 0;
int num, dato, n;
n= numero_aleatorio();
printf ("Productor con %d datos\n", n);
for(num= 0; num< n; num++)
{
dato= generar_dato();
sem_wait(&huecos);
buffer[pos_productor]= dato;
pos_productor= (pos_productor+ 1) %MAX;
sem_post (&elementos);
}
sem_wait (&huecos);
buffer[pos_productor]= FIN;
sem_post (&elementos);
pthread_exit (NULL);
}
void *consumidor(void *p)
{
int pos_consumidor= 0, dato;
bool continuar= true;
while (continuar)
{
sem_wait (&elementos);
dato= buffer[pos_consumidor];
sem_post (&huecos);
if (dato== FIN)
continuar= false;
else
{
printf ("Numero aleatorio: %d\n", dato);
pos_consumidor= (pos_consumidor+1) %MAX;
}
}
pthread_exit (NULL);
}
{
int pos_consumidor= 0, dato;
bool continuar= true;
while (continuar)
{
sem_wait (&elementos);
dato= buffer[pos_consumidor];
sem_post (&huecos);
if (dato== FIN)
continuar= false;
else
{
printf ("Numero aleatorio: %d\n", dato);
pos_consumidor= (pos_consumidor+1) %MAX;
}
}
pthread_exit (NULL);
}
int main ()
{
pthread_t hiloproductor, hiloconsumidor;
sem_init (&elementos, 0, 0);
sem_init (&huecos, 0, MAX);
pthread_create (&hiloproductor, NULL, productor, NULL);
pthread_create (&hiloconsumidor, NULL, consumidor, NULL);
pthread_join (hiloproductor, NULL);
pthread_join (hiloconsumidor, NULL);
sem_destroy (&huecos);
sem_destroy (&elementos);
return 0;
}
{
pthread_t hiloproductor, hiloconsumidor;
sem_init (&elementos, 0, 0);
sem_init (&huecos, 0, MAX);
pthread_create (&hiloproductor, NULL, productor, NULL);
pthread_create (&hiloconsumidor, NULL, consumidor, NULL);
pthread_join (hiloproductor, NULL);
pthread_join (hiloconsumidor, NULL);
sem_destroy (&huecos);
sem_destroy (&elementos);
return 0;
}
