内存管理中所有分区分配方法的实现

在计算机中，内存是一种非常重要的资源。为了能够更好地管理内存，计算机系统会将内存分成多个分区，然后采用不同的分配方法来为不同的进程或线程分配内存。下面就来介绍一下所有分区分配方法的实现。

首次适应算法

首次适应算法是一种最简单、最直接的分配算法，其实现非常简单。当系统需要为一个进程或线程分配内存时，首次适应算法会从最开始的空闲分区开始查找，并将第一个能够满足内存需求的分区分配给该进程或线程。

# include <stdlib.h>

typedef struct _partition {
    void *start_address;        // 起始地址
    size_t size;                // 大小
} Partition;

Partition *memory;              // 内存分区数组
size_t partition_count;         // 内存分区数量

void *allocate_memory(size_t size) {
    for (size_t i = 0; i < partition_count; i++) {
        // 找到第一个可用的分区
        if (memory[i].size >= size) {
            void *address = memory[i].start_address;
            memory[i].start_address += size;
            memory[i].size -= size;
            return address;
        }
    }
    // 没有可用的分区
    return NULL;
}

最佳适应算法

最佳适应算法会根据所有空闲分区的大小，选择其中最小的一个，并将其分配给该进程或线程。这个算法会将所有空闲分区按大小排序，然后依次查找直到找到一个可用的分区。

void sort_partitions(void) {
    for (size_t i = 0; i < partition_count; i++) {
        for (size_t j = i + 1; j < partition_count; j++) {
            if (memory[i].size > memory[j].size) {
                Partition temp = memory[i];
                memory[i] = memory[j];
                memory[j] = temp;   
            }
        }
    }
}

void *allocate_memory(size_t size) {
    sort_partitions();
    for (size_t i = 0; i < partition_count; i++) {
        // 找到第一个可用的分区
        if (memory[i].size >= size) {
            void *address = memory[i].start_address;
            memory[i].start_address += size;
            memory[i].size -= size;
            return address;
        }
    }
    // 没有可用的分区
    return NULL;
}

最坏适应算法

最坏适应算法与最佳适应算法类似，不同的是，它会选择所有空闲分区中最大的一个分区作为进程或线程的分配位置。这个算法同样需要将所有空闲分区按大小排序。

void sort_partitions(void) {
    for (size_t i = 0; i < partition_count; i++) {
        for (size_t j = i + 1; j < partition_count; j++) {
            if (memory[i].size < memory[j].size) {
                Partition temp = memory[i];
                memory[i] = memory[j];
                memory[j] = temp;   
            }
        }
    }
}

void *allocate_memory(size_t size) {
    sort_partitions();
    for (size_t i = 0; i < partition_count; i++) {
        // 找到第一个可用的分区
        if (memory[i].size >= size) {
            void *address = memory[i].start_address;
            memory[i].start_address += size;
            memory[i].size -= size;
            return address;
        }
    }
    // 没有可用的分区
    return NULL;
}

邻近适应算法

邻近适应算法是一种比较复杂的分配算法，其实现需要维护一个空闲分区链表。当系统需要为一个进程或线程分配内存时，邻近适应算法会选择最小的能够满足大小需求的空闲分区，如果有多个这样的分区，那么会选择邻近的分区。

typedef struct _partition {
    void *start_address;        // 起始地址
    size_t size;                // 大小
    struct _partition *prev;    // 上一个分区
    struct _partition *next;    // 下一个分区
} Partition;

Partition *free_list;           // 空闲分区链表

void *allocate_memory(size_t size) {
    Partition *best_fit = NULL;
    Partition *current = free_list;
    while (current != NULL) {
        if (current->size >= size && (best_fit == NULL || current->size < best_fit->size)) {
            best_fit = current;
        }
        current = current->next;
    }
    if (best_fit != NULL) {
        void *address = best_fit->start_address;
        best_fit->start_address += size;
        best_fit->size -= size;
        if (best_fit->size == 0) {
            if (best_fit->prev != NULL) {
                best_fit->prev->next = best_fit->next;
            }
            if (best_fit->next != NULL) {
                best_fit->next->prev = best_fit->prev;
            }
            if (best_fit == free_list) {
                free_list = free_list->next;
            }
            free(best_fit);
        }
        return address;
    }
    // 没有可用的分区
    return NULL;
}

碎片整理算法

碎片整理算法是一种相对简单的算法，其思想是在整个内存中找到一段连续的空闲区域，并将所有已分配的内存移动到这段区域，然后合并所有剩余空闲区域。实现碎片整理算法需要维护一个链表来记录所有已分配的内存。

typedef struct _partition {
    void *start_address;        // 起始地址
    size_t size;                // 大小
    struct _partition *prev;    // 上一个分区
    struct _partition *next;    // 下一个分区
} Partition;

typedef struct _allocation {
    void *start_address;        // 起始地址
    size_t size;                // 大小
} Allocation;

Partition *partition_list;      // 所有分区链表
Allocation *allocation_list;    // 所有分配链表

void *allocate_memory(size_t size) {
    // ...
}

void compact_memory(void) {
    Partition *current = partition_list;
    void *end_address = NULL;
    while (current != NULL) {
        if (current->next != NULL && (char *)current->start_address + current->size == current->next->start_address) {
            if (end_address == NULL) {
                end_address = current->next->start_address + current->next->size;
            }
            Allocation *allocation = allocation_list;
            while (allocation != NULL) {
                if (allocation->start_address >= current->next->start_address && allocation->start_address < end_address) {
                    allocation->start_address += current->size;
                }
                allocation = allocation->next;
            }
            current->size += current->next->size;
            Partition *temp = current->next;
            current->next = current->next->next;
            if (current->next != NULL) {
                current->next->prev = current;
            }
            free(temp);
        } else {
            end_address = NULL;
        }
        current = current->next;
    }
}

以上就是所有分区分配方法的实现。不同的方法有各自的优缺点，具体应该根据实际情况进行选择。