Feda /dev/ - No Javascript allowed

#include <errno.h>
#include <getopt.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>

int num_chairs = 5;
int num_barbers = 5;
int num_customers = 100;
int max_time = 1000000;

static struct option long_options[] = {
	{ .name = "chairs",
	  .has_arg = required_argument,
	  .flag = NULL,
	  .val = 0},
	{ .name = "barbers",
	  .has_arg = required_argument,
	  .flag = NULL,
	  .val = 0},
	{ .name = "customers",
	  .has_arg = required_argument,
	  .flag = NULL,
	  .val = 0},
	{ .name = "max_time",
	  .has_arg = required_argument,
	  .flag = NULL,
	  .val = 0},
	{ .name = NULL,
	  .has_arg = 0,
	  .flag = NULL,
	  .val = 0}
};

static void usage(int i)
{
	printf(
		"Usage:  producers [OPTION] [DIR]\n"
		"Launch producers and consumers\n"
		"Opciones:\n"
		"  -b n, --barbers=<n>: number of barbers\n"
		"  -c n, --chairs=<n>: number of chairs\n"
		"  -n n, --customers=<n>: number of customers\n"
		"  -t n, --max_time=<n>: maximum time a customer will wait\n"
		"  -h, --help: show this help\n\n"
	);
	exit(i);
}

static int get_int(char *arg, int *value)
{
	char *end;
	*value = strtol(arg, &end, 10);

return (end != NULL);
}

static void handle_long_options(struct option option, char *arg)
{
	if (!strcmp(option.name, "help"))
		usage(0);

if (!strcmp(option.name, "barbers")) {
	if (!get_int(arg, &num_barbers)
	    || num_barbers <= 0) {
		printf("'%s': not a valid integer\n", arg);
		usage(-3);
	}
}
if (!strcmp(option.name, "chairs")) {
	if (!get_int(arg, &num_chairs)
	    || num_chairs <= 0) {
		printf("'%s': not a valid integer\n", arg);
		usage(-3);
	}
}
if (!strcmp(option.name, "customers")) {
	if (!get_int(arg, &num_customers)
	    || num_customers <= 0) {
		printf("'%s': not a valid integer\n", arg);
		usage(-3);
	}
}
if (!strcmp(option.name, "max_time")) {
	if (!get_int(arg, &max_time)
	    || max_time <= 0) {
		printf("'%s': not a valid integer\n", arg);
		usage(-3);
	}
}
}

static int handle_options(int argc, char **argv)
{
	while (1) {
		int c;
		int option_index = 0;

	c = getopt_long (argc, argv, "hb:c:n:t:",
			 long_options, &option_index);
	if (c == -1)
		break;

	switch (c) {
	case 0:
		handle_long_options(long_options[option_index],
			optarg);
		break;

	case 'b':
		if (!get_int(optarg, &num_barbers)
		    || num_barbers <= 0) {
			printf("'%s': not a valid integer\n",
			       optarg);
			usage(-3);
		}
		break;

	case 'c':
		if (!get_int(optarg, &num_chairs)
		    || num_chairs <= 0) {
			printf("'%s': not a valid integer\n",
			       optarg);
			usage(-3);
		}
		break;

	case 'n':
		if (!get_int(optarg, &num_customers)
		    || num_customers <= 0) {
			printf("'%s': not a valid integer\n",
			       optarg);
			usage(-3);
		}
		break;

	case 't':
		if (!get_int(optarg, &max_time)
		    || max_time <= 0) {
			printf("'%s': not a valid integer\n",
			       optarg);
			usage(-3);
		}
		break;

	case '?':
	case 'h':
		usage(0);
		break;

	default:
		printf ("?? getopt returned character code 0%o ??\n", c);
		usage(-1);
	}
}
return 0;
}

pthread_cond_t waiting_room = PTHREAD_COND_INITIALIZER;
pthread_cond_t no_customers = PTHREAD_COND_INITIALIZER;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

int waiting_customers = 0;
int clientes = 0;	//Número de clientes que se acercaron a la barbería
int atendidos = 0;	//Número de clientes atendidos 
int cont_llena = 0;	//Número de clientes que se encontraron la barbería llena
int impacientes = 0;


enum barber_state_t { SLEEPING, WORKING} ;

//enum barber_state_t barber_state = SLEEPING;

struct barber_info {    /* Used as argument to thread_start() */
	pthread_t thread_id;        /* ID returned by pthread_create() */
	int       barber_num;
	pthread_cond_t ocioso;
	int cliente;
	enum barber_state_t barber_state;
};

struct customer_info {    /* Used as argument to thread_start() */
	pthread_t thread_id;        /* ID returned by pthread_create() */
	int       customer_num;	
	pthread_cond_t mi_turno;
	int barbero;
	struct timeval	t_llegada;	    /* Instante en el que el cliente llega */
	struct timeval	t_corte;	    /* Instsante en el que le cortan el pelo */
};

struct timeval tv_inicio;

/* CODIGO PARA LA COLA DE CLIENTES */

struct nodo {
	struct customer_info *cinfo;
	struct nodo *sig;
};

struct nodo * cola_clientes;

void inicializar_cola(struct nodo *cola){
	cola -> sig = NULL;
}

int es_cola_vacia(struct nodo cola){
	return cola.sig == NULL;
}

struct nodo * crear_nodo(struct customer_info *info){
	struct nodo *aux = malloc(sizeof(*aux));
	aux -> cinfo = info;
	aux -> sig = NULL;

return aux;	
}

void insertar_cola(struct nodo *cola, struct customer_info *cinfo){
	struct nodo * aux;

if (es_cola_vacia(*cola)) cola->sig = crear_nodo(cinfo);
else {
	aux = cola->sig;
	while (aux->sig != NULL) aux = aux->sig;
	aux->sig = crear_nodo(cinfo);
}	
}

struct customer_info * eliminar_cola(struct nodo *cola){
	struct nodo * aux = cola->sig;

if (!es_cola_vacia(*cola)){
	cola->sig = cola->sig->sig;	
	aux->sig = NULL;
	return aux->cinfo;
}

return NULL;
}

void eliminar_customer(struct nodo *cola, int cnum){
	struct nodo * aux = cola->sig;
	struct nodo * ant = cola;

while (aux != NULL){
	if (aux->cinfo->customer_num == cnum){
		ant->sig = aux->sig;
		aux->sig = NULL;
	}
	ant = aux;
	aux = aux->sig;
}

}

void listar_cola(struct nodo *cola){
	struct nodo * aux = cola->sig;
	struct customer_info * c;
	while(aux!=NULL){
		c = aux->cinfo;
		printf("Cliente %d\n",c->customer_num);
		aux = aux-> sig;	
	}
}
/* --------------------------------------- */

/* CODIGO PARA LA LISTA DE BARBEROS */

struct nodo_l {
	struct barber_info * binfo;
	struct nodo_l * sig;
};

struct nodo_l * lista_barberos;

void inicializar_lista(struct nodo_l *l){
	l -> sig = NULL;
}

int es_lista_vacia(struct nodo_l l){
	return l.sig == NULL;
}

struct nodo_l * crear_nodo_l(struct barber_info *info){
	struct nodo_l *aux = malloc(sizeof(*aux));
	aux -> binfo = info;
	aux -> sig = NULL;

return aux;	
}

void insertar_lista(struct nodo_l *l, struct barber_info *info){
	struct nodo_l * aux;

if (es_lista_vacia(*l)) l->sig = crear_nodo_l(info);
else {
	aux = l->sig;
	while (aux->sig != NULL) aux = aux->sig;
	aux->sig = crear_nodo_l(info);
}	
}

int buscar_barbero_ocioso(struct nodo_l *l){
	struct nodo_l * aux;

aux = l->sig;
while (aux != NULL){
	if (aux->binfo->barber_state == SLEEPING){
		return aux->binfo->barber_num;
	}
	aux = aux->sig;
}

return -1;
}

void despertar_barbero(struct nodo_l * l, int barbero, int cliente){
	struct nodo_l * aux;

aux = l->sig;
while (aux != NULL){
	if (aux->binfo->barber_num == barbero){
		aux->binfo->cliente = cliente;
		pthread_cond_signal(&aux->binfo->ocioso);
		aux->binfo->barber_state = WORKING;
		break;
	}
	aux = aux->sig;
}
}

void despertar_barberos_despistados(struct nodo_l * l){
	struct nodo_l * aux;

aux = l->sig;
while (aux != NULL){
	pthread_cond_signal(&aux->binfo->ocioso);
	aux = aux->sig;
}
}

void esperar_barberos(struct nodo_l * l){
	struct nodo_l * aux;

aux = l->sig;
while (aux != NULL){
	pthread_join(aux->binfo->thread_id, NULL);
	aux = aux -> sig;
}
}

/* --------------------------------------- */

unsigned int seed = 12345678;

void cut_hair(int barber, int customer)
{
	unsigned int time = rand_r(&seed) % 500000;
	// time that takes to do the haircut
	usleep(time);

printf("barber %d cut hair of customer %d took %d time\n", barber, customer, time);
}

void *barber_function(void *ptr)
{
	struct barber_info *t =  ptr;

printf("barber thread %d\n", t->barber_num);

while(1) {
	pthread_mutex_lock(&mutex);
	if (!waiting_customers) {
		if ( (clientes) >= num_customers){ //Comprueba si acabó por hoy
			printf("barber %d goes home\n",t->barber_num);

			despertar_barberos_despistados(lista_barberos);
			pthread_mutex_unlock(&mutex);
			return NULL;
		}

		t->barber_state = SLEEPING;
		printf("barber %d goes to sleep\n", t->barber_num);
		//pthread_cond_wait(&no_customers, &mutex);
		pthread_cond_wait(&t->ocioso, &mutex);
		
		if (t->cliente == -1){
			pthread_mutex_unlock(&mutex);
			printf("barber %d goes home\n",t->barber_num);
			return NULL;
		}
		
		atendidos++;
		pthread_mutex_unlock(&mutex);

		cut_hair(t->barber_num, t->cliente);
		t->cliente = -1;

	}
	else{
		atendidos++; //Actualiza el numero de clientes atendidos

		//Entiendo que aquí se quita al cliente de la cola, además así tengo el numero de cliente para el cut_hair	
		struct customer_info * c = eliminar_cola(cola_clientes);
		
		if (c!=NULL){
			c->barbero = t->barber_num;
			waiting_customers--;
			pthread_mutex_unlock(&mutex);
			pthread_cond_signal(&c->mi_turno);
			cut_hair(t->barber_num, c->customer_num);
			t->cliente = -1;
		}	
	}
}
}

void get_hair_cut(int barber, int customer)
{
	printf("customer %d got hair cut from barber %d\n", customer, barber);
}

void *customer_function(void *ptr)
{
	struct customer_info *t =  ptr;
	unsigned int tim = rand_r(&seed) % 100000 + t->customer_num * 100000;
	unsigned long llegada_s, llegada_u, corte_s, corte_u;

struct timeval tv; //timeval para los tiempos del cliente

// time that takes until it arrives to the barber shop
usleep(tim);



//instante de llegada para la traza y eso
gettimeofday(&tv,NULL);	
t->t_llegada = tv;

pthread_mutex_lock(&mutex);

llegada_s = tv.tv_sec - tv_inicio.tv_sec;
llegada_u = tv.tv_usec - tv_inicio.tv_usec;

if ( tv.tv_usec - tv_inicio.tv_usec < 0){
	llegada_u = 1000000 - tv.tv_usec;
	llegada_s = llegada_s - 1;
}
	

printf("customer thread %d arrives in %d | %lu s : %lu us despues de empezar\n", t->customer_num, tim, llegada_s, llegada_u);

clientes++; //Actualiza el numero de clientes que se acercaron a la barbería

if(waiting_customers == num_chairs)  {
	printf("waiting room full for customer %d\n", t->customer_num);
	cont_llena++; //Actualiza el numero de clientes que no entraron	
	pthread_mutex_unlock(&mutex);
	return NULL;
}


//	if(barber_state==SLEEPING) {	
	if ( (t->barbero = buscar_barbero_ocioso(lista_barberos)) != -1){
		despertar_barbero(lista_barberos, t->barbero, t->customer_num);

} else {
	waiting_customers++;
	//pthread_cond_wait(&waiting_room, &mutex);
	//Inserto al cliente en la cola

	pthread_cond_init(&t->mi_turno, NULL);
	t->barbero = -1;				
	insertar_cola(cola_clientes,t);
	// -----
	//pthread_cond_wait(&t->mi_turno,&mutex);

	// Preparo el asunto para el timedwait
	struct timespec tp;		
	clock_gettime(CLOCK_REALTIME, &tp);
	
	unsigned long time = (rand_r(&seed) % max_time)*1000;

	if ( (tp.tv_nsec + time) >= 1000000000 ){
		tp.tv_sec += (tp.tv_nsec + time) / 1000000000;
		tp.tv_nsec = (tp.tv_nsec + time) % 1000000000;
	}else{
		tp.tv_nsec += time;
	}
	
	int e;
	if ( (e = pthread_cond_timedwait(&t->mi_turno, &mutex, &tp)) !=0 ){
		if (e == ETIMEDOUT){
			printf("Customer %d leaves after %lu waiting\n",t->customer_num, time/1000);
			eliminar_customer(cola_clientes, t->customer_num);
			impacientes++;
			waiting_customers--;
			pthread_mutex_unlock(&mutex);
			return NULL;
		}
		if ( e == EINVAL){
			printf("error en timedwait EINVAL %d: en thread %i\n",e, t->customer_num);
			printf("tiempos: %lu : %lu\n",tp.tv_sec, tp.tv_nsec);
			waiting_customers--;
			pthread_mutex_unlock(&mutex);
			return NULL;
		}							
	}
}

//tiempo de corte para la traza y eso
gettimeofday(&tv, NULL);
t->t_corte = tv;

corte_s = tv.tv_sec - t->t_llegada.tv_sec;
corte_u = tv.tv_usec - t->t_llegada.tv_usec;

if ( tv.tv_usec - t->t_llegada.tv_usec < 0){
	corte_u = 1000000 - tv.tv_usec;
	corte_s = corte_s - 1;
}

pthread_mutex_unlock(&mutex);


printf("customer thread %d se va a cortar el pelo tras %lu s : %lu us despues de llegar\n", t->customer_num, corte_s, corte_u);
get_hair_cut(t->barbero, t->customer_num);

return NULL;
}

void create_threads(void)
{
	int i;
	struct barber_info *barber_info;
	struct customer_info *customer_info;	


printf("creating %d barbers\n",num_barbers);

barber_info = malloc(sizeof(struct barber_info)*num_barbers);

if (barber_info == NULL) {
	printf("Not enough memory\n");
	exit(1);
}

/* Create independent threads each of which will execute function */
for (i = 0; i<num_barbers; i++){
	barber_info[i].barber_num = i;
	barber_info[i].barber_state = SLEEPING;
	barber_info[i].cliente = -1;
	pthread_cond_init(&barber_info[i].ocioso, NULL);
	if ( 0 != pthread_create(&barber_info[i].thread_id, NULL,
				 barber_function, &barber_info[i])) {
		printf("Failing creating barber thread %d", i);
		exit(1);
	}		
	insertar_lista(lista_barberos,&barber_info[i]);
}

printf("creating %d customers\n", num_customers);
customer_info = malloc(sizeof(struct customer_info) * num_customers);

if (customer_info == NULL) {
	printf("Not enough memory\n");
	exit(1);
}

for (i = 0; i < num_customers; i++) {
	customer_info[i].customer_num = i;
	if ( 0 != pthread_create(&customer_info[i].thread_id, NULL,
				 customer_function, &customer_info[i])) {
		printf("Failing creating customer thread %d", i);
		exit(1);
	}
}

esperar_barberos(lista_barberos);

printf("***************\nEstadisticas:\n");
printf("%d clientes se quedaron fuera\n",cont_llena);
printf("%d clientes fueron atendidos\n",atendidos);
printf("%d clientes se cansaron de esperar\n",impacientes);

pthread_exit(0);
}

int main (int argc, char **argv)
{
	int result = handle_options(argc, argv);

if (result != 0)
	exit(result);

if (argc - optind != 0) {
	printf ("Extra arguments\n\n");
	while (optind < argc)
		printf ("'%s' ", argv[optind++]);
	printf ("\n");
	usage(-2);
}

//pillo la hora de inicio del programa
gettimeofday(&tv_inicio, NULL);	
printf("INICIO: %lu : %lu\n", tv_inicio.tv_sec, tv_inicio.tv_usec);


//Inicializa la cola de clientes
cola_clientes = malloc(sizeof(*cola_clientes));
inicializar_cola(cola_clientes);
// -----

//Inicializa la lista de barberos
lista_barberos = malloc(sizeof(*lista_barberos));
inicializar_lista(lista_barberos);
// -----

create_threads();

exit (0);
}

