fork download 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stddef.h>
  4.  
  5. typedef struct MemoryBlock {
  6.     void* start_addr;
  7.     size_t size;
  8.     struct MemoryBlock* next;
  9. } MemoryBlock;
  10.  
  11. MemoryBlock* free_list = NULL;
  12.  
  13. void initialize_memory(void* base_addr, size_t total_size) {
  14.     free_list = (MemoryBlock*)malloc(sizeof(MemoryBlock));
  15.     free_list->start_addr = base_addr;
  16.     free_list->size = total_size;
  17.     free_list->next = NULL;
  18. }
  19.  
  20. void print_free_list() {
  21.     MemoryBlock* current = free_list;
  22.     printf("Free Memory Blocks:\n");
  23.     while (current != NULL) {
  24.         printf("  Address: %p, Size: %zu\n", current->start_addr, current->size);
  25.         current = current->next;
  26.     }
  27. }
  28.  
  29. // Hàm cấp phát bộ nhớ First Fit
  30. void* firstfit_malloc(size_t size) {
  31.     MemoryBlock *prev = NULL, *curr = free_list;
  32.  
  33.     while (curr != NULL) {
  34.         if (curr->size >= size) {
  35.             void* alloc_addr = curr->start_addr;
  36.  
  37.             if (curr->size == size) {
  38.                 if (prev == NULL) free_list = curr->next;
  39.                 else prev->next = curr->next;
  40.                 free(curr);
  41.             } else {
  42.                 curr->start_addr = (char*)curr->start_addr + size;
  43.                 curr->size -= size;
  44.             }
  45.  
  46.             return alloc_addr;
  47.         }
  48.  
  49.         prev = curr;
  50.         curr = curr->next;
  51.     }
  52.  
  53.     return NULL;
  54. }
  55.  
  56. // Hàm cấp phát bộ nhớ Best Fit
  57. void* bestfit_malloc(size_t size) {
  58.     MemoryBlock *best_fit = NULL, *best_fit_prev = NULL;
  59.     MemoryBlock *prev = NULL, *curr = free_list;
  60.  
  61.     while (curr != NULL) {
  62.         if (curr->size >= size) {
  63.             if (best_fit == NULL || curr->size < best_fit->size) {
  64.                 best_fit = curr;
  65.                 best_fit_prev = prev;
  66.             }
  67.         }
  68.         prev = curr;
  69.         curr = curr->next;
  70.     }
  71.  
  72.     if (best_fit == NULL) return NULL;
  73.  
  74.     void* alloc_addr = best_fit->start_addr;
  75.  
  76.     if (best_fit->size == size) {
  77.         if (best_fit_prev == NULL) free_list = best_fit->next;
  78.         else best_fit_prev->next = best_fit->next;
  79.         free(best_fit);
  80.     } else {
  81.         best_fit->start_addr = (char*)best_fit->start_addr + size;
  82.         best_fit->size -= size;
  83.     }
  84.  
  85.     return alloc_addr;
  86. }
  87.  
  88. // Hàm giải phóng và hợp nhất khối liền kề
  89. void free_mem(void* addr, size_t size) {
  90.     MemoryBlock* new_block = (MemoryBlock*)malloc(sizeof(MemoryBlock));
  91.     new_block->start_addr = addr;
  92.     new_block->size = size;
  93.     new_block->next = NULL;
  94.  
  95.     if (free_list == NULL || free_list->start_addr > addr) {
  96.         new_block->next = free_list;
  97.         free_list = new_block;
  98.     } else {
  99.         MemoryBlock* curr = free_list;
  100.         while (curr->next != NULL && curr->next->start_addr < addr) {
  101.             curr = curr->next;
  102.         }
  103.         new_block->next = curr->next;
  104.         curr->next = new_block;
  105.     }
  106.  
  107.     // Hợp nhất khối liền kề
  108.     MemoryBlock* curr = free_list;
  109.     while (curr != NULL && curr->next != NULL) {
  110.         void* curr_end = (char*)curr->start_addr + curr->size;
  111.         if (curr_end == curr->next->start_addr) {
  112.             curr->size += curr->next->size;
  113.             MemoryBlock* temp = curr->next;
  114.             curr->next = temp->next;
  115.             free(temp);
  116.         } else {
  117.             curr = curr->next;
  118.         }
  119.     }
  120. }
  121. int main() {
  122.     void* memory_pool = malloc(2048); // Giả lập bộ nhớ ban đầu
  123.  
  124.     initialize_memory(memory_pool, 2048);
  125.     print_free_list();
  126.  
  127.     void* ptr1 = firstfit_malloc(256);
  128.     printf("\nAfter allocating 256 bytes:\n");
  129.     print_free_list();
  130.  
  131.     void* ptr2 = bestfit_malloc(128);
  132.     printf("\nAfter allocating 128 bytes:\n");
  133.     print_free_list();
  134.  
  135.     free_mem(ptr1, 256);
  136.     printf("\nAfter freeing 256 bytes:\n");
  137.     print_free_list();
  138.  
  139.     // Đừng quên giải phóng vùng memory_pool nếu không dùng nữa
  140.     free(memory_pool);
  141.     return 0;
  142. }
  143.  
Success #stdin #stdout 0s 5284KB
comments (?)
stdin 
Standard input is empty
stdout 
Free Memory Blocks:
  Address: 0x5650ef353260, Size: 2048

After allocating 256 bytes:
Free Memory Blocks:
  Address: 0x5650ef353360, Size: 1792

After allocating 128 bytes:
Free Memory Blocks:
  Address: 0x5650ef3533e0, Size: 1664

After freeing 256 bytes:
Free Memory Blocks:
  Address: 0x5650ef353260, Size: 256
  Address: 0x5650ef3533e0, Size: 1664
https://ideone.com/6avtlL
language:
C (gcc 8.3)
created:
12 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!