使用多链表实现malloc

最新推荐文章于 2023-12-21 23:48:14 发布
最新推荐文章于 2023-12-21 23:48:14 发布
阅读量2.3k 收藏
点赞数
分类专栏： 数据结构 C 文章标签： null insert delete struct gcc 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qiujunchao/article/details/4381628
版权
本文介绍了一个简单的自定义内存分配器的实现方法，包括内存分配与释放的流程，并通过一系列测试验证其性能表现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//本人实在太懒了，没写一行注释，哈哈，没时间写，只是一个课堂练习

/

//makefile文件


OBJS=mainApp.o mini_malloc.o
malloc : mainApp.o mini_malloc.o
    gcc -g -o malloc ${OBJS}
mainApp.o : mainApp.c mini_malloc.h
    gcc -c -g mainApp.c
mini_malloc.o : mini_malloc.c mini_malloc.h
    gcc -c -g mini_malloc.c



/

//mini_malloc.h头文件


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

#define MAXMEM 100000
#define NODESIZE (sizeof(Node))

typedef unsigned int size_t;

typedef struct Node {
    char _used;
    struct Node *_prev;
    struct Node *_next;
    struct Node *_usedprev;
    struct Node *_usednext;
    struct Node *_freeprev;
    struct Node *_freenext;
} Node;
extern Node *L;
extern char *P;

void *mini_malloc(size_t size);
void mini_free(void *addr);




/

//mainApp.c测试malloc性能，相当棒的一段测试代码，老师写的，我是看不懂了


#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include "mini_malloc.h"
 
#define MAXSIZE 0x1000
#define REPEAT 100
#define MEMPOOL 10000
 
#define DISPLAYMEM
 
typedef struct UnitTestNode {
    size_t _size;
    void* _ptr;
    struct UnitTestNode* _next;
} UnitTestNode;
 
static UnitTestNode* head = NULL;
static UnitTestNode* tail = NULL;
 
static int mem = 0;
static int max_mem = 0;
static int count_succeed = 0;
static int count_failed = 0;
static int count_free = 0;
static double time_succeed = 0.0;
static double time_failed = 0.0;
static double time_free = 0.0;
 
int insert(size_t size) {
    clock_t start, finish;
    void* ptr = NULL;
 
    start = clock();
    ptr = mini_malloc(size);
    finish = clock();
 
    if (ptr == NULL) {
        ++count_failed;
        time_failed += (double)(finish - start) * 1000 / CLOCKS_PER_SEC;
        return 0;
    }
 
    ++count_succeed;
    time_succeed += (double)(finish - start) * 1000 / CLOCKS_PER_SEC;
    mem += size;
    if (mem > max_mem) {
        max_mem = mem;
    }
 
    memset(ptr, 0xff, size);
 
    if (tail != NULL) {
        tail->_next = (UnitTestNode*)malloc(sizeof(UnitTestNode));
        tail = tail->_next;
    } else {
        tail = (UnitTestNode*)malloc(sizeof(UnitTestNode));
        head = tail;
    }
    tail->_size = size;
    tail->_ptr = ptr;
    tail->_next = NULL;
    return 1;
}
 
void delete(void) {
    clock_t start, finish;
    UnitTestNode* pNode = NULL;
 
    if(head != NULL) {
        pNode = head;
        head = head->_next;
        if (head == NULL) {
            tail = NULL;
        }
 
        start = clock();
        mini_free(pNode->_ptr);
        finish = clock();
 
        ++count_free;
        time_free += (double)(finish - start) * 1000 / CLOCKS_PER_SEC;
        mem -= pNode->_size;
 
        free(pNode);
    }
}
 
int blank(size_t size) {
    UnitTestNode* pNode = NULL;
    insert(size);
    pNode = tail;
    if (insert(size)) {
        tail->_next = head;
        head = tail;
        tail = pNode;
        tail->_next = NULL;
        return 1;
    } else {
        return 0;
    }
}
 
void print(int mark) {
#ifdef DISPLAYMEM
    int i, line_max, line_step;
    line_max = MEMPOOL;
    line_step = 150;
    printf("#%d |", mark);
    for (i = 0; i < line_max; i += line_step) {
        if (mem < line_max) {
            if (i < mem) {
                printf(".");
            } else {
                printf(" ");
            }
        } else {
            if (i + line_max < mem) {
                printf(":");
            } else {
                printf(".");
            }
        }
    }
    printf("|/n");
#endif
}
 
int main(int argc, char ** argv) {
    int i, n;
    srand(time(NULL));
 
    // Test 0
    for (i = 0; i < REPEAT * 10; ++i) {
        insert(sizeof(UnitTestNode));
        if (i % REPEAT == 0) {
            print(0);
        }
    }
 
    for (i = 0; i < REPEAT * 10; ++i) {
        delete();
        if (i % REPEAT == 0) {
            print(0);
        }
    }
 
    // Test 1
    for (n = MAXSIZE; n > 0; n >>= 1) {
        for (i = 0; i < REPEAT; ++i) {
            if (rand() % 2) {
                delete();
            }
            insert(n);
        }
        print(1);
    }
 
    for (n = 1; n <= MAXSIZE; n <<= 1) {
        for (i = 0; i < REPEAT; ++i) {
            if (rand() % 2) {
                delete();
            }
            insert(n);
        }
        print(1);
    }
 
    // Test 2
    for (n = 1; n <= MAXSIZE; n <<= 1) {
        for (i = 0; i < REPEAT; ++i) {
            if (rand() % 2) {
                delete();
            }
            insert((rand() % n) + 1);
        }
        print(2);
    }
 
    while (head != NULL) {
        delete();
    }
    print(2);
 
    for (n = 1; n <= MAXSIZE; n <<= 1) {
        for (i = 0; i < REPEAT; ++i) {
            if (rand() % 2) {
                delete();
            }
            insert((rand() % n) + 1);
        }
        print(2);
    }
 
    // Test 3
    for (i = 0; i <= REPEAT * 10; ++i) {
        if (rand() % 2) {
            delete();
        }
        insert((rand() % REPEAT) + 1);
        if (i % REPEAT == 0) {
            print(3);
        }
    }
 
    while (head != NULL) {
        delete();
    }
    print(3);
 
    for (i = 0; i <= REPEAT * 10; ++i) {
        if (rand() % 2) {
            delete();
        }
        insert((rand() % REPEAT) + 1);
        if (i % REPEAT == 0) {
            print(3);
        }
    }
 
    // Test 4
    while (head != NULL) {
        delete();
    }
    print(4);
 
    for (i = 0; i < MEMPOOL; ++i) {
        if (blank(1) == 0) {
            break;
        }
        if (i % (MEMPOOL / 12) == 0) {
            print(4);
        }
    }
 
    while(--i) {
        delete();
    }
    print(4);
 
    for (i = 0; i < REPEAT * 10; ++i) {
        insert(MEMPOOL / 2);
        if (i % REPEAT == 0) {
            print(4);
        }
    }
 
    // Test 5
    for (i = 0; i <= REPEAT * 10; ++i) {
        if (rand() % 4) {
            delete();
        }
        insert(sizeof(UnitTestNode));
        if (i % 60 == 0) {
            print(5);
        }
    }
 
    while (head != NULL) {
        delete();
    }
    print(5);
 
    for (i = 0; i <= MEMPOOL; ++i) {
        insert(sizeof(char));
        if (i % 600 == 0) {
            print(5);
        }
    }
 
    printf("%d times succeed malloc", count_succeed);
    if (count_succeed != 0) {
        printf(", which average costs %.3f ms./n", time_succeed / count_succeed);
    } else {
        printf("./n");
    }
 
    printf("%d times failed malloc", count_failed);
    if (count_failed != 0) {
        printf(", which average costs %.3f ms./n", time_failed / count_failed);
    } else {
        printf("./n");
    }
 
    printf("%d times free", count_free);
    if (count_free != 0) {
        printf(", which average costs %.3f ms./n", time_free / count_free);
    } else {
        printf("./n");
    }
 
    printf("%d memories used, %d memories used at the peak./n", mem, max_mem);
 
    return 0;
}



/

//mini_malloc内存分配与释放


#include "mini_malloc.h"

extern char *P = '/0';
extern Node *L = NULL;

Node *uNode = NULL;
Node *fNode = NULL;

void DLpushfront(Node *pNode, char obj);
void DLdelete(Node **head, char obj);

void init_malloc()
{
    P = (char *)malloc(MAXMEM);
    L = (Node *)P;
    L->_used = '/0';
    L->_prev = NULL;
    L->_next = NULL;
    L->_usedprev = NULL;
    L->_usednext = NULL;
    L->_freeprev = NULL;
    L->_freenext = NULL;
    fNode = L;
}

void *mini_malloc(size_t size)
{
    if (L == NULL)
        init_malloc();
    size_t fsize = 0;
    Node *head = fNode;
    while (head) {
        if (head->_used == '/0') {
            if (head->_next != NULL) {
                fsize = (char *)(head->_next) - (char *)head - NODESIZE;
            }
            else {
                fsize = P + MAXMEM - (char *)head - NODESIZE;
            }
            if (fsize >= size) {
                head->_used = '1';
                DLpushfront(head, 'u');
                DLdelete(&head, 'f');
                if (fsize - size > NODESIZE) {
                    Node *node = (Node *)((char *)head + NODESIZE + size);
                    node->_used = '/0';
                    node->_prev = head;
                    node->_next = NULL;
                    node->_freenext = NULL;
                    if (head->_next != NULL) {
                        node->_next = head->_next;
                        head->_next->_prev = node;
                    }
                    DLpushfront(node, 'f');
                    head->_next = node;
                }
                return (void *)((char *)head + NODESIZE);
            }
        }
        head = head->_freenext;
    }
}