#include <stdio.h>
#include <sys/time.h>
#include <math.h>
#include <stdlib.h>

#define TAM 128000

typedef struct {
  int vector[TAM];
  int ultimo;
} monticulo;


void listar_vector(int v[], int n){
  int i;
  printf("[");
  for(i=0;i<n;i++){  

    printf("%4i",v[i]);
  }  

  printf(" ]\n");
}


/* obtiene el tiempo actual en microsegundos */
double microsegundos(){
  struct timeval t;
  if (gettimeofday(&t, NULL) < 0)
    return 0.0;
  return (t.tv_usec + t.tv_sec * 1000000.0);
}


//Inicializacion de vector de forma aleatoria
void inicializar_semilla(){
  srand(time(NULL));
}

void aleatorio(int v[], int n){
  int i, m=2*n+1;
  for(i=0;i<n;i++)
    v[i] = (rand() % m) - n;
}


//Inicialización de vector ordenado de forma ascendente
void inicializar_asc(int v[], int n){
  int i;
  for(i=0;i<n;i++){
    v[i] = i;
  }
}

//Inicialización de vector ordenado de forma ascendente
void inicializar_des(int v[], int n){
  int i;
  for(i=n;i>=0;i--){
    v[i] = n-i;
  }
}


/* *** FUNCIONES DEL MONTICULO *** */
void ini_monticulo(monticulo *M) {
  M->ultimo = -1;
}

void Hundir(monticulo *M,int i) {
  int HijoIzq;
  int HijoDer;
  int j,aux;
  do {
    HijoIzq = (2*i) + 1;
    HijoDer = (2*i) + 2;
    j = i;
    if ((HijoDer < M->ultimo+1) && (M->vector[HijoDer] > M->vector[i]))   

      i = HijoDer;
    if ((HijoIzq < M->ultimo+1) && (M->vector[HijoIzq] > M->vector[i]))   

      i = HijoIzq;
    aux = M->vector[i];
    M->vector[i] = M->vector[j];
    M->vector[j] = aux; 
  } while (j!=i);
}

void crear_monticulo(int v[], int n, monticulo *M){
  int i;
  for (i=0; i<n; i++){
    M->vector[i] = v[i];        

  }
  M->ultimo=n-1;
  for (i=(n / 2); i>=0; i--)
    Hundir(M,i);
}

int eliminar_mayor(monticulo *M){
  int x;
  if (M->ultimo == -1)
    printf("Error: Monticulo Vacío\n");
  else{
    x = M->vector[0];
    M->vector[0] = M->vector[M->ultimo];
    M->ultimo = M->ultimo-1;
    

if (M->ultimo >=-1) 
  Hundir (M, 0);
  }
    return x;
}

void ordenar_monticulo(int v[],int n){
  int i;
  monticulo *M;    

  M = malloc(sizeof(monticulo));

  crear_monticulo (v,n,M);

  for (i=M->ultimo; i>0; i--)
    v[i] = eliminar_mayor(M); 
  free(M);
}


/* *** FUNCION DE TEST *** */
void test_mont(){
  int tam = 10;
  int v[tam];
  monticulo *M;
  M = malloc(sizeof(monticulo));

  printf("\nVALIDACION INICIALIZAR MONTICULO\n");
  ini_monticulo(M);
  if (M->ultimo == -1) 
    printf("Inicializacion correcta.\n");

  printf("\nVALIDACION FUNCION CREAR MONTICULO\n");
  inicializar_asc(v,tam);
  printf("Vector inicializado ascendente\n");
  listar_vector(v,tam);
  printf("\nCreando monticulo...\n");
  crear_monticulo(v,tam,M);  

  listar_vector(M->vector,tam);

  printf("\nOrdenando vector por monticulo...\n");
  ordenar_monticulo(v,tam);
  listar_vector(v,tam);  

  free(M); 
}


/* *** CALCULO DE TIEMPOS Y TABLAS PARA CREAR MONTICULO *** */

