Question

我正在尝试使用C中的二叉树来实现内存管理模拟（伙伴）。这里概述了系统如何工作的想法：

http://en.wikipedia.org/wiki/Buddy_memory_allocation

第一次输入值时，代码工作正常，并提供所需的输出。这个问题是第二次输入值时产生的。我使用递归函数遍历树，我得到一个错误，结构存在，但结构的成员不存在。

 Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 1 (LWP 1)]
 0x00010b2c in allocate (node=0x401ba18a, reqSize=1000) at temp.c:95
 95         if(node->flag == 1){
 (gdb) print node
 $1 = (struct block *) 0x401ba18a
 (gdb) print node->flag
 Cannot access memory at address 0x401ba192

相关代码发布在下面，真的很感激任何帮助！

 static int allocate(struct block* node, int reqSize) {
 //BASE CASES!
 printf("We've called allocate\n");
 //check if the request is too small
 if(reqSize < minSize){
     printf("The request is too small!\n");
     return -1;
 }
 //check if the request is too large
 if(reqSize > memory){
     printf("The request is too large!\n");
     return -1;
 }
 //check if the current block is already allocated
 if(node->flag == 1){
     printf("This block has been allocated!\n");
    return -1;
  }
   //var to hold returned value
   int returnVal = 0;
   //If the size of the request is less than or equal to half the node
  if(reqSize<(node->size)/2){
    printf("The size of the request is less than or equal too half the node\n");
    //check if there is a left node, if not, make one and call allocate
    if(node->left == NULL){
        printf("There's no left node so we are making one and calling allocate with     it\n");

        struct block buddy1 = { .init =1.};
        buddy1 = findSpace();
        buddy1.init = 1;
        buddy1.size = ((node->size)/2);
        printf("with the size %d\n",(node->size)/2);
        buddy1.flag = 0;
        buddy1.parent = node;
        buddy1.left = NULL;
        buddy1.right = NULL;

        struct block buddy2 = { .init =1.};
        buddy2 = findSpace();
        buddy2.init = 1;
        buddy2.size = ((node->size)/2);
        printf("with the size %d\n",(node->size)/2);
        buddy2.flag = 0;
        buddy2.parent = node;
        buddy1.left = NULL;
        buddy1.right = NULL;

        node->left = &buddy1;
        node->right = &buddy2;
        returnVal = allocate(node->left,reqSize);
        return returnVal;
    }
    //otherwise call allocate on the left node
    printf("There is a left node so we are calling allocate on it\n");
    returnVal = allocate(node->left,reqSize);

    if(returnVal == -1){
        printf("couldn't allocate a left node for some reason, so we are checking if a right node exists\n");
        if(node->right ==NULL){
            printf("it doesn't. We're making one and calling allocate on it!\n");
            struct block buddy = { .init =1.};
            buddy = findSpace();
            buddy.init = 1;
            buddy.size = ((node->size)/2);
            printf("with the size %d\n",(node->size)/2);
            buddy.flag = 0;
            buddy.parent = node;
            //node->left = NULL;
            node->right = &buddy;
            returnVal = allocate(&buddy,reqSize);
            }
            printf("it did, so we are calling allocate on it\n");
            returnVal = allocate(node->right,reqSize);
            //return returnVal;

    }
    return returnVal;
}

if(node->flag == 1){
    return -1;
}

printf("This is the node we need!\n");
node->flag = 1;
printPostOrder(&blockArr[position]);
return 1;
}

Answer 1

您的伙伴节点是局部变量，在堆栈上分配，并在分配函数返回时被销毁。您没有显示block结构或findSpace函数的定义，因此很难提供更多帮助。

为什么要部分初始化每个好友（.init被分配一个浮点1），然后立即用findSpace的返回值覆盖整个结构？

第三个伙伴（从左侧分配的右侧失败）没有像其他两个伙伴一样初始化它的左右指针NULL。这里有很多复制代码可能最好放在它自己的函数中。

通常，树结构是隐式的，您只需从位于每个空闲块前面的结构中创建一个空闲列表。合并块时，您可以通过将您的地址与您的尺寸进行异或来确定您的好友的地址。您只需要每个块一个位来告诉您伙伴是否空闲（并且具有标头结构），如果是，您可以检查标头以确保其大小相同。唯一需要的附加存储是一个位向量，每个最小可分配块为1位，允许您快速确定标头的存在而无需扫描空闲列表。哦，自由列表应该双重链接，允许您从中间删除元素（无需从头开始扫描列表）。如果您愿意为已分配的块添加标头，则可用大小将不再是2的幂，但您可以避免使用外部位向量。

二进制树结构实现的麻烦

1 个答案: