elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Tutorial básico de Quickjs


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  problema de memoria con readdir (Solucionado)		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: problema de memoria con readdir (Solucionado)  (Leído 2,378 veces)
AlbertoBSD
Programador y
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.705


🏴 Libertad!!!!!


Ver Perfil WWW
problema de memoria con readdir (Solucionado)
« en: 29 Noviembre 2018, 18:47 pm »
Muy buen dia.

Problema: La memoria utilizada por el programa aumenta y no disminuye

Solución: No es un problema, es la memoria que se genera por el paradigma de la recursividad, esto es: que al llamar a la misma función de forma recursiva, el Stack Frame de la memoria que utiliza cada una de las llamadas a la función se acumule.

Intente aplicar una solucion de forma Iterativa, guardando el Path de los directorios que faltan por leer en una Queue, pero utiliza mas memoria  que la solucion recursiva.

readdir devuelve un apuntador de la estructura (struct dirent)
Mas info: https://linux.die.net/man/3/readdir

El cual creo que es el causante de este POST.

Versión Corta

¿Quien controla el Apuntador entregado por readdir?

Es memoria estatica y no se debe de liberar

Código
  1. directorio_archivo_temporal = readdir(directorio)

Al momento de tratar de liberar dicho apuntador, el programa se cuelga...

Código
  1. while(directorio_archivo_temporal = readdir(directorio) )	{
  2. 	//etc..
  3. 	free(directorio_archivo_temporal);
  4. }
  5.  

El problema radica en que la memoria del programa solo aumenta y no disminuye.

Codigo de la version corta funcionando
Código
  1. #include<sys/stat.h>
  2. #include<sys/types.h>
  3. #include<dirent.h>
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<string.h>
  7.  
  8. int is_regular_file(const char *path);
  9.  
  10. int procesar_directorio(char *path);
  11.  
  12. int main(int argc,char **argv)	{
  13. 	switch(argc){
  14. 		case 2:	//Se espera directorio
  15. 			procesar_directorio(argv[1]);
  16. 		break;
  17. 		default:
  18. 			printf("Numero de argumentos no esperado\n");
  19. 		break;
  20. 	}
  22.  
  23. }
  24.  
  25. int is_regular_file(const char *path)	{
  26. 	struct stat path_stat;
  27. 	stat(path, &path_stat);
  28. 	return S_ISREG(path_stat.st_mode);
  29. }
  30.  
  31. int procesar_directorio(char *path)	{
  32. 	DIR *directorio;
  33. 	struct dirent *directorio_archivo_temporal;
  34. 	char *path_copy;
  35. 	int len_path;
  36. 	char *path_temporal;
  37. 	int len_path_temporal;
  38. 	directorio = opendir(path);
  39. 	if(directorio != NULL)	{	
  40. 		len_path = strlen(path);
  41. 		path_copy = malloc(len_path+2);
  42. 		memcpy(path_copy,path,len_path);
  43. 		if(path_copy[len_path - 1] == '\\' ){
  44. 			path_copy[len_path] = '\0';
  45. 		}
  46. 		else	{
  47. 			path_copy[len_path] = '\\';
  48. 			path_copy[len_path+1] = '\0';
  49. 			len_path++;
  50. 		}
  51. 		while(directorio_archivo_temporal = readdir(directorio) )	{		
  52. 			len_path_temporal = strlen(directorio_archivo_temporal->d_name);
  53. 			path_temporal = malloc(len_path+len_path_temporal+1);
  54. 			path_temporal[len_path+len_path_temporal] = '\0';
  55. 			sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
  56. 			if(is_regular_file(path_temporal))	{
  57. 				printf("%s\n",path_temporal);
  58. 			}
  59. 			else	{	//Directorio?
  60. 				if( len_path_temporal > 2 ) { //not .. or .
  61. 					procesar_directorio(path_temporal);	//recursivamente
  62. 				}			
  63. 			}
  64. 			free(path_temporal);
  65. 		}
  66. 		free(path_copy);
  67. 		closedir(directorio);
  68. 	}
  69. }
  70.  