/* medicion de tiempos por debajo del umbral */
double umbral_crea(int v[], int n, monticulo *M){
  int m,k;
  int umbral=500 ,repeticiones=1000;
  double ajustada,subestimada,sobrestimada,ta=0,tb=0,t,t1,t2;

  ta = microsegundos();
  for(k=0;k<repeticiones;k++){
    inicializar_asc(v,n);
    crear_monticulo(v,n,M);
  }
  tb = microsegundos();
  t1 = tb-ta;
  ta = microsegundos(); //Hay que restar el tiempo que tarda el bucle
  for(k=0;k<repeticiones;k++){
    inicializar_asc(v,n);	
  }
  tb = microsegundos();
  t2=tb-ta;

  return (t1-t2)/repeticiones;
}

/* medicion de tiempos general */
double tiempos_crear(int v[], int n){
  monticulo *M;    

  M = malloc(sizeof(monticulo));
  int umbral=500;
  double ajustada,subestimada,sobrestimada,ta=0,tb=0,t;
  char flag=' ';

  ta = microsegundos(); 
  crear_monticulo(v,n,M);
  tb = microsegundos();
  t = tb -ta;

  if(t < umbral){	//Se comprueba el tiempo umbral
    t=umbral_crea(v,n,M);
    flag='*';
  }
  printf("%c",flag);  

  free(M); 
  return t;
}

/* creacion de la tabla */
void tabla_crea_mont(){
  int j,m,n = TAM;
  int v[n];
  double ajustada,subestimada,sobrestimada,t;
   

  printf("\n%5s%15s%15s%13s%15s\n","n","t(n)","t(n)/n^0.9","t(n)/n","t(n)/n^1.1");
  for(j=0;j<70;j++){
    printf("-");
  }
  printf("\n");

  for(m=1000;m<=n;m*=2){  

    inicializar_asc(v,m);
    t = tiempos_crear(v,m);

subestimada = t/pow(m,0.9);
ajustada = t/m;
sobrestimada = t/pow(m,1.1);
 
printf("%6d%14.4f%13.6f%13.6f%13.6f\n",m,t,subestimada,ajustada,sobrestimada );
  }
}


/* *** CALCULO DE TIEMPOS Y TABLAS PARA ORDENAR POR MONTICULO *** */

/* tiempos por debajo del umbral vector inicializado ascendente*/
double umbral_a(int v[], int n){
  int m,k;
  int umbral=500 ,repeticiones=1000;
  double ajustada,subestimada,sobrestimada,ta=0,tb=0,t,t1,t2;

  ta = microsegundos();
  for(k=0;k<repeticiones;k++){
    inicializar_asc(v,n);
    ordenar_monticulo(v,n);
  }
  tb = microsegundos();
  t1 = tb-ta;
  ta = microsegundos(); //Hay que restar el tiempo que tarda el bucle
  for(k=0;k<repeticiones;k++){
    inicializar_asc(v,n);	
  }
  tb = microsegundos();
  t2=tb-ta;

  return (t1-t2)/repeticiones;
}

/* tiempos por debajo del umbral vector inicializado descendente */
double umbral_d(int v[], int n){
  int m,k;
  int umbral=500 ,repeticiones=1000;
  double ajustada,subestimada,sobrestimada,ta=0,tb=0,t,t1,t2;

  ta = microsegundos();
  for(k=0;k<repeticiones;k++){
    inicializar_des(v,n);
    ordenar_monticulo(v,n);
  }
  tb = microsegundos();
  t1 = tb-ta;
  ta = microsegundos(); //Hay que restar el tiempo que tarda el bucle
  for(k=0;k<repeticiones;k++){
    inicializar_des(v,n);	
  }
  tb = microsegundos();
  t2=tb-ta;

  return (t1-t2)/repeticiones;
}

/* tiempos por debajo del umbral vector inicializado aleatorio */
double umbral_r(int v[], int n){
  int m,k;
  int umbral=500 ,repeticiones=1000;
  double ajustada,subestimada,sobrestimada,ta=0,tb=0,t,t1,t2;

  ta = microsegundos();
  for(k=0;k<repeticiones;k++){
    aleatorio(v,n);
    ordenar_monticulo(v,n);
  }
  tb = microsegundos();
  t1 = tb-ta;
  ta = microsegundos(); //Hay que restar el tiempo que tarda el bucle
  for(k=0;k<repeticiones;k++){
    aleatorio(v,n);	
  }
  tb = microsegundos();
  t2=tb-ta;

  return (t1-t2)/repeticiones;
}