void mini_free(void *addr)
{
    if (uNode == NULL)
        return;
    Node *Used = uNode;
    Node *node = NULL;
    while (Used) {
        if ((Node *)((char *)addr - NODESIZE) == Used) {
            Used->_used = '/0';
            node = Used;
            DLdelete(&Used, 'u');
            if (Used->_next != NULL && Used->_next->_used == '/0') {
                DLdelete(&(Used->_next), 'f');
                DLdelete(&(Used->_next), 'm');
            }
            if (Used->_prev != NULL && Used->_prev->_used == '/0') {
                node = Used->_prev;
                DLdelete(&node, 'f');
                DLdelete(&Used, 'm');
            }
            DLpushfront(node, 'f');
            return;
        }
        Used = Used->_usednext;
    }
}

void DLpushfront(Node *pNode, char obj)
{
    if (pNode == NULL) return;
    switch (obj) {
    case 'm':
        if (L == NULL) {
            L = pNode;
            L->_prev = NULL;
            L->_next = NULL;
        }
        else {
            pNode->_next = L;
            L->_prev = pNode;
            L = pNode;
            L->_prev = NULL;
        }
        break;
    case 'u':
        if (uNode == NULL) {
            uNode = pNode;
            uNode->_usedprev = NULL;
            uNode->_usednext = NULL;
        }
        else {
            pNode->_usednext = uNode;
            uNode->_usedprev = pNode;
            uNode = pNode;
            uNode->_usedprev = NULL;
        }
        break;
    case 'f':
        if (fNode == NULL) {
            fNode = pNode;
            fNode->_freeprev = NULL;
            fNode->_freenext = NULL;
        }
        else {
            pNode->_freenext = fNode;
            fNode->_freeprev = pNode;
            fNode = pNode;
            fNode->_freeprev = NULL;
        }
        break;
    }
}

void DLdelete(Node **head, char obj)
{
    if (*head == NULL) return;
    Node *T = *head;
    switch (obj) {
    case 'm':
        if (T->_prev != NULL) {
            if (T->_next != NULL) {
                T->_prev->_next = T->_next;
                T->_next->_prev = T->_prev;
            }
            else
                T->_prev->_next = NULL;
        }
        else {
            printf("ERROR/n");
        }
        break;
    case 'u':
        if (T->_usedprev != NULL) {
            if (T->_usednext != NULL) {
                T->_usedprev->_usednext = T->_usednext;
                T->_usednext->_usedprev = T->_usedprev;
            }
            else
                T->_usedprev->_usednext = NULL;
        }
        else {
            if (T->_usednext != NULL) {
                uNode = T->_usednext;
                uNode->_usedprev = NULL;
            }
            else
                uNode = NULL;
        }
        break;
    case 'f':
        if (T->_freeprev != NULL) {
            if (T->_freenext != NULL) {
                T->_freeprev->_freenext = T->_freenext;
                T->_freenext->_freeprev = T->_freeprev;
            }
            else
                T->_freeprev->_freenext = NULL;
        }
        else {
            if (T->_freenext != NULL) {
                fNode = T->_freenext;
                fNode->_freeprev = NULL;
            }
            else
                fNode = NULL;
        }
        break;
    }
}

【C语言】 单链表的实现 用malloc实现的动态内存管理
azrael___的博客
03-30 1111
链表是我们初学者经常接触到的数据结构，和顺序表相比，它节省了空间，在插入的时候节省了时间。 单链表每个节点由数据和指向下一个节点的指针构成。头部由一个head节点，尾部指针指向NULL。 如图所示：     而用malloc实现，就是需要插入一个节点的时候在开辟空间存放此节点。 代码实现如下： 头文件.h: #pragma once #define __SEQ_LIST_
c++使用malloc来做内存分配创建链表
feinifi的博客
12-02 2635
c++中创建链表可以直接通过new对象的方式创建节点，然后将节点之间的关系通过next指针来关联起来，另外，也可以通过malloc来分配内存，创建节点。这里介绍如何通过malloc来创建链表。 malloc分配内存的方式为malloc(sizeof(typename))，最后 还需要通过类型转换，将它转为(typename *)，如下所示： node *p=NULL; p =...
malloc()函数（链表必备）
m0_61544935的博客
02-13 2008
malloc()函数的层层剖析，轻轻松松搞懂。
动态链表----malloc
最新发布
l2ohvef的博客
12-21 678
1.malloc（）找到可用内存中一个大小适合的块。2.它创建的内存是匿名的，也就是说，malloc（）分配了内存，但没有为它指定名字。3.它可以返回那块内存第一个字节的地址。因此，可以把那个地址赋值给一个指针变量，并使用该指针来访问那块内存（第一个字节），后面的字节的地址访问不了。4.我们使用malloc（）来创建一个 数组。可以在程序运行时使用malloc（）请求一个存储块，另外还需要一个指针来存放该块在内存中的位置。
今日课堂上用链表写的malloc
eric's blog
07-23 842
//在远程linux服务器上无法用中文写注释，就没写了，英文嘛，它认识我，我不认识它。这只是一超简单的模拟版 //mini_malloc.h头文件 #include #include #define MAXMEM 10000 typedef unsigned int size_t; typedef struct PLACEHOLDER { char
malloc一个动态链表
vigier的专栏
03-27 1598
描述：按图实现一个人员管理功能（录入，增加，删除） 思考：是否可以将 动态链表的实现，封装成一套宏接口？（实现后更新） 代码实现： 1. 变量声明 和 main函数： #include <stdio.h> #include <stdlib.h> #include <string.h> int listCount = 0; /* 个数统计 */ typedef struct _Student { char name[20]; int numbe
双链表实现malloc
09-04
双链表法实现malloc 功能，运行十万次以上
timeout-list-malloc.rar_glib链表_malloc_双向链表 Linux实验_容器 定时
09-19
本实验主要关注了两个关键点：`glib`链表和`malloc`函数，以及如何结合它们实现一个带有定时功能的容器。以下是关于这两个主题的详细解释。 首先，`malloc`是C语言中的动态内存分配函数，它允许程序在运行时请求...
双向链表法实现malloc和free
02-20
自己实现的malloc 和 free 用的双向链表 尽量做了注释
双向循环链表实现malloc
09-04
双向循环链表法实现malloc 功能，运行十万次以上
1.3.1线性链表之动态（malloc）链表
golden_dreams的博客
12-12 450
/*************线性表单链表存储结构 typedef struct     LNode {      ElemType          data;       //数据域      struct               *next;       //指针域 }LNode, *LinkList; //查看链表中第i个元素，用e返回其值 Status GetEle
C语言创建链表malloc的使用（C的创建对象）
fxtxz2的专栏
09-10 4453
struct student *creat() { struct student *head; struct student *p1, *p2; p1 = p2 = (struct student *)malloc(LEN); //LEN是student结构的大小 这就是new对象 printf("Please enter the num :"); scanf("%d", &p1->
链表、线性表、malloc
m0_62786109的博客
09-19 358
数据结构
c链表里的malloc
Hoskein的博客
03-31 713
分配空间malloc 代码 typedef struct node{ int a; struct node* next; }linklistnode,linklist*; ........... linklist s; ...
动态链表 malloc
sky的博客
02-27 199
malloc 简单的动态链表
【数据结构】单链表(打印链表 创建malloc节点的指针 头插 尾插 头删 尾删 链表的销毁 链表的查找 某个位置去插入 ---- 在pos之前插入 )
m0_68800221的博客
10-22 990
顺序表在头部和中部插入删除数据都是不太合适的，因为要挪动数据时间复杂度为O(N)。扩容过程有消耗，如果需要大一点的空间可能不是原地扩容，拷贝数据，释放旧空间会有不少的消耗。扩容一般是2倍增长，会有一定的空间浪费。现在我们有一种这样的想法：我需要存一个数据，那么就开一块单独的空间去存这个数据，小块小块的开。现在把这些空间开出来，数据存起来后，他们之间如何建立关系呢？可以用指针，前一个节点存储后一个的指针，这个时候它们就链接在一起了。上面说的这种结构就是我们的链表。按需的申请和释放。
多种链表结构
玫瑰安全
06-03 379
...
多链表C++
qq_40786884的博客
05-09 620
#include<iostream> #include<string> #include <fstream> #include<windows.h> using namespace std; struct Node {//定义节点 int data; Node*prior, *next; }; class LinkList { public: LinkList();//无参构造函数 LinkList(int a[], in.
C语言链表与malloc函数
weixin_30415801的博客
09-02 530
// 分配内存空间.cpp : 定义控制台应用程序的入口点。//#include "stdio.h"#include "malloc.h"struct Student{ int id; char *name; int score; struct Student *next;};void errorFun(){ struct Student stu={1,"wq",99...
C语言实现有序链表合并及malloc源码解析
在对malloc源码的学习过程中，我们能够看到内存分配的具体实现方式，比如如何请求操作系统分配内存，如何维护一个空闲内存链表以便快速重用已经释放的内存，以及如何在内存不足时向操作系统申请更多内存等。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值