用哈希表加链表实现动态malloc

/

//头文件

#include <stdio.h>
#include <stdlib.h>

#define STEP 0    //可动态增加内存次数
#define MAXMEM 10000   //每次从系统获取内存字节数
#define HASHSIZE 100   //哈希表数组大小
#define NODESIZE sizeof(Node)  //链表节点字节数

typedef struct Node {
 char _state;   //内存状态
 size_t _size;   //内存大小
 struct Node *_prev;  //主链表前一节点地址
 struct Node *_next;  //主链表下一节点地址
 struct Node *_free;  //Free哈希表项中的下一节点地址
 struct Node *_used;  //Used哈希表项中的下一节点地址
} Node;

extern Node *usedHashTable[HASHSIZE]; //Used哈希表
extern Node *freeHashTable[HASHSIZE]; //Free哈希表

void *mini_malloc(size_t size);  //申请内存
void mini_free(void *addr);  //释放内存

 

/

//内存分配与释放调用mini_malloc与mini_free

#include "mini_malloc.h"

int initFlag = 0; //标识位，判断是否初始化分配内存
int step = 0;  //当前动态申请增加内存次数
Node *usedHashTable[HASHSIZE] = {NULL}; //占用空间哈希表
Node *freeHashTable[HASHSIZE] = {NULL}; //空闲空间哈希表

void insertMain(Node **head, Node **pNode, size_t fsize); //将新建内存块插入到主链表中
void insertFree(Node **pNode); //将空闲空间以空间从小到大排序方式插入到Free哈希表相应项中
void pushUsed(Node **pNode); //将占用空间插入到Used哈希表相应项最前面
void delFree(Node **pNode); //将指定空间从Free哈希表中删除
void delUsed(Node **pNode); //将指定空间从Used哈希表中删除
void delMain(Node **pNode); //将指定空间从主链表中删除
int init_malloc();  //初始化分配内存，返回该内存对应Free哈希表的key
void *find_malloc(Node *head, size_t size); //在指定的Free哈希表项中查找满足size大小的内存并返回相应的地址
int freeHash(size_t size); //生成并返回Free哈希表key
int usedHash(void *addr); //生成并返回Used哈希表key

int freeHash(size_t size) {
 return ((size - 1) / HASHSIZE) % HASHSIZE; //size－1确保1～100（101～200，201～300...)存放在Free哈希表同一项中
}

int usedHash(void *addr) {
 return ((int)addr) % HASHSIZE;
}  

///
初始化分配内存，返回该内存对应Free哈希表的key
int init_malloc() {
 Node *L = (Node *)((char *)malloc(MAXMEM)); //申请MAXMEM大小内存，从中创建一个节点
 int key = 0;
 L->_state = '/0';    //标识该内存状态为空闲
 L->_size = (size_t)(MAXMEM - NODESIZE);  //计算当前实际可用字节数
 key = freeHash(L->_size);   //生成该内存对应Free哈希表的key
 L->_prev = NULL;
 L->_next = NULL;
 L->_free = NULL;
 L->_used = NULL;
 insertFree(&L);     //将当前空闲内存插入到Free哈希表中
 return key;
}

///
在指定的Free哈希表项中查找满足size大小的内存并返回相应的地址
void *find_malloc(Node *head, size_t size) {
 size_t fsize = 0;
 while (head) {
  fsize = head->_size;   //获取当前可用内存fsize
  if (fsize >= size) {   //如果当前可用内存fsize满足用户需求size
   head->_state = '1';  //标识当前内存为占用
   pushUsed(&head);  //将当前占用的内存插入到Used哈希表中
   delFree(&head);   //奖当前占用的内存从Free哈希表中删除
   if (fsize - size > NODESIZE) { //如果当前可用内存fsize超过用户需求size并且剩余内存能够组织新内存块
    head->_size = size; //设置前面占用内存大小为用户需求size
    Node *pNode = (Node *)((char *)head + NODESIZE + size); //创建新内存块
    insertMain(&head, &pNode, fsize - size - NODESIZE);  //将新内存块插入到主链表中
    insertFree(&pNode); //将新空闲内存插入到Free哈希表中
   }
   return (void *)((char *)head + NODESIZE); //返回内存实际可用地址
  }
  head = head->_free;
 }
 return NULL;
}

///
申请内存
void *mini_malloc(size_t size) {
 if (size < 1 || size > MAXMEM - NODESIZE) {  //如果用户需求内存大小超过最大可用内存数，则返回NULL
  return NULL;
 }
 if (initFlag == 0) {   //如果未初始化内存
  init_malloc();
  initFlag = 1;
 }
 void *T;
 int key = freeHash(size);  //获取用户需求内存所在Free哈希表中的key
 while (1) {
  while (key < HASHSIZE) {
   T = find_malloc(freeHashTable[key], size); //在用户需求内存所在Free哈希表项中查找满足需求的内存
   if (T != NULL) { //如果在相应Free哈希表项中找到满足需求的内存，则返回它的地址
    return T;
   }
   ++key;  //当在相应Free哈希表项中未找到满足需求的内存，则查找下一项
  }
  //当在Free哈希表中没有找到满足需求的内存，并且当前动态申请增加内存次数小于设定次数，则新开辟一块内存
  if (step < STEP) {
   ++step;
   key = init_malloc();
  }
  else {
   return NULL;
  }
 }
 return NULL;
}

///
释放内存
void mini_free(void *addr) {
 int key = usedHash((void *)((char *)addr - NODESIZE)); //获取用户需释放内存对应的Used哈希表key
 Node *head = usedHashTable[key]; //获取用户需释放内存对应Used哈希表项
 while (head) {
  if ((Node *)((char *)addr - NODESIZE) == head) { //如果当前内存为用户需释放的内存
   head->_state = '/0';  //标识当前内存为空闲
   Node *pNode = head;
   delUsed(&head);
   //如果当前内存下一内存也为空闲，则合并它
   if (head->_next != NULL && head->_next->_state == '/0') {
    delFree(&(head->_next));
    delMain(&(head->_next));
   }
   //如果当前内存上一内存也为空闲，则合并它
   if (head->_prev != NULL && head->_prev->_state == '/0') {
    pNode = head->_prev;
    delFree(&pNode);
    delMain(&head);
   }
   insertFree(&pNode);
   return;
  }
  head = head->_used;
 }
}

///
将新建内存块插入到主链表中
void insertMain(Node **head, Node **pNode, size_t fsize) {
 if (*head == NULL || *pNode == NULL) {
  return;
 }
 (*pNode)->_state = '/0';
 (*pNode)->_size = fsize;
 (*pNode)->_prev = *head;
 (*pNode)->_next = NULL;
 (*pNode)->_free = NULL;
 (*pNode)->_used = NULL;
 if ((*head)->_next != NULL) {
  (*pNode)->_next = (*head)->_next;
  (*head)->_next->_prev = *pNode;
 }
 (*head)->_next = *pNode;
}

///
将空闲空间以空间从小到大排序方式插入到Free哈希表相应项中
void insertFree(Node **pNode) {

 if (*pNode == NULL)
  return;
 int key = freeHash((*pNode)->_size);
 Node *head = freeHashTable[key];
 if (head == NULL) {
  freeHashTable[key] = *pNode;
  freeHashTable[key]->_free = NULL;
  return;
 }
 Node *prev = NULL;
 while (head) {
  if (head->_size > (*pNode)->_size) {
   if (prev == NULL) {
    (*pNode)->_free = freeHashTable[key];
    freeHashTable[key] = *pNode;
   }
   else {
    (*pNode)->_free = head;
    prev->_free = *pNode;
   }
   return;
  }
  prev = head;
  head = head->_free;
 }
 prev->_free = *pNode;
 (*pNode)->_free = NULL;
}

///
将占用空间插入到Used哈希表相应项最前面
void pushUsed(Node **pNode) {
 if (*pNode == NULL)
  return;
 int key = usedHash((void *)(*pNode));
 Node *head = usedHashTable[key];
 if (head == NULL) {
  usedHashTable[key] = *pNode;
  usedHashTable[key]->_used = NULL;
 }
 else {
  (*pNode)->_used = usedHashTable[key];
  usedHashTable[key] = *pNode;
 }
}

///
将指定空间从Free哈希表中删除
void delFree(Node **pNode) {
 if (*pNode == NULL)
  return;
 int key = freeHash((*pNode)->_size);
 Node *head = freeHashTable[key];
 Node *prev = NULL;
 while (head) {
  if (head == *pNode) {
   if (prev != NULL) {
    if (head->_free != NULL) {
     prev->_free = head->_free;
    }
    else {
     prev->_free = NULL;
    }
   }
   else {
    if (head->_free != NULL) {
     freeHashTable[key] = head->_free;
    }
    else {
     freeHashTable[key] = NULL;
    }
   }
   return;
  }
  prev = head;
  head = head->_free;
 }
}

///
将指定空间从Used哈希表中删除
void delUsed(Node **pNode) {
 if (*pNode == NULL)
  return;
 int key = usedHash((void *)(*pNode));
 Node *head = usedHashTable[key];
 Node *prev = NULL;
 while (head) {
  if (head == *pNode) {
   if (prev != NULL) {
    if (head->_used != NULL) {
     prev->_used = head->_used;
    }
    else {
     prev->_used = NULL;
    }
   }
   else {
    if (head->_used != NULL) {
     usedHashTable[key] = head->_used;
    }
    else {
     usedHashTable[key] = NULL;
    }
   }
   return;
  }
  prev = head;
  head = head->_used;
 }
}

///
将指定空间从主链表中删除
void delMain(Node **pNode) {
 Node *T = *pNode;
 if (T == NULL)
  return;
 if (T->_prev != NULL) {
  T->_prev->_size = T->_prev->_size + T->_size + NODESIZE;
  if (T->_next != NULL) {
   T->_prev->_next = T->_next;
   T->_next->_prev = T->_prev;
  }
  else {
   T->_prev->_next = NULL;
  }
 }
 else {
  printf("ERROR./n");
 }
}