Versión extensa

Aquí esta toda la Letanía

Estoy realizando un programa que lea de forma Recursiva un directorio dado y liste los archivos en pantalla. Nada del otro mundo. Asi mismo estoy haciendo que el formato de salida sea el formato tipo UNIX /bla/bla/bla en lugar del formato de windows C:\lalala\lalalala.txt

Esto con el objetivo de virtualizar el path de subdirectorios específicos para otro programa pero eso ya es harina de otro costal.

El problema es que cuando listo Cualquier carpeta con muchos subdirectorios como la unidad C:\  el programa en empieza usando lo clasico unos 400 KB y termina utilizando 800 KB o mas dependiendo de la carpeta que este listada.

El dia Ayer publique un post parecido:
Problema de memoria en miniservidor usando Winsock (Solucionado)

En el cual se estaba cerrando el socket de forma incorrecta.

En este caso creo que es problema del apuntador devuelto por readdir.

Código del programa funcionando:

Código
  1. #include<sys/stat.h>
  2. #include<sys/types.h>
  3. #include<dirent.h>
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<string.h>
  7.  
  8. int fsize(const char *filename);
  9. int is_regular_file(const char *path);
  10.  
  11. int procesar_directorio(char *path,char *virtual_path);
  12.  
  13. int main(int argc,char **argv)	{
  14. 	switch(argc){
  15. 		case 2:	//Se espera directorio
  16. 			procesar_directorio(argv[1],"/");
  17. 		break;
  18. 		case 3:	//Se espera archivo + nombre de directorio de destino.
  19. 		break;
  20. 		default:
  21. 			printf("Numero de argumentos no esperado\n");
  22. 		break;
  23. 	}
  25.  
  26. }
  27.  
  28. int is_regular_file(const char *path)	{
  29. 	struct stat path_stat;
  30. 	stat(path, &path_stat);
  31. 	return S_ISREG(path_stat.st_mode);
  32. }
  33.  
  34. int fsize(const char *filename) {
  35.     struct stat st;
  36.     if (stat(filename, &st) == 0)
  37.         return st.st_size;
  38.     return -1; 
  39. }
  40.  
  41. int procesar_directorio(char *path,char *virtual_path)	{
  42. 	DIR *directorio;
  43. 	struct dirent *directorio_archivo_temporal,*result;
  44.  
  45. 	char *path_copy;
  46. 	char *virtual_path_copy;
  47. 	int len_path,len_virtual_path;
  48.  
  49. 	char *path_temporal;
  50. 	char *virtual_path_temporal;
  51. 	int len_path_temporal;
  52. 	int len_virtual_path_temporal;
  53.  
  54.  
  55. 	directorio = opendir(path);
  56. 	if(directorio != NULL)	{	
  57.  
  58. 		len_path = strlen(path);
  59. 		len_virtual_path = strlen(virtual_path);
  60.  
  61. 		virtual_path_copy = malloc(len_virtual_path+2);
  62. 		path_copy = malloc(len_path+2);
  63. 		memcpy(path_copy,path,len_path);
  64. 		memcpy(virtual_path_copy,virtual_path,len_virtual_path);
  65.  
  66. 		if(path_copy[len_path - 1] == '\\' ){
  67. 			path_copy[len_path] = '\0';
  68. 		}
  69. 		else	{
  70. 			path_copy[len_path] = '\\';
  71. 			path_copy[len_path+1] = '\0';
  72. 			len_path++;
  73. 		}
  74. 		if(virtual_path_copy[len_virtual_path - 1] == '/' ){
  75. 			virtual_path_copy[len_virtual_path] = '\0';
  76. 		}
  77. 		else	{
  78. 			virtual_path_copy[len_virtual_path] = '/';
  79. 			virtual_path_copy[len_virtual_path+1] = '\0';
  80. 			len_virtual_path++;
  81. 		}
  82. 		/*
  83. 		directorio_archivo_temporal = calloc(1,sizeof(struct dirent));
  84. 		result == NULL;
  85. 		*/
  86. 		//while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){
  87. 		while(directorio_archivo_temporal = readdir(directorio) )	{
  88.  
  89. 			len_path_temporal = strlen(directorio_archivo_temporal->d_name);
  90. 			//printf("readdir point to %p\n",directorio_archivo_temporal);
  91. 			//printf("Len %i : %s\n",len_path_temporal,directorio_archivo_temporal->d_name);
  92.  
  93. 			path_temporal = malloc(len_path+len_path_temporal+1);
  94. 			virtual_path_temporal = malloc(len_virtual_path + len_path_temporal+1);
  95.  
  96. 			path_temporal[len_path+len_path_temporal] = '\0';
  97. 			virtual_path_temporal[len_virtual_path+len_path_temporal] = '\0';
  98.  
  99. 			sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
  100. 			sprintf(virtual_path_temporal,"%s%s",virtual_path_copy,directorio_archivo_temporal->d_name);
  101.  
  102. 			if(is_regular_file(path_temporal))	{
  103. 				//printf("Archivo :\"%s\"\n",path_temporal);
  104. 				printf("%s\n",virtual_path_temporal);
  105. 			}
  106. 			else	{	//Directorio?
  107. 				if( len_path_temporal > 2 ) { //not .. or .
  108. 					procesar_directorio(path_temporal,virtual_path_temporal);	//recursivamente
  109. 				}			
  110. 			}
  111. 			free(path_temporal);
  112. 			free(virtual_path_temporal);
  113. 		}
  114. 		//free(directorio_archivo_temporal);
  115.  
  116.  
  117.  
  118. 		free(path_copy);
  119. 		free(virtual_path_copy);
  120. 		closedir(directorio);
  121. 	}
  122. 	else	{
  123. 		printf("El directorio \"%s\" no es un directorio valido\n",path);
  124. 	}
  125. }
  126.  

