1
다음 함수는 main 함수에서 여러 번 호출됩니다. 프로그램의 RAM 사용을 모니터링하고 있습니다. 이 기능이 호출 될 때마다 RAM 메모리 사용이 증가합니다. 문제는 함수가 종료되고 파일을 닫을 때마다 발생하며 RAM 메모리 사용량은 계속 증가합니다. 따라서이 함수를 몇 번 호출하면 너무 많은 메모리를 사용하기 때문에 시스템이 프로세스를 종료합니다. 이 문제로 저를 도울 수 있습니까?C 프로그램이 파일을 닫고 포인터를 해제 한 후에도 메모리를 해제하지 않는 이유는 무엇입니까?
파일을 닫은 후에도 메모리가 지워지지 않는 이유는 무엇입니까? 이 문제에 대한 해결책이 있습니까? 저의 가난한 코딩 기술로 흠뻑 젖어주십시오. 저는 C에서 아마추어이고이 코드는 수정되어 중복 변수를 찾을 수 있습니다. 라인으로
void find_path(char* hope_key_node)
{
char input_list[100];
char affected_dff_list[100];
char output_dependency[100]; // file name for storing the output cone of dependency
char input_no[100]; // file name for storing the number of inputs in each output cone of dependency
strcpy(input_list, circuit_name);
strcat(input_list, "/");
strcpy(affected_dff_list, input_list);
int inNum; // Stores the number of nodes in each output cone of dependency
memset(output_dependency, '\0', sizeof(output_dependency));
memset(input_no, '\0', sizeof(input_no));
strcpy(output_dependency, circuit_name); // This creates a new directory inside <circuit_name>/dependency/
strcat(output_dependency, "/dependency/");
//strcat(output_dependency, hope_key_node);
strcpy(input_no, output_dependency);
strcat(input_no, "inNum_");
strcat(input_no, hope_key_node);
printf("%s\n",input_no);
input_num = fopen(input_no,"w"); // For storing the number of nodes in each output cone of dependency
for(int ii = 0; ii < NO_OF_OUTPUT; ii++) // This loop iterates over the array of strings 'output_name[]' which contains the list of output nodes.
{
/*strcpy(output_dependency, circuit_name); // This creates a new file (of the name of output) inside <circuit_name>/dependency/<hope_key_node>/
strcat(output_dependency, "/dependency/");
strcat(output_dependency, hope_key_node);
strcat(output_dependency, "/");
strcat(output_dependency, output_name[ii]);
output_history = fopen(output_dependency,"w");
printf("\n%s\n",output_dependency);
if(output_history == NULL)
{
perror ("Error opening file: output_dependency: ");
exit(0);
}*/
inNum = 0; // Resetting the value of inNum for each cone
for(int i=0;i<count;i++) // Resetting the color values of all the nodes so that all the nodes are unvisited.
{
node_array[i].color=0;
}
/*for(int i=0;i<count;i++)
{
printf("%s\t%d\n",node_array[i].name,node_array[i].color);
}
*/
char **track_path = (char **)malloc(MAX_NODE * sizeof(char *)); // Array of strings which contains the track path diverging from a specific output (ii th output)
for(int i = 0; i < MAX_NODE; i++)
{
track_path[i] = (char *)malloc((100) * sizeof(char));
}
//char track_path[120000][100];
int path_counter = 0; // Stores the index which is used in the track_path
for(int jj = 0; jj< count; jj++)
{
if(!(strcmp(output_name[ii],node_array[jj].name)))
{
strcpy(track_path[path_counter],node_array[jj].name);
//fprintf(path_history,"%s\t====>", node_array[jj].name);
//fprintf(dff_history,"%s\t====>", node_array[jj].name);
//fprintf(output_history,"%s\t====>", node_array[jj].name);
//printf("%s**\n",node_array[jj].name);
path_counter++;
break;
}
}
// Shit storm. Please decode this at your own risk. It may lead to temporary loos of sanity.
while(path_counter>0)
{
char temp[200];
strcpy(temp,track_path[0]);
for(int mm = 0; mm <= path_counter-2; mm++)
{
strcpy(track_path[mm],track_path[mm+1]);
}
path_counter--;
for(int jj = 0; jj < count; jj++)
{
if(!(strcmp(temp,node_array[jj].name)) && strcmp(temp,hope_key_node))
{
//fprintf(output_history,"%s\t", node_array[jj].name); // Printing the output code of dependency
//fprintf(output_history,"%s\n", node_array[jj].name);
inNum++;
/*if(!(strcmp(node_array[jj].type, "DFF")))
{
fprintf(dff_history,"%s\t", node_array[jj].name);
/*for(int aa = 0; aa < dff_count; aa++)
{
if(!(strcmp(DFF_list[aa],node_array[jj].name)))
{
dff_dependency_matrix[ii][aa] = 1;
break;
}
}*/
//printf("******************************************************************************/n");
//printf("-----%s\t%d\n",node_array[jj].name,node_array[jj].no_of_input);
if(node_array[jj].no_of_input > 0)
{
for(int kk = 0; kk < node_array[jj].no_of_input; kk++)
{
{
//printf("\n++++%s\t\n", node_array[jj].name_input[kk]);
//printf("\n****%s\t%d\n",node_array[node_array[jj].index_of_input[kk]].name,node_array[node_array[jj].index_of_input[kk]].color);
if(node_array[node_array[jj].index_of_input[kk]].color == 0)
{
if(path_counter>0)
{
for(int mm = path_counter-1; mm >= 0; mm--)
{
strcpy(track_path[mm+1],track_path[mm]);
}
}
strcpy(track_path[0], node_array[jj].name_input[kk]);
//printf("@@@@%s\t", node_array[jj].name_input[kk]);
path_counter++;
node_array[node_array[jj].index_of_input[kk]].color = 1;
}
}
}
}
/*printf("\ntrack path \n");
for (int z = 0; z<path_counter;z++)
printf("%s\t",track_path[z]);
printf("\n\n");
*/
else
{
//fprintf(path_history,"%s\t", node_array[jj].name);
/*for(int xx = 0; xx< NO_OF_OUTPUT; xx++)
{
if(!(strcmp(node_array[jj].name, output_name[xx])))
{
cone_of_dependency[ii][xx] = '1';
}
} */
}
}
}
}
fprintf(input_num,"%s\t%d\n",output_name[ii], inNum);
//fprintf(path_history,"\n\n\n");
//fprintf(dff_history,"\n\n\n");
//fprintf(output_history,"\n\n\n"); //Do not change this. Other codes will throw segmentation error.
free(track_path);
//fclose(output_history);
}
fclose(input_num);
}
어디에서'malloc'을 자유롭게 할 수 있습니까? *** 모든 malloc 호출에는 대응하는'free' 호출이 필요합니다. –
함수의 끝에서 메모리가 더 이상 사용되지 않을 때. 예를 들어이 함수에서 track_path는 malloc이고 함수의 끝에서 해제됩니다. –
'track_path [i] = (char *) malloc ((100) * sizeof (char));'해당 없음'free()' – wildplasser