Question

我是C ++的新手，我发现这个伙伴系统内存分配代码但没有主要功能，所有成员函数都是正确的，我希望你们帮我主要功能，我想分配一些内存，然后显示分配之前和之后的内存状态，然后释放内存以验证伙伴正在合并，并显示空闲块列表

- BuddyPool.h -

#ifndef  BUDDYPOOL_INC
#define  BUDDYPOOL_INC

class BuddyPool{
public:
    enum Status { free, reserved };
    struct Header
    {
        Status status: 1;
        //unsigned int k : bitsizeof(unsigned int) - 1U;
        unsigned int k : 31;
    };
    struct Block : public Header
    {
        //enum { size = 16 };

        enum { size = 64 };
        struct Links
        {
            Block *next;
            Block *prev;
        };
        union
        {
            Links link;
            char userPart [size - sizeof(Header)];
        };
    };

private:
    unsigned int m;
    unsigned int numberOfBlocks;
    Block *pool;
    Block *sentinel;

    static void Unlink(Block &);
    static void InsertAfter(Block &, Block &);
    Block &Buddy(Block &) const;

public:
    BuddyPool(size_t);
    ~BuddyPool();

    void *Acquire(size_t);
    void Release(void *);
};

#endif   /* ----- #ifndef BUDDYPOOL_INC  ----- */

- BuddyPool.cpp -

#include <WinDef.h>
#include "BuddyPool.h"

unsigned int Log2Ceil(unsigned int val){
    unsigned int L;
    for (L = 0; (1ul<<L) < val; L++);
    return L;
}

BuddyPool::BuddyPool(size_t bytes) 
    : m(Log2Ceil(bytes))
    , numberOfBlocks( (1 << m) / sizeof(Block))
    , pool (new Block[numberOfBlocks + m +1])
    , sentinel(pool + numberOfBlocks)
{
    for (unsigned int i = 0; i <= m; ++i) {
        sentinel[i].link.next = &sentinel[i];
        sentinel[i].link.prev = &sentinel[i];
    }

    Block &head = pool[0];
    head.status = free;
    head.k = m;
    InsertAfter(sentinel[m], head);
}

BuddyPool::~BuddyPool(){
    delete [] pool;
}

void *BuddyPool::Acquire(size_t bytes){
    unsigned int kPrime = Log2Ceil(bytes + sizeof(Header));

    unsigned int i = kPrime;
    while (i <= m && sentinel[i].link.next == &sentinel[i]) {
        ++i;
    }
    if (i > m) {
        return NULL;    // throw bad_alloc("out of memory");
    }

    Block &block = *sentinel[i].link.next;
    Unlink(block);
    while (block.k > kPrime) {
        block.k -= 1;
        Block &buddy = Buddy(block);
        buddy.status = free;
        buddy.k = block.k;
        InsertAfter(sentinel[buddy.k], buddy);
    }
    block.status = reserved;
    return block.userPart;
}

void BuddyPool::Release(void *arg){
    Block &block = *reinterpret_cast<Block *>(
                                              reinterpret_cast<Header *>(arg) - 1U);

    if (&block < pool || &block >= pool + numberOfBlocks) {
        return; // throw invalid_argument("invalid pointer");
    }

    block.status = free;
    Block *ptr;
    for (ptr = &block; ptr->k < m; ptr->k += 1) {
        Block &buddy = Buddy(*ptr);
        if (buddy.status == reserved || buddy.k != ptr->k) {
            break;
        }
        Unlink(buddy);
        if (&buddy < ptr) {
            ptr = &buddy;
        }
    }

    InsertAfter(sentinel[ptr->k], *ptr);
}

BuddyPool::Block &BuddyPool::Buddy(Block &block) const{
    unsigned int addr = reinterpret_cast<unsigned int>(&block) + (1 << block.k);
    return *(reinterpret_cast<Block *>(addr));
}

void BuddyPool::Unlink(Block &block){
    if (block.link.next) {
        block.link.next->link.prev = block.link.prev;
    }
    if (block.link.prev) {
        block.link.prev->link.next = block.link.next;
    }
    block.link.next = block.link.prev = &block;
}

void BuddyPool::InsertAfter(Block &src, Block &block){
    block.link.next = src.link.next;
    block.link.prev = &src;

    if (src.link.next) {
        src.link.next->link.prev = &block;
    }
    src.link.next = &block; 
}

Answer 1

你可以从调用公共函数开始。

可视化内部活动是相当困难的。对此没有简短的答案。对于某些语言，例如python，有可视化工具，甚至是在线可视化工具，但对于c ++要求它就像要求SO读者为你开发应用程序... l

更高级的用法：将调用包装在标准的allocator类中（参见std::allocator），然后您可以使用它来进行分配和解除分配。 std::vector。

和/或您可以为某个类定义operator new和operator delete（分别为单个对象分配和解除定位函数）

伙伴记忆分配 - 主要功能

1 个答案: