Как я могу правильно управлять распределением блоков памяти в C, не перезаписывая основной блок? ⇐ Linux

[Anonymous]

Цель проекта:
Я работаю над проектом C, целью которого является управление блоками памяти с помощью функций динамического распределения памяти, таких как realloc и malloc и сохраните их состояние в файле с именемblock.dat. Блок основной памяти (который представляет общий объем доступной памяти) хранится в этом файле, и его следует перезаписывать каждый раз, когда процессам выделяется больше блоков памяти. При выделении памяти размер основного блока следует уменьшить и добавить новые блоки, представляющие память, выделенную процессам.
Ожидаемый результат:
Когда я выделяю память процессу, я стремлюсь:

[*]Уменьшить размер основного блока.
[*] Создайте новый блок, представляющий память, назначенную процессу.
[*]Сохраните обновленное состояние памяти в файле block.dat.

Ожидаемое содержимое файла block.dat после выделения памяти процессу должно выглядеть следующим образом:

Код: Выделить всё

Name: MainBlock
Size: 6000000 bytes
State: Free
Block 1:
Name: Block1
Size: 2000000 bytes
Process assigned: Process_2
State: Occupied

Реализация кода:

[code]init_block[/code] функция для инициализации основного блока:

Код: Выделить всё

void init_block(MemoryBlock **memory, int *used_blocks) {
*memory = (MemoryBlock *)malloc(sizeof(MemoryBlock));  // Reserve space for the memory block
(*memory)->size = 8000000;  // Initialize the main block with 8 MB
(*memory)->free = 1;  // Block is free
strcpy((*memory)->name, "MainBlock");
strcpy((*memory)->process, "None");  // No process assigned

*used_blocks = 0;  // No blocks assigned yet

// Save the initial state of the block to the block.dat file
save_block_state(*memory, *used_blocks);

printf("Memory initialized:\nName: %s\nSize: %d bytes\nState: Free\n", (*memory)->name, (*memory)->size);
}

Функция для сохранения состояния блочной памяти:

Код: Выделить всё

void save_block_state(MemoryBlock *memory, int used_blocks) {
FILE *file = fopen("block.dat", "w");  // Open the file in write mode
if (file == NULL) {
perror("Error opening block.dat");
return;
}

// Save the main block
fprintf(file, "Name: %s\n", memory[0].name);
fprintf(file, "Size: %d bytes\n", memory[0].size);
fprintf(file, "State: %s\n", memory[0].free ? "Free" : "Occupied");

// Save the assigned blocks
for (int i = 1; i name);
fscanf(file, "Size: %d bytes\n", &(*memory)->size);
char state[10];
fscanf(file, "State: %s\n", state);
(*memory)->free = (strcmp(state, "Free") == 0) ? 1 : 0;

// Read the assigned blocks
int block_index = 0;
while (fscanf(file, "Block %d:\n", &block_index) == 1) {
(*memory) = (MemoryBlock *)realloc(*memory, (block_index + 1) * sizeof(MemoryBlock));

char block_name[50];
int block_size;
char process_name[50];

// Read the block data
fscanf(file, "Name: %s\n", block_name);
fscanf(file, "Size: %d bytes\n", &block_size);
fscanf(file, "Process assigned: %s\n", process_name);
fscanf(file, "State: Occupied\n");

// Assign the read data to the block
(*memory)[block_index - 1].size = block_size;
strcpy((*memory)[block_index - 1].name, block_name);
strcpy((*memory)[block_index - 1].process, process_name);
(*memory)[block_index - 1].free = 0;
}

*used_blocks = block_index;
fclose(file);
}

[code]assign_block[/code] реализация выделения блоков памяти:

Код: Выделить всё

void assign_block(MemoryBlock **memory, int *used_blocks) {

//Helper function that executes  get a list of process
get_total_process();

printf("Total available memory in the main block: %d bytes\n", (*memory)[0].size);

FILE *file = fopen("processes.dat", "r");
if (file == NULL) {
perror("Error opening processes.dat");
return;
}

printf("Processes available for memory assignment:\nProcess   | Memory Usage\n");
printf("--------------------------\n");
char line[256];
int process_index = 1;
while (fgets(line, sizeof(line), file)) {
printf("(%d) %s", process_index, line);
process_index++;
}
fclose(file);

int process_choice;
printf("Enter the number corresponding to the process to assign the memory block to: ");
scanf("%d", &process_choice);

int block_size;
printf("How many bytes of memory do you want to assign to the selected process?: ");
scanf("%d", &block_size);

if (block_size > (*memory)[0].size) {
printf("Error: Not enough memory in the main block.\n");
return;
}

(*memory)[0].size -= block_size;

*memory = (MemoryBlock *)realloc(*memory, (*used_blocks + 2) * sizeof(MemoryBlock));

MemoryBlock *new_block = &(*memory)[*used_blocks + 1];
new_block->size = block_size;
new_block->free = 0;
sprintf(new_block->name, "Block%d", *used_blocks + 1);
sprintf(new_block->process, "Process_%d", process_choice);

(*used_blocks)++;
save_block_state(*memory, *used_blocks);

printf("Assigned %d bytes to Process_%d.\n", block_size, process_choice);
printf("Remaining size in MainBlock: %d bytes\n", (*memory)[0].size);
}

[code]main[/code], реализующий Assign_block:

Код: Выделить всё

int main() {
MemoryBlock *memory = NULL;
int used_blocks = 0;

// Load the memory state from block.dat
load_block_state(&memory, &used_blocks);

// Assign a block to a process
assign_block(&memory, &used_blocks);

// Show the current memory state
show_mem_status(memory, used_blocks);

// Free allocated memory
free(memory);

return 0;
}

На самом деле я получил результат:
Проблема, с которой я столкнулся, заключается в том, что когда я пытаюсь назначить блок памяти процессу, вместо создания новый блок для процесса, похоже, что основной блок (

Код: Выделить всё

MainBlock

) перезаписывается данными вновь назначенного блока. Вот содержимое, которое я получаю в block.dat:

Код: Выделить всё

Name: MainBlock
Size: 2000000 bytes
State: Occupied

Кроме того, когда я запускаю функцию show_mem_status после назначения блока, я получаю следующий вывод:

Код: Выделить всё

--------------------------------------------------------------------------------
Name: MainBlock
Size: 2000000 bytes
State: Occupied
--------------------------------------------------------------------------------

когда ожидаемый результат должен быть:

Код: Выделить всё

Name: MainBlock
Size: 6000000 bytes
State: Free
Block 1:
Name: Block1
Size: 2000000 bytes
Process assigned: Process_2
State: Occupied

Как видите, вместо уменьшения размера основного блока и создания нового блока для назначенного процесса основной блок перезаписывается данными из вновь назначенного блока. Ожидаемое поведение будет заключаться в том, что размер MainBlock уменьшится, а новый блок для Process_2 будет отображаться отдельно в выводе статуса.
Мой вопрос:
Как я могу изменить свою реализацию, чтобы предотвратить перезапись основного блока и вместо этого правильно добавить новый блок для каждого назначенного процесса?


Подробнее здесь: https://stackoverflow.com/questions/790 ... riting-the