/* funcion de calculo de tiempos */
double tiempos(int v[], int n, char ini){
  monticulo *M;    

  M = malloc(sizeof(monticulo));
  int umbral=500;
  double ajustada,subestimada,sobrestimada,ta=0,tb=0,t;
  char flag=' ';

  ta = microsegundos(); 
  ordenar_monticulo(v,n);
  tb = microsegundos();
  t = tb -ta;

  if(t < umbral){	//Se comprueba el tiempo umbral
    if (ini == 'a') t=umbral_a(v,n);
    else if (ini == 'd') t=umbral_d(v,n);
    else if (ini == 'r') t=umbral_r(v,n);
    flag='*';
  }
  printf("%c",flag);  

  free(M); 
  return t;
}
 

/*** FUNCION TABLA ORDENAR POR MONTICULO VECTOR ASCENDENTE *** */
void tabla_ord_asc(){
  int j,m,n = TAM;
  int v[n];
  double ajustada,subestimada,sobrestimada,t;
   

  printf("\n%5s%15s%15s%13s%15s\n","n","t(n)","t(n)/n","t(n)/n*logn","t(n)/n^1.3");
  for(j=0;j<70;j++){
    printf("-");
  }
  printf("\n");

  for(m=1000;m<=n;m*=2){  

    inicializar_asc(v,m);
    t = tiempos(v,m,'a');

subestimada = t/m;
ajustada = t/(m*log(m));
sobrestimada = t/pow(m,1.3);
 
printf("%6d%14.4f%13.6f%13.6f%13.6f\n",m,t,subestimada,ajustada,sobrestimada );
  }
}

/*** FUNCION TABLA ORDENAR POR MONTICULO VECTOR DESCENDENTE *** */
void tabla_ord_des(){
  int j,m,n = TAM;
  int v[n];
  double ajustada,subestimada,sobrestimada,t;
   

  printf("\n%5s%15s%15s%13s%15s\n","n","t(n)","t(n)/n","t(n)/n*logn","t(n)/n^1.3");
  for(j=0;j<70;j++){
    printf("-");
  }
  printf("\n");

  for(m=1000;m<=n;m*=2){  

    inicializar_des(v,m);
    t = tiempos(v,m,'a');

subestimada = t/m;
ajustada = t/(m*log(m));
sobrestimada = t/pow(m,1.3);
 
printf("%6d%14.4f%13.6f%13.6f%13.6f\n",m,t,subestimada,ajustada,sobrestimada );
  }
}


/*** FUNCION TABLA ORDENAR POR MONTICULO VECTOR ALEATORIO *** */
void tabla_ord_ale(){
  int j,m,n = TAM;
  int v[n];
  double ajustada,subestimada,sobrestimada,t;
   

  printf("\n%5s%15s%15s%13s%15s\n","n","t(n)","t(n)/n","t(n)/n*logn","t(n)/n^1.3");
  for(j=0;j<70;j++){
    printf("-");
  }
  printf("\n");

  for(m=1000;m<=n;m*=2){  

    aleatorio(v,m);
    t = tiempos(v,m,'a');

subestimada = t/m;
ajustada = t/(m*log(m));
sobrestimada = t/pow(m,1.3);
 
printf("%6d%14.4f%13.6f%13.6f%13.6f\n",m,t,subestimada,ajustada,sobrestimada );
  }
}


int main(){
  int i;
  test_mont();

  printf("\n\nCREACION DEL MONTICULO");
  for(i=1;i<4;i++){
    printf("\niteracion %i",i);
    tabla_crea_mont();  

  }
 
  printf("\n\nORDENACION POR MONTICULOS VECTOR ASCENDENTE");
  for(i=1;i<4;i++){
    printf("\niteracion %i",i);
    tabla_ord_asc();  

  }  

  printf("\n\nORDENACION POR MONTICULOS VECTOR DESCENDENTE");
  for(i=1;i<4;i++){
    printf("\niteracion %i",i);
    tabla_ord_des();  

  }  

  printf("\n\nORDENACION POR MONTICULOS VECTOR ALEATORIO");
  for(i=1;i<4;i++){
    printf("\niteracion %i",i);
    tabla_ord_ale();
  }  

}