Funciona bien, recibe parametros de entrada, ejemplo

Ejemplo

Código:
C:\>generar_contenido.exe contenido
/index.html

Le agregue un getchar al final del archivo para poder ver con cuanta memoria termina el programa. Para carpetas sin tanto subdirecorio no hay problema, el detalle es cuando se trata de todo un disco...

Imagen:


Ya he validado que todos los apuntadores que yo genero de forma dinámica son liberados en su totalidad, esto mediante re implementaciones de malloc,calloc,realloc y free como describo en el siguiente post: ¿He liberado todos los apuntadores?

Imagen:


Con lo cual considero que el problema es el apuntador devuelto por readdir.

Intente cambiar el siguiente pedazo de codigo

Código
  1. while(directorio_archivo_temporal = readdir(directorio) )	{
  2. 	//etc...
  3. }
  4.  

por

Código
  1. while(directorio_archivo_temporal = readdir(directorio) )	{
  2. 	//etc..
  3. 	free(directorio_archivo_temporal);
  4. }
  5.  

Pero el programa se queda colgado por un rato y finaliza, seguramente por tratar de escribir en memoria que no esta asignada...

Intente implementarlo con readdir_r utilizando mi propio apuntador previamente asignado..

Código
  1. while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){
  2.  

Pero por alguna razon MinGW no lo tiene implementado, y segun he visto ya esta deprecated, entonces ¿Cual puede ser la solución?

Saludos!


Pordon por el Post tan largo, aqui esta su patata
« Última modificación: 30 Noviembre 2018, 04:40 am por AlbertoBSD » En línea
CalgaryCorpus


Desconectado Desconectado

Mensajes: 323


Ver Perfil WWW
Re: problema de memoria con readdir
« Respuesta #1 en: 29 Noviembre 2018, 21:35 pm »
Segun la documentacion, readdir usa memoria estatica, de modo que no corresponde usar free() sobre lo que se retorna.
En línea
Aqui mi perfil en LinkedIn, invitame un cafe aqui
CalgaryCorpus


Desconectado Desconectado

Mensajes: 323


Ver Perfil WWW
Re: problema de memoria con readdir
« Respuesta #2 en: 29 Noviembre 2018, 22:10 pm »
Sugiero reemplazar esto de pedir y liberar memoria en cada vuelta del while por solo pedir memoria cuando es necesario pedirla, y no liberarla en cada vuelta, solo liberarla al final del while.

Algo asi como:

Código
  1. buffer = NULL;
  2. memoria_actual = 0;
  3. while( ... ) {
  4.    memoria_requerida = ...  // calcular cuanto se requiere 
  5.    if( memoria_requerida > memoria_actual ) {
  6.        // liberar la memoria anterior, pedir tanta como memoria_requerida, o hacer realloc
  7.        ..
  8.        // y actualizar cual es el tamano actual
  9.        memoria_actual = memoria_requerida;
  10.    }
  11.    // copiar hacia buffer
  12.  
  13.    // la logica actual
  14.    if( is_regular_file ....) {
  15.    } 
  16.    //etc
  17.  
  18.    // no liberar la memoria en cada vuelta
  19. }
  20.  
  21. free(buffer);  // liberar al final.
  22.  
« Última modificación: 29 Noviembre 2018, 22:11 pm por CalgaryCorpus » En línea
Aqui mi perfil en LinkedIn, invitame un cafe aqui
AlbertoBSD
Programador y
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.705


🏴 Libertad!!!!!


Ver Perfil WWW
Re: problema de memoria con readdir (Solucionado)
« Respuesta #3 en: 30 Noviembre 2018, 04:57 am »
Cita de: CalgaryCorpus en 29 Noviembre 2018, 21:35 pm
Segun la documentacion, readdir usa memoria estatica, de modo que no corresponde usar free() sobre lo que se retorna.

Excelente, segun veo usa parte de la misma estrucutra original del directorio pasado como parametro. o algo asi alcance a ver.

Cita de: CalgaryCorpus en 29 Noviembre 2018, 22:10 pm
Sugiero reemplazar esto de pedir y liberar memoria en cada vuelta del while por solo pedir memoria cuando es necesario pedirla, y no liberarla en cada vuelta, solo liberarla al final del while.

Voy aplicarlo gracias!, ya que si termina siendo mas eficiente, por que evitaria tantas llamadas a malloc como sea posible.

Creo que ya encontre la solucion, según veo no es problema de memoria por liberar, es problema de la implementación recursiva de la función.

La solución recursiva es la que menos memoria utiliza.

Saludos!
« Última modificación: 30 Noviembre 2018, 05:05 am por AlbertoBSD » En línea
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
[Solucionado] Cargar DLL a memoria « 1 2 »
.NET (C#, VB.NET, ASP) 		seba123neo 13 12,263 Último mensaje 17 Septiembre 2010, 15:09 pm
por [D4N93R]
Función readdir
Programación C/C++ 		raquelsg88 2 1,913 Último mensaje 14 Junio 2013, 19:25 pm
por engel lex
Función readdir
Programación C/C++ 		raquelsg88 1 1,994 Último mensaje 14 Junio 2013, 16:31 pm
por aguml
Problema leyendo cadenas con memoria dinamica [solucionado]
Programación C/C++ 		dato000 9 7,211 Último mensaje 24 Enero 2014, 18:37 pm
por dato000
Problema de memoria en miniservidor usando Winsock (Solucionado)
Programación C/C++ 		AlbertoBSD 3 1,982 Último mensaje 29 Noviembre 2018, 10:42 am
por Eternal Idol
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines