【CS.OS】堆管理算法：不同的堆分配和管理算法

news2024/11/26 3:39:43

1000.5.CS.OS.1.3-基础-内存管理-堆管理算法-Created: 2024-06-09.Sunday10:41

文章目录

- - 1 内存分配算法概述
  - - 1.1 首次适应（First-Fit）
    - 1.2 最佳适应（Best-Fit）
  - 2 伙伴系统（Buddy System）
- 3 总结
- References

在操作系统和程序设计中，内存管理是一个至关重要的环节。不同的堆分配和管理算法，如首次适应（first-fit）、最佳适应（best-fit）和伙伴系统（buddy system），在内存分配和管理中发挥着重要作用。这篇文章将深入探讨这些算法，并通过示例代码展示其实现。

1 内存分配算法概述

内存分配算法用于动态地分配和释放内存，以便程序能够高效地使用系统资源。以下是一些常见的堆分配和管理算法：

1.1 首次适应（First-Fit）

首次适应算法是一种简单且快速的内存分配算法。它从头开始扫描内存分区表，找到第一个足够大的空闲块，并分配给请求的进程。

优点：

快速：由于从头开始扫描，通常能迅速找到合适的空闲块。
简单：实现和理解都较为简单。

缺点：

内存碎片：容易产生外部碎片，导致内存利用率下降。

示例代码：

#include <iostream>
#include <vector>

struct Block {
    int size;
    bool free;
    Block(int s) : size(s), free(true) {}
};

class FirstFitAllocator {
public:
    FirstFitAllocator(std::vector<int> blockSizes) {
        for (int size : blockSizes) {
            blocks.push_back(Block(size));
        }
    }

    void* allocate(int requestSize) {
        for (Block& block : blocks) {
            if (block.free && block.size >= requestSize) {
                block.free = false;
                return &block;
            }
        }
        return nullptr; // Allocation failed
    }

    void deallocate(void* ptr) {
        Block* block = static_cast<Block*>(ptr);
        block->free = true;
    }

private:
    std::vector<Block> blocks;
};

int main() {
    FirstFitAllocator allocator({100, 500, 200, 300, 600});
    void* ptr1 = allocator.allocate(150);
    void* ptr2 = allocator.allocate(100);
    allocator.deallocate(ptr1);
    void* ptr3 = allocator.allocate(50);
    return 0;
}

1.2 最佳适应（Best-Fit）

最佳适应算法通过扫描整个内存分区表，找到最接近请求大小的空闲块进行分配。这种方法尽量减少剩余的空闲块，降低外部碎片的产生。

优点：

内存利用率高：通过分配最接近大小的空闲块，减少了外部碎片。
有效：在内存资源紧张的情况下表现较好。

缺点：

扫描时间长：需要扫描整个内存分区表，可能导致分配时间较长。

示例代码：

#include <iostream>
#include <vector>
#include <limits>

struct Block {
    int size;
    bool free;
    Block(int s) : size(s), free(true) {}
};

class BestFitAllocator {
public:
    BestFitAllocator(std::vector<int> blockSizes) {
        for (int size : blockSizes) {
            blocks.push_back(Block(size));
        }
    }

    void* allocate(int requestSize) {
        int bestFitIndex = -1;
        int minDiff = std::numeric_limits<int>::max();

        for (int i = 0; i < blocks.size(); ++i) {
            if (blocks[i].free && blocks[i].size >= requestSize) {
                int diff = blocks[i].size - requestSize;
                if (diff < minDiff) {
                    minDiff = diff;
                    bestFitIndex = i;
                }
            }
        }

        if (bestFitIndex != -1) {
            blocks[bestFitIndex].free = false;
            return &blocks[bestFitIndex];
        }
        return nullptr; // Allocation failed
    }

    void deallocate(void* ptr) {
        Block* block = static_cast<Block*>(ptr);
        block->free = true;
    }

private:
    std::vector<Block> blocks;
};

int main() {
    BestFitAllocator allocator({100, 500, 200, 300, 600});
    void* ptr1 = allocator.allocate(150);
    void* ptr2 = allocator.allocate(100);
    allocator.deallocate(ptr1);
    void* ptr3 = allocator.allocate(50);
    return 0;
}

2 伙伴系统（Buddy System）

伙伴系统是一种平衡了首次适应和最佳适应优点的内存分配算法。它将内存分割成大小为2的幂次方的块，当需要分配内存时，会找到最小的满足请求的块。如果块大小过大，会将其分割成两个“伙伴”块，并继续分配。

优点：

内存碎片少：由于采用幂次方块，容易合并相邻空闲块，减少碎片。
分配和释放效率高：通过伙伴系统，分配和释放操作较为高效。

缺点：

内存浪费：有时会由于块大小限制，导致内存浪费。

示例代码：

#include <iostream>
#include <vector>
#include <cmath>

class BuddyAllocator {
public:
    BuddyAllocator(int size) {
        int n = std::ceil(std::log2(size));
        maxSize = 1 << n;
        freeBlocks.resize(n + 1);
        freeBlocks[n].push_back(0);
    }

    void* allocate(int size) {
        int n = std::ceil(std::log2(size));
        for (int i = n; i < freeBlocks.size(); ++i) {
            if (!freeBlocks[i].empty()) {
                int block = freeBlocks[i].back();
                freeBlocks[i].pop_back();
                while (i > n) {
                    --i;
                    int buddy = block ^ (1 << i);
                    freeBlocks[i].push_back(buddy);
                }
                return reinterpret_cast<void*>(block * minBlockSize);
            }
        }
        return nullptr; // Allocation failed
    }

    void deallocate(void* ptr) {
        int block = reinterpret_cast<int>(ptr) / minBlockSize;
        int size = 1;
        while (true) {
            int buddy = block ^ size;
            auto it = std::find(freeBlocks[std::log2(size)].begin(), freeBlocks[std::log2(size)].end(), buddy);
            if (it == freeBlocks[std::log2(size)].end()) {
                freeBlocks[std::log2(size)].push_back(block);
                break;
            }
            freeBlocks[std::log2(size)].erase(it);
            block &= ~size;
            size <<= 1;
        }
    }

private:
    int maxSize;
    int minBlockSize = 1;
    std::vector<std::vector<int>> freeBlocks;
};

int main() {
    BuddyAllocator allocator(1024);
    void* ptr1 = allocator.allocate(100);
    void* ptr2 = allocator.allocate(200);
    allocator.deallocate(ptr1);
    void* ptr3 = allocator.allocate(50);
    return 0;
}