Liberar memoria

[Zunri]

Gracias Fw190.

Entonces crees que puede ser por las variables locales que utilizo en la función.

Muestro la función recursiva. La llamada a la propia función se encuentra abajo en un FOR... num_fallos = num_fallos + ejecuta_muestra();


Aquí va el código:

__________________________________________________ _______________

Código:

int ejecuta_muestra(float* periodo_MTBF, float* MTBF, int* contadorfallosMTBF, int* primerMTBF, int primer_fallo, float* sumacuadradoMTTT, float* sumaMTTT, int transicion_pasada, float tiempos_en_umbral[num_umbrales], float hilos_indisponibilidad[1], int ultimo_hilo, int primera_ejecucion, int intentos_restantes[num_umbrales], int primer_hilo, float reloj, int umbral_hilo, int* funcionamiento_sistema, float acontecimientos[num_acontecimientos], int sistema_reparacion[tamanio_sistema_reparacion],
					 int sistema[num_elementos], float tasas_de_fallos[num_elementos], float landas[fallos_grupo], int umbrales[num_umbrales], int reintentos_umbrales[num_umbrales], int funcionamiento_sistema_[num_umbrales],
					 float reloj_[num_umbrales], float estado_float[num_umbrales][tamanio_estado_float], int estado_int[num_umbrales][tamanio_estado_int])

{
	int siguiente_acontecimiento;
        int que_elemento;
        int posicion,
        int i, 
        int posicion_umbral, 
        int fallos;
	float cantidad_a_reducir;
	int copia_sistema_reparacion[tamanio_sistema_reparacion];
        int ultimo_ha_descendido = 0;
	int num_fallos = 0;
        int hilo_fallo = 0;
        int descenso_umbral = 0;
        int total_fallos = 0;
        int vuelta_hilo;
        int fallos_antes = 0;
        int hasta_que_pos_umbral;
        float relojMTTT = 0;
	int pintar, l;


	vuelta_hilo = 0;
	if (primera_ejecucion == 0) 
	/* siempre que este subprograma se ejecuta es por nuevo hilo, y hay que volcar el  estado,
	   pero no si es la llamada inicial y es el hilo que viene de 0, ya viene inicializado desde fuera */
	{
			vuelca_estado(umbral_hilo, estado_int, estado_float, acontecimientos, sistema_reparacion, sistema, tasas_de_fallos);
            intentos_restantes[umbral_hilo-1] = intentos_restantes[umbral_hilo -1]-1; /* saber cuantos faltan para cortar ultimo al ir descendiendo */
			*funcionamiento_sistema = funcionamiento_sistema_[umbral_hilo -1]; reloj = reloj_[umbral_hilo -1];
			if (primer_hilo == 0) {/* cambiar acontecimientos para que no se repita */
					               cambia_acontecimientos(acontecimientos, tasas_de_fallos);
								  } 
	}
	
    primera_ejecucion = 0; /* no ha volcado, ya siempre puede volcar el estado */
	
	while ((vuelta_hilo == 0) && (reloj<duracion_muestra) && (descenso_umbral == 0))/* Condicion de parada de cada muestra */
	{   
		siguiente_acontecimiento=primer_acontecimiento(acontecimientos, *funcionamiento_sistema); /* vemos que acontecimiento es el siguiente */
        reloj = reloj + acontecimientos[siguiente_acontecimiento];  /* actualizamos el reloj */
        
        cantidad_a_reducir = acontecimientos[siguiente_acontecimiento]; /* almacenamos la cantidad que debemos restar a todos los acontecimientos */
		if (reloj < duracion_muestra) /* IMPORTANTE */
		{/* Cuando queda poco para llegar a los 100, puede que el proximo acontecimiento se pase y no haya que contarlo */
           
           fallos_antes = fallos_maximos(sistema);
           
           /* Movimiento */      
           if (siguiente_acontecimiento < num_servidores) /* se produce salida de un servidor */
	       {	  
                     -- No a lugar--
	       }
	       else /* se produce una llegada al sistema de reparacion */
	       {
                    -- No a lugar--
	        }
  
		    /* caluclo tiempo por encima de umbrales */
		    total_fallos = fallos_maximos(sistema);
                  
		    hasta_que_pos_umbral = hasta_que_umbral_afecta(fallos_antes, umbrales);
		    
            for (i=0;i<=hasta_que_pos_umbral;i++) 
            {
                tiempos_en_umbral[i] = tiempos_en_umbral[i] + cantidad_a_reducir;
            }
            			
		    /* *** RESTART *** */
		    total_fallos = fallos_maximos(sistema);
            
			if ((total_fallos < umbrales[umbral_hilo-1]) && !(umbral_hilo == 0))/* si se ha bajado del umbral */
			{        
					if (ultimo_hilo == 0) /* si no es ultimo hilo se corta */
					   {descenso_umbral = 1;}
					else {if ((ultimo_ha_descendido == 1) || (umbral_hilo == 1))/* es ultimo hilo y ya ha bajado o es el mas bajo*/
					         { /* si el hilo es del primer umbral no puede bajar dos veces, es excepcion */  
							     if (intentos_restantes[umbral_hilo -1] == 0) /* no quedan mas por atras */
								 {
						            umbral_hilo = umbral_hilo -1;
								    ultimo_ha_descendido = 0;
								 }
								 else{descenso_umbral = 1;} /* quedan por atras, debe cortarse */
							 }
						  else {ultimo_ha_descendido = 1; umbral_hilo = umbral_hilo -1;}
						 } 
			}
			else
			{       
					if (total_fallos == umbrales[umbral_hilo]) /* si alcanza un umbral superior */
					{
							if (umbral_hilo == (num_umbrales - 1)) /* umbral final */
							{                                                                           
                                    if (hilo_fallo == 0)
									{       
											hilo_fallo = 1;
											num_fallos++;
									}	                               						
							}
							else /* umbral intermedio */
							{		 
							        ultimo_ha_descendido = 0;
									umbral_hilo++;
								    intentos_restantes[umbral_hilo-1] = reintentos_umbrales[umbral_hilo -1]; /* se reponen */
                                    captura_estado(umbral_hilo, estado_int, estado_float, acontecimientos, sistema_reparacion, sistema, tasas_de_fallos, 
												*funcionamiento_sistema, reloj, funcionamiento_sistema_, reloj_);
								
									for (i=1;i<= reintentos_umbrales[umbral_hilo-1];i++)
									{/* el umbral 1, esta en la pos 0, etc */
											if (!(i == reintentos_umbrales[umbral_hilo-1])) {ultimo_hilo = 0;}
											else {ultimo_hilo = 1; ultimo_ha_descendido = 0;}
											
											 
											if (i==1) {primer_hilo = 1;} 
											else {primer_hilo = 0;}
											num_fallos = num_fallos + ejecuta_muestra(periodo_MTBF, MTBF, contadorfallosMTBF, primerMTBF, primer_fallo, sumacuadradoMTTT, sumaMTTT, transicion_pasada, tiempos_en_umbral, hilos_indisponibilidad, ultimo_hilo, primera_ejecucion, intentos_restantes, primer_hilo, reloj, 
											                                        umbral_hilo, funcionamiento_sistema, acontecimientos, sistema_reparacion, sistema, 
																					tasas_de_fallos, landas, umbrales, reintentos_umbrales, funcionamiento_sistema_, reloj_, estado_float, estado_int);
											vuelta_hilo = 1;
											if (no_quedan_reintentos(intentos_restantes) == 1) {return(num_fallos);}
									}
							}
					}
			}	/* fin restart */
		}
		else {/* para que salga porque ese acontecimiento ya se pasaba */
		      
			  if (*funcionamiento_sistema == 0) {hilos_indisponibilidad[0] = hilos_indisponibilidad[0]+1;
                                                 tiempos_en_umbral[num_umbrales-1] = tiempos_en_umbral[num_umbrales-1] + cantidad_a_reducir;
                                                 }
			 } 
	} /* fin de la muestra */
	
	return(num_fallos);	
}

Hay momentos en la ejecución de esta simulación que no haría falta toda la información guardada, y lo de la pila no me sirve, podría liberarla periódicamente, pero nose como. :)
Gracias por la ayuda.