操作系统的完整代码——内存管理代码ycmm.cpp

最新推荐文章于 2024-09-19 13:09:57 发布
最新推荐文章于 2024-09-19 13:09:57 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： YC编译器 文章标签： c++ c语言 后端 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiaobingyang/article/details/105007738
版权
本文深入解析ycmm内存管理模块的源代码，探讨其malloc(), realloc()和free()函数的实现细节。ycmm模块通过复杂的链表操作，高效地管理物理内存，支持不同场景下的内存分配与回收。

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

#define YCORG -1          //该设置使编译器生成头部为YCEXE结构的可执行文件
#include "ycio.cpp"
#define PgTail(pLink) (((unsigned)pLink + pLink->size + PAGE_SIZE-1) & PAGE_MASK)

ycmmCLASS YCMM;
YMEM *phyHead,*maxHead;

void main(void **pObj)
{
    phyHead = *(YMEM**)(KERNEL_POS + DATA_POS + 8);   //可用内存链表头
    maxHead = *(YMEM**)(KERNEL_POS + DATA_POS + 12);  //可用内存链表最大地址
    *pObj = &YCMM;
}

YMEM *ycmmCLASS::malloc(YMEM *pHead,unsigned int _Size,int isHigh)
{
    YMEM *pLink;
    unsigned int memPos;
    int alloc_size = sizeof(YMEM) + (_Size + 15) & ~15;  //实际要分配的内存大小
    int alignSize = (alloc_size + PAGE_SIZE - 1) & PAGE_MASK;//要分配的内存页长度

    if(isHigh)                 //驱动程序申请高端内存, 其线性地址 > KERNEL_POS
      {
        pLink = phyHead;       //可用内存链表头
        while(pLink)           //查看是否还有不小于alignSize的可用内存
          {
            pLink = pLink->pLast;                      //从物理内存尾部开始搜索
            if(pLink->size >= alignSize)  break;       //搜到pLink项满足所需内存
            if(pLink == phyHead)  return nullptr; //没有可分配的内存,返回空指针
          }
        memPos = pLink->addr + pLink->size - alignSize + KERNEL_POS;//分配的内存
      }
    else                    //用户程序进程申请低端内存, 其线性地址 < KERNEL_POS
      {
        if(alloc_size < PAGE_SIZE)     //处理小内存, 即所需内存小于一个物理页框
          {
            pLink = pHead;             //进程内存链表头
            while(pLink)
              {
                memPos = (unsigned int)pLink + pLink->size;
                int taiPos = PgTail(pLink);                 //所占内存页尾部位置
                if(taiPos - memPos >= alloc_size) //尾页所剩内存不小于所需内存时
                  {
                    YMEM *qLink = pLink->pNext;
                    while(qLink)                 //检查尾页所剩内存是否被分配掉
                      {
                        if(taiPos==PgTail(qLink) && qLink > pLink)  break;
                        qLink = qLink->pNext;
                        if(qLink == pLink)  goto  ma_p_end; //尾页所剩内存可用
                      }
                  }
                pLink = pLink->pNext;        //检查下一项
                if(pLink == pHead)  break;   //pLink回到头部, 退出循环
              }
          }

        pLink = phyHead;       //可用内存链表头
        while(pLink)           //查看是否有不小于alloc_size的可用内存
          {
            if(pLink->size >= alloc_size)  break;
            pLink = pLink->pNext;
            if(pLink == phyHead)  return nullptr; //没有可分配的内存,返回空指针
          }

        memPos = pLink->addr;   //分配到的内存地址
        pLink->addr = memPos + alignSize;
      }

    pLink->size -= alignSize;  //调整可用内存链表项的内存大小
    if(!pLink->size)  delete_a_phy_link(pLink); //若链表项内存大小为0, 则删除

    ma_p_end:
    pLink = (YMEM*)memPos;
    pLink->size = alloc_size;
    pLink->flag = 0;
    return pLink;
}

void ycmmCLASS::free(YMEM *pLink)
{
    pLink->flag = 1;
    unsigned int memPos = (unsigned int)pLink;
    if(memPos >= KERNEL_POS)  memPos -= KERNEL_POS;
    int pg_num = (pLink->size + PAGE_SIZE - 1) / PAGE_SIZE;

    unsigned int endPos = PgTail(pLink);
    YMEM *qLink = pLink->pNext;
    if(memPos % PAGE_SIZE)
      {
        while(qLink)  //处理小内存
          {
            if(endPos == PgTail(qLink) && !qLink->flag)  return;  //有在用内存
            qLink = qLink->pNext;
            if(qLink == pLink)   break;
          }
        memPos &= PAGE_MASK;    //被释放内存地址进行页对齐
      }
    else
      {
        while(qLink)
          {
            if(endPos == PgTail(qLink) && !qLink->flag)
              {
                pg_num--;     //尾页所剩内存在用, 不释放尾页
                break;
              }
            qLink = qLink->pNext;
            if(qLink == pLink)  break;
          }
      }
    add_to_phy_link(memPos, pg_num * PAGE_SIZE);  //被释放内存加到可用内存链表
}

YMEM *ycmmCLASS::realloc(YMEM *oldLink,unsigned int _NewSize)
{
    YMEM *pLink;
    unsigned int memPos = (unsigned int)oldLink;

    if((memPos % PAGE_SIZE) == 0)  //检查是否能在旧分配内存的尾部调整
      {
        int alloc_size = sizeof(YMEM) + (_NewSize + 15) & ~15;
        unsigned int endPos = PgTail(oldLink);         //旧内存尾部页框对齐位置
        unsigned int newPos = ((unsigned)oldLink + alloc_size + PAGE_SIZE - 1)
                                          & PAGE_MASK; //新内存尾部页框对齐位置

        if(newPos <= endPos)  //新内存小于旧内存直接去掉后部
          {
            oldLink->size = alloc_size;
            if(newPos < endPos)   add_to_phy_link(newPos, endPos - newPos);
            return oldLink;
          }

        pLink = phyHead;
        while(pLink)
          {
            if(pLink->addr == endPos)       //新内存大于旧内存时,
              {                             //检查其后是否有足够大的可用内存
                if(pLink->size >= newPos - endPos)
                  {
                    pLink->size -= newPos - endPos;
                    pLink->addr += newPos - endPos;
                    if(!pLink->size)  delete_a_phy_link(pLink); //删除链表项
                    oldLink->size = alloc_size; //有足够大可用内存,直接加到后部
                    return oldLink;
                  }
                break;
              }
            pLink = pLink->pNext;
            if(pLink == phyHead)   break;
          }
      }

    //重新分配所需大小的内存, 并把旧内存内容拷贝到新内存
    pLink = YCMM.malloc(oldLink,_NewSize);
    if(pLink)   memcpy(to_memPtr(pLink), to_memPtr(oldLink), oldLink->size);
    return pLink;
}

YMEM *merge_phy_link(unsigned int memPos,unsigned int msize)
{
    unsigned int endPos = memPos + msize;
    YMEM *pLink = phyHead;
    while(pLink)
      {
        if(pLink->addr == endPos)  //链表项pLink与内存memPos右边相邻，合并
          {
            pLink->addr = memPos;
            pLink->size += msize;
            return pLink;
          }
        if(pLink->addr + pLink->size == memPos)  //链表项与memPos左边相邻,合并
          {
            pLink->size += msize;
            return pLink;
          }
        pLink = pLink->pNext;
        if(pLink == phyHead)  break;
      }
    return nullptr;
}

void add_to_phy_link(unsigned int memPos,unsigned int msize)
{
    YMEM *pLink = merge_phy_link(memPos,msize);
    if(!pLink)  //没有可与内存memPos合并的链表项, 则增加一项
      {
        for(pLink=(YMEM*)freeMemLINK_POS; pLink<maxHead; pLink++)
                                                       if(!pLink->pNext) break;
        if(pLink >= maxHead)
          {
            pLink = maxHead++;
            if(maxHead >= (YMEM*)freeMemLink_NUM) {  }
          }
        pLink->addr = memPos;
        pLink->size = msize;
        yc_add_link(pLink,phyHead);
        return;
      }

    while(1)
      {
        YMEM *qLink = pLink;
        pLink = merge_phy_link(pLink->addr,pLink->size);
        if(!pLink)  break;
        delete_a_phy_link(qLink);   //删除被合并的链表项
      }
}

void delete_a_phy_link(YMEM *pLink)
{
    yc_delete_link(pLink,phyHead);
    pLink->pNext = nullptr;
}

YMEM *ycmmCLASS::get_head()
{
    return phyHead;
}

                      C/C++代码文件: ycmm.cpp

    ycmm.cpp只是简单实现malloc(),realloc()和free()函数。

【光学】拉盖尔-高斯涡旋光束【含Matlab源码 6775期】
订阅付费专栏Matlab（奶茶价版），可赠送奶茶价版付费专栏指定代码1份；
08-03 561
拉盖尔-高斯涡旋光束 完整的代码，方可运行；可提供运行操作视频！适合小白！
【光学】基于matlab拉盖尔-高斯涡旋光束【含Matlab源码 6775期】
订阅付费专栏Matlab（奶茶价版），可赠送奶茶价版付费专栏指定代码1份；
08-03 56
拉盖尔-高斯涡旋光束 完整的代码，方可运行；可提供运行操作视频！适合小白！
操作系统-内存管理代码.doc
06-22
程序代码： #include<iostream> #include<fstream> #define MAXMSIZE 99 using namespace std; struct Node{ int startAddress; char name; int size; int endAddress; struct Node *prior; struct Node *next; }; struct Blocklist { Node* head; }; Blocklist* freelist=new Blocklist; Blocklist* busylist=new Blocklist; void initial(); void allocateBlock(); void print(); void reclaimBlock(); void main() { int slct; initial(); print(); cout<<"select allocetion (1) or reclaim (2):"<<endl; slct=1; while(slct) { cin>>slct;
操作系统内存管理代码
网络战争的博客
12-20 624
这段代码实现了一个简单的内存分配程序。它定义了一个MemoryBlock结构，用于表示内存块的起始地址、大小和是否已分配。initializeMemory函数用于初始化内存块数组。allocateMemory函数用于分配一块给定大小的内存，返回分配的内存块在数组中的索引。freeMemory函数用于释放一个已分配的内存块。printMemory函数用于打印当前内存块的状态。在main函数中，我们先初始化内存块数组，然后分配两块内存，最后释放一块内存，并打印当前内存块的状态。
操作系统-基本分页存储管理(内有代码)
05-08
本实验通过程序模拟操作系统的基本分页存储管理方式，进一步理解这一内存分配方式的原理和特点，加深对理论知识的掌握。
操作系统内存管理实验报告及源代码
12-30
随机给出一个页面执行序列，如：1,5,3,4,2,1,3,4,5,7,9,……。要求计算以下几种置换算法的缺页数、缺页率和命中率。  最佳置换算法OPT（Optimal）  先进先出算法FIFO（First In First Out）  最近最少使用算法LRU（Least Recently Used） 实验报告（含流程图及运行结果）&源代码
操作系统内存管理
菜鸟的自留地-mooyang
04-24 1万+
物理内存 Linux为了有效使用机器中的物理内存，在系统初始化阶段内存被划分成几个功能区域： 其中，Linux内核程序占据在物理内存的开始部分，接下来是供硬盘等块设备使用的高速缓冲区部分（其中要扣除显卡内存和ROM BIOS所占用的内存地址范围） 当一个进程需要读取块设备中的数据时，系统会首先把数据读到高速缓冲区中。当有数据需要写到块设备上去时，系统也是先将数据放
public void refreshUD() { List resList = null; String ycyh = null; String ycmm = null; ActiveXComponent component = null; Dispatch ds = null; Loggers.PERFORMANCE.info("开始UD自动刷新处理"); String sql = "select ycyh,ycmm from tbl_qymc where deleteflag='0'"; try { resList = this.dao.queryForList(sql); if (resList != null && resList.size() > 0) { ycyh = MapUtil.getMapValue((Map)resList.get(0), "ycyh", ""); ycmm = MapUtil.getMapValue((Map)resList.get(0), "ycmm", ""); ComThread.InitSTA(); component = new ActiveXComponent("CLSID:57FF2549-912B-4847-8B06-098C118C1F83"); ds = component.getObject(); Variant var = Dispatch.call(ds,"UG_Update",ycyh,ycmm,"0ad55136-e94c-49a7-a41e-6f99c3fbddd6"); if (var != null && var.getBoolean()) { Loggers.PERFORMANCE.info("完成UD自动刷新：刷新成功！"); } else { Loggers.PERFORMANCE.info("完成UD自动刷新：刷新失败！"); } ComThread.Release(); } } catch (DAOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
06-07
方法中的代码逻辑如下： 1. 查询数据库中有关用户和密码的信息。 2. 如果查询结果不为空，则初始化一个COM线程并创建一个ActiveXComponent对象。 3. 通过调用Dispatch对象的UG_Update方法进行UD刷新处理。 4. 根据...
BeautifulSoup抓取门户网站上的链接
热门推荐
weixin_30843605的博客
12-16 7万+
使用BeautifulSoup抓取门户网站上的所有跳转链接 from bs4 import BeautifulSoup import urllib2 request = urllib2.Request('http://www.163.com') response = urllib2.urlopen(request) html_doc = response.read() so...
最新退休日期SQL语句（延迟退休）
最新发布
悠闲饭团的博客
09-19 934
员工表按性别，生日生成退休日期，及对应的延退月份
内存管理源代码-内存管理源代码
09-07
建议自己写操作系统的朋友下载； 建议使用一个没有内存管理的操作系统的朋友下载； 建议对内存管理实现感兴趣的朋友下载
操作系统内存管理算法
05-06
实现关于内存管理的内存布局初始化及内存申请分配、内存回收等基本功能操作函数，尝试对用256MB的内存空间进行动态分区方式模拟管理。 内存分配的基本单位为1KB，同时要求支持至少两种分配策略，并进行测试和对不同分配策略的性能展开比较评估。
操作系统 内存管理
06-02
操作系统 内存管理 设计和实现关于内存管理的内存布局初始化及内存申请分配、内存回收等基本功能操作函数，尝试对用256MB的内存空间进行动态分区方式模拟管理。内存分配的基本单位为1KB，同时要求支持至少两种分配策略，并进行测试和对不同分配策略的性能展开比较评估。
存储管理 代码
05-15
操作系统课程设计的存储管理，源代码，可执行
操作系统之内存管理
1周是1年的2%
05-06 1030
memory manage
操作系统实验-内存管理（python实现）
weixin_48297950的博客
01-12 1534
操作系统实验-内存管理（python实现） 实验目标 模拟操作系统对内存的基于分页机制的管理。 基本功能是：内存的分配和回收，地址转换。 支持按需调页FIFO算法 数据结构 全局的位示图，用于内存的分配和回收。 每个进程维护一个页表，用于支持地址转换。 代码实现 import random,math #进程pcb class PCB: class table: class zt: def __init__(self):
操作系统——内存管理
lijunjie127的博客
08-16 609
内存管理 1.一段程序放入内存，cpu取指执行、取指执行，cup和内存都工作起来了 2.程序在内存中分段处理，因为每个段有不同的特点（代码段只读，数据段可写，堆栈段单向增长），分治 3.在内存中找一段空闲内存，将一段（代码段、数据段）程序放入内存 4.取指执行，跳转到某个地址，需要运行时重定位，记录基指，ldtr寄存器就是放到段表ldt表。根据基址和偏移地址算出真正的物理地址。 5.每个...
代码规范：内存管理
ALex_zry的博客
11-05 525
在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。注：建议提供类的公有函数，作用是封装指针的释放操作，包含free，和赋值NULL两部分，（这里的安全性检查步骤先略过不聊。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值