精华内容
下载资源
问答
  • 内存管理算法

    2015-11-10 09:20:36
    本资源为博客《实验2后篇——内存管理算法》的附件,其中主要包括莱昂氏的unix文档与源码,linux内存分析文件,博客中设计到的图,slab算法,buddy算法,malloc/free的实现源码。希望对内存管理感兴趣的人员有所帮助...
  • 在嵌入式系统中,内存碎片是一个很棘手的问题。slab内存管理算法具有分配和释放内存速度迅速、内外部碎片非常小等优点。本文通过分析glib中slab内存管理算法,阐明了其管理内存的实现机制。
  • C++高效内存管理算法

    2013-11-26 10:03:18
    C++高效内存管理算法
  • 模拟FF,WF,BF内存管理算法,有紧缩处理,排序处理,碎片处理。Windows下,Linux下均可运行。
  • C++ 内存管理算法和实现.chm.rar C++ 内存管理算法和实现.chm.rar C++ 内存管理算法和实现.chm.rar C++ 内存管理算法和实现.chm.rar
  • 本文主要介绍内存的基本概念以及操作系统的内存管理算法。一、内存的基本概念内存是计算机系统中除了处理器以外最重要的资源,用于存储当前正在执行的程序和数据。内存是相对于 CPU 来说的,CPU 可以直接寻址的存储...

    本文主要介绍内存的基本概念以及操作系统的内存管理算法。

    一、内存的基本概念

    内存是计算机系统中除了处理器以外最重要的资源,用于存储当前正在执行的程序和数据。内存是相对于 CPU 来说的,CPU 可以直接寻址的存储空间叫做内存,CPU 需要通过驱动才能访问的叫做外存。

    二、ROM&RAM&Flash

    内存一般采用半导体存储单元,分为只读存储器(ROM,Read Only Memory)、随机存储器(RAM,Random Access Memory)ROM 一般只能读取不能写入,掉电后其中的数据也不会丢失。RAM 既可以从中读取也可以写入,但是掉电后其中的数据会丢失。内存一般指的就是 RAM。

    ROM 在嵌入式系统中一般用于存储 BootLoader 以及操作系统或者程序代码或者直接当硬盘使用。近年来闪存(Flash)已经全面代替了 ROM 在嵌入式系统中的地位,它结合了 ROM 和 RAM 的长处,不仅具备电子可擦除可编程的特性,而且断电也不会丢失数据,同时可以快速读取数据。

    三、两类内存管理方式 内存管理模块管理系统的内存资源,它是操作系统的核心模块之一。主要包括内存的初始化、分配以及释放。

    从分配内存是否连续,可以分为两大类。

    连续内存管理

    为进程分配的内存空间是连续的,但这种分配方式容易形成内存碎片(碎片是难以利用的空闲内存,通常是小内存),降低内存利用率。连续内存管理主要分为单一连续内存管理和分区式内存管理两种。

    非连续内存管理

    将进程分散到多个不连续的内存空间中,可以减少内存碎片,内存使用率更高。如果分配的基本单位是页,则称为分页内存管理;如果基本单位是段,则称为分段内存管理。

    当前的操作系统,普遍采用非连续内存管理方式。不过因为分配粒度较大,对于内存较小的嵌入式系统,一般采用连续内存管理。本文主要对嵌入式系统中常用的连续内存管理的分区式内存管理进行介绍。

    四、分区式内存管理 分区式内存管理分为固定分区和动态分区。

    固定分区

    事先就把内存划分为若干个固定大小的区域。分区大小既可以相等也可以不等。固定分区易于实现,但是会造成分区内碎片浪费,而且分区总数固定,限制了可以并发执行的进程数量。

    动态分区

    根据进程的实际需要,动态地给进程分配所需内存。

    五、动态分区内存管理 运作机制

    动态分区管理一般采用空闲链表法,即基于一个双向链表来保存空闲分区。对于初始状态,整个内存块都会被作为一个大的空闲分区加入到空闲链表中。当进程申请内存时,将会从这个空闲链表中找到一个大小满足要求的空闲分区。如果分区大于所需内存,则从该分区中拆分出需求大小的内存交给进程,并将此拆分出的内存从空闲链表中移除,剩下的内存仍然是一个挂在空闲链表中的空闲分区。

    数据结构

    空闲链表法有多种数据结构实现,这里介绍一种较为简单的数据结构。每个空闲分区的数据结构中包含分区的大小,以及指向前一个分区和后一个分区的指针,这样就能将各个空闲分区链接成一个双向链表。

    内存分配算法

    First Fit(首次适应算法)

    First Fit 要求空闲分区链表以地址从小到大的顺序链接。分配内存时,从链表的第一个空闲分区开始查找,将最先能够满足要求的空闲分区分配给进程。

    Next Fit(循环首次适应算法)

    Next Fit 由 First Fit 算法演变而来。分配内存时,从上一次刚分配过的空闲分区的下一个开始查找,直至找到能满足要求的空闲分区。查找时会采用循环查找的方式,即如果直到链表最后一个空闲分区都不能满足要求,则返回到第一个空闲分区开始查找。

    Best Fit(最佳适应算法)

    从所有空闲分区中找出能满足要求的、且大小最小的空闲分区。为了加快查找速度,Best Fit 算法会把所有空闲分区按其容量从小到大的顺序链接起来,这样第一次找到的满足大小要求的内存必然是最小的空闲分区。

    Worst Fit(最坏适应算法)

    从所有空闲分区中找出能满足要求的、且大小最大的空闲分区。Worst Fit 算法按其容量从大到小的顺序链接所有空闲分区。

    Two LevelSegregated Fit(TLSF)

    使用两层链表来管理空闲内存,将空闲分区大小进行分类,每一类用一个空闲链表表示,其中的空闲内存大小都在某个特定值或者某个范围内。这样存在多个空闲链表,所以又用一个索引链表来管理这些空闲链表,该表的每一项都对应一种空闲链表,并记录该类空闲链表的表头指针。

    5a891ef9539b2b40105f74ad86ab6185.png

    图中,第一层链表将空闲内存块的大小根据 2 的幂进行分类。第二层链表是具体的每一类空闲内存块按照一定的范围进行线性分段。比如 25 这一类,以 23 即 8 分为 4 个内存区间【25,25+8),【25+8,25+16),【25+16,25+24),【25+24,25+32);216 这一类,以 214 分为 4 个小区间【216,216+214),【216+214,216+2*214),【216+2*214,216+3*214),【216+3*214,216+4*214)。同时为了快速检索到空闲块,每一层链表都有一个 bitmap 用于标记对应的链表中是否有空闲块,比如第一层 bitmap 后 3 位 010,表示 25 这一类内存区间有空闲块。对应的第二层 bitmap 为 0100 表示【25+16,25+24)这个区间有空闲块,即下面的 52Byte。

    Buddysystems(伙伴算法)

    Segregated Fit 算法的变种,具有更好的内存拆分和回收合并效率。伙伴算法有很多种类,比如 BinaryBuddies,Fibonacci Buddies 等。Binary Buddies 是最简单也是最流行的一种,将所有空闲分区根据分区的大小进行分类,每一类都是具有相同大小的空闲分区的集合,使用一个空闲双向链表表示。BinaryBuddies 中所有的内存分区都是 2 的幂次方。 因为无论是已分配的或是空闲的分区,其大小均为 2 的幂次方,即使进程申请的内存小于分配给它的内存块,多余的内存也不会再拆分出来给其他进程使用,这样就容易造成内部碎片。 当进程申请一块大小为 n 的内存时的分配步骤为:

    1、计算一个 i 值,使得 2i-1

    2、在空闲分区大小为 2i 的空闲链表中查找

    3、如果找到空闲块,则分配给进程

    4、如果 2i 的空闲分区已经耗尽,则在分区大小为 2i+1 的空闲链表中查找

    5、如果存在 2i+1 的空闲分区,则将此空闲块分为相等的两个分区,这两分区就是一对伙伴,其中一块分配给进程,另一块挂到分区大小为 2i 的空闲链表中

    6、如果 2i+1 的空闲分区还是不存在,则继续查找大小为 2i+2 的空闲分区。如果找到,需要进行两次拆分。第一次拆分为两块大小为 2i+1 的分区,一块分区挂到大小为 2i+1 的空闲链表中,另一块分区继续拆分为两块大小为 2i 的空闲分区,一块分配给进程,另一块挂到大小为 2i 的空闲链表中

    7、如果 2i+2 的空闲分区也找不到,则继续查找 2i+3,以此类推

    在内存回收时,如果待回收的内存块与空闲链表中的一块内存互为伙伴,则将它们合并为一块更大的内存块,如果合并后的内存块在空闲链表中还有伙伴,则继续合并到不能合并为止,并将合并后的内存块挂到对应的空闲链表中。

    ced8baa74c0115ce618121ac5a5cb8b3.png

    下面的表格对上面 6 种算法的优缺点进行了比较:

    777576473b5293b218ef3a278e96c2ef.png
    展开全文
  • 提出一种对动态等尺寸内存管理算法的改进方法。改进的算法取消了用链表连接空闲内存块的做法,采用内存分配表的办法,从而实现了将控制信息从用户的内存块中分离,使内存管理更加安全可靠。
  • 基于线段树的高效内存管理算法及其空间优化
  • 内存管理算法 By 冲出宇宙 2008-10-8 PAGE Memory Management Algorithms 内存管理算法 By 冲出宇宙 2008-10-8 1前言 内存资源有限内存管理很必要 2问题 内存分配回收要快速因为内存分配回收十分频繁 内存碎片比例要...
  • C++ 内存管理算法和实现 C++ 内存管理算法和实现
  • 关注、星标公众号,不错过精彩内容转自:LiteOS物联网操作系统本文主要介绍内存的基本概念以及操作系统的内存管理算法。一、内存的基本概念内存是计算机系统中除了处理器以外最重要的资源,用于...

    关注、星标公众,不错过精彩内容

    转自:LiteOS物联网操作系统

    本文主要介绍内存的基本概念以及操作系统的内存管理算法。

    一、内存的基本概念

    内存是计算机系统中除了处理器以外最重要的资源,用于存储当前正在执行的程序和数据。内存是相对于CPU来说的,CPU可以直接寻址的存储空间叫做内存,CPU需要通过驱动才能访问的叫做外存

    二、ROM&RAM&Flash

    内存一般采用半导体存储单元,分为只读存储器(ROM,Read Only Memory)、随机存储器(RAM,Random Access Memory)ROM一般只能读取不能写入,掉电后其中的数据也不会丢失。RAM既可以从中读取也可以写入,但是掉电后其中的数据会丢失。内存一般指的就是RAM

    ROM在嵌入式系统中一般用于存储BootLoader以及操作系统或者程序代码或者直接当硬盘使用。近年来闪存(Flash)已经全面代替了ROM在嵌入式系统中的地位,它结合了ROMRAM的长处,不仅具备电子可擦除可编程的特性,而且断电也不会丢失数据,同时可以快速读取数据。

    三、两类内存管理方式

    内存管理模块管理系统的内存资源,它是操作系统的核心模块之一。主要包括内存的初始化、分配以及释放。

    从分配内存是否连续,可以分为两大类。

    • 连续内存管理

    为进程分配的内存空间是连续的,但这种分配方式容易形成内存碎片(碎片是难以利用的空闲内存,通常是小内存),降低内存利用率。连续内存管理主要分为单一连续内存管理和分区式内存管理两种

    • 非连续内存管理

    将进程分散到多个不连续的内存空间中,可以减少内存碎片,内存使用率更高。如果分配的基本单位是页,则称为分页内存管理;如果基本单位是段,则称为分段内存管理。

    当前的操作系统,普遍采用非连续内存管理方式。不过因为分配粒度较大,对于内存较小的嵌入式系统,一般采用连续内存管理。本文主要对嵌入式系统中常用的连续内存管理的分区式内存管理进行介绍。

    四、分区式内存管理

    分区式内存管理分为固定分区和动态分区

    • 固定分区

      事先就把内存划分为若干个固定大小的区域。分区大小既可以相等也可以不等。固定分区易于实现,但是会造成分区内碎片浪费,而且分区总数固定,限制了可以并发执行的进程数量。

    • 动态分区

    根据进程的实际需要,动态地给进程分配所需内存。

    五、动态分区内存管理

    运作机制

    动态分区管理一般采用空闲链表法即基于一个双向链表来保存空闲分区。对于初始状态,整个内存块都会被作为一个大的空闲分区加入到空闲链表中。当进程申请内存时,将会从这个空闲链表中找到一个大小满足要求的空闲分区。如果分区大于所需内存,则从该分区中拆分出需求大小的内存交给进程,并将此拆分出的内存从空闲链表中移除,剩下的内存仍然是一个挂在空闲链表中的空闲分区。

    数据结构

    空闲链表法有多种数据结构实现,这里介绍一种较为简单的数据结构。每个空闲分区的数据结构中包含分区的大小,以及指向前一个分区和后一个分区的指针,这样就能将各个空闲分区链接成一个双向链表。

    内存分配算法

    • First Fit(首次适应算法)

    First Fit要求空闲分区链表以地址从小到大的顺序链接。分配内存时,从链表的第一个空闲分区开始查找,将最先能够满足要求的空闲分区分配给进程。

    • Next Fit(循环首次适应算法)

    Next Fit由First Fit算法演变而来。分配内存时,从上一次刚分配过的空闲分区的下一个开始查找,直至找到能满足要求的空闲分区。查找时会采用循环查找的方式,即如果直到链表最后一个空闲分区都不能满足要求,则返回到第一个空闲分区开始查找。

    • Best Fit(最佳适应算法)

    从所有空闲分区中找出能满足要求的、且大小最小的空闲分区。为了加快查找速度,Best Fit算法会把所有空闲分区按其容量从小到大的顺序链接起来,这样第一次找到的满足大小要求的内存必然是最小的空闲分区。

    • Worst Fit(最坏适应算法)

    从所有空闲分区中找出能满足要求的、且大小最大的空闲分区。Worst Fit算法按其容量从大到小的顺序链接所有空闲分区。

    • Two LevelSegregated Fit(TLSF)

    使用两层链表来管理空闲内存,将空闲分区大小进行分类,每一类用一个空闲链表表示,其中的空闲内存大小都在某个特定值或者某个范围内。这样存在多个空闲链表,所以又用一个索引链表来管理这些空闲链表,该表的每一项都对应一种空闲链表,并记录该类空闲链表的表头指针。

    图中,第一层链表将空闲内存块的大小根据2的幂进行分类第二层链表是具体的每一类空闲内存块按照一定的范围进行线性分段。比如25这一类,以238分为4个内存区间【2525+8),【25+825+16),【25+1625+24),【25+2425+32);216这一类,以214分为4个小区间【216216+214),【216+214216+2*214),【216+2*214216+3*214),【216+3*214216+4*214)。同时为了快速检索到空闲块,每一层链表都有一个bitmap用于标记对应的链表中是否有空闲块,比如第一层bitmap3010,表示25这一类内存区间有空闲块。对应的第二层bitmap0100表示【25+1625+24)这个区间有空闲块,即下面的52Byte

    • Buddysystems(伙伴算法)

    Segregated Fit算法的变种,具有更好的内存拆分和回收合并效率。伙伴算法有很多种类,比如BinaryBuddies,Fibonacci Buddies等。Binary Buddies是最简单也是最流行的一种,将所有空闲分区根据分区的大小进行分类,每一类都是具有相同大小的空闲分区的集合,使用一个空闲双向链表表示。BinaryBuddies中所有的内存分区都是2的幂次方。

    因为无论是已分配的或是空闲的分区,其大小均为 2 的幂次方,即使进程申请的内存小于分配给它的内存块,多余的内存也不会再拆分出来给其他进程使用,这样就容易造成内部碎片。

    当进程申请一块大小为n的内存时的分配步骤为:

    1、计算一个i值,使得2i-1<n≤2i

    2、在空闲分区大小为2i的空闲链表中查找

    3、如果找到空闲块,则分配给进程

    4、如果2i的空闲分区已经耗尽,则在分区大小为2i+1的空闲链表中查找

    5、如果存在2i+1的空闲分区,则将此空闲块分为相等的两个分区,这两分区就是一对伙伴,其中一块分配给进程,另一块挂到分区大小为2i的空闲链表中

    6、如果2i+1的空闲分区还是不存在,则继续查找大小为2i+2的空闲分区。如果找到,需要进行两次拆分。第一次拆分为两块大小为2i+1的分区,一块分区挂到大小为2i+1的空闲链表中,另一块分区继续拆分为两块大小为2i的空闲分区,一块分配给进程,另一块挂到大小为2i的空闲链表中

    7、如果2i+2的空闲分区也找不到,则继续查找2i+3,以此类推

    内存回收时,如果待回收的内存块与空闲链表中的一块内存互为伙伴,则将它们合并为一块更大的内存块,如果合并后的内存块在空闲链表中还有伙伴,则继续合并到不能合并为止,并将合并后的内存块挂到对应的空闲链表中。

    下面的表格对上面6种算法的优缺点进行了比较:

    内存算法
    优点
    缺点
    First Fit高地址空间大空闲块被保留低地址空间被不断拆分,造成碎片;每次都从第一个空闲分区开始查找,增加了查找时的系统开销
    Next Fit空闲分区分布比较均匀,算法开销小缺乏大内存空闲块
    Best Fit用最小内存满足要求,保留大内存空闲块每次分配后所拆分出来的剩余空闲内存总是最小的,造成许多小碎片,算法开销大
    Worst Fit每次分配后所拆分出来的剩余空闲内存仍较大,减少小碎片产生缺乏大内存空闲块,算法开销大
    TLSF查找效率高,时间复杂度小,碎片问题表现良好内存回收时算法复杂,系统开销大
    Buddy systems内部碎片比较严重外部碎片较少

    免责声明:本文转自LiteOS物联网操作系统,版权归原作者所有。如涉及作品版权问题,请与我联系删除。

    推荐阅读:

    ST-LINK Utility查看内核运行状态

    C语言中几种特殊标准定义和用法

    C语言 volatile 关键字在编译优化过程中有何作用

    关注微信公众号『strongerHuang』,后台回复“1024”查看更多内容,回复“加群”按规则加入技术交流群。

    长按前往图中包含的公众号关注

    展开全文
  • 内存管理算法与C,C++实现内存管理算法与C,C++实现内存管理算法与C,C++实现内存管理算法与C,C++实现内存管理算法与C,C++实现
  • C++ 内存管理算法和实现.详细介绍了C++在内存管理方面的知识点。一本好书。
  • TLSF 内存管理算法的源代码,包含测试的样例程序
  • 本文主要介绍内存的基本概念以及操作系统的内存管理算法。一、内存的基本概念内存是计算机系统中除了处理器以外最重要的资源,用于存储当前正在执行的程序和数据。内存是相对于 CPU 来说的,CPU 可以直接寻址的存储...

    本文主要介绍内存的基本概念以及操作系统的内存管理算法。

    一、内存的基本概念

    内存是计算机系统中除了处理器以外最重要的资源,用于存储当前正在执行的程序和数据。内存是相对于 CPU 来说的,CPU 可以直接寻址的存储空间叫做内存,CPU 需要通过驱动才能访问的叫做外存。

    二、ROM&RAM&Flash

    内存一般采用半导体存储单元,分为只读存储器(ROM,Read Only Memory)、随机存储器(RAM,Random Access Memory)ROM 一般只能读取不能写入,掉电后其中的数据也不会丢失。RAM 既可以从中读取也可以写入,但是掉电后其中的数据会丢失。内存一般指的就是 RAM。

    ROM 在嵌入式系统中一般用于存储 BootLoader 以及操作系统或者程序代码或者直接当硬盘使用。近年来闪存(Flash)已经全面代替了 ROM 在嵌入式系统中的地位,它结合了 ROM 和 RAM 的长处,不仅具备电子可擦除可编程的特性,而且断电也不会丢失数据,同时可以快速读取数据。

    三、两类内存管理方式 内存管理模块管理系统的内存资源,它是操作系统的核心模块之一。主要包括内存的初始化、分配以及释放。

    从分配内存是否连续,可以分为两大类。

    连续内存管理

    为进程分配的内存空间是连续的,但这种分配方式容易形成内存碎片(碎片是难以利用的空闲内存,通常是小内存),降低内存利用率。连续内存管理主要分为单一连续内存管理和分区式内存管理两种。

    非连续内存管理

    将进程分散到多个不连续的内存空间中,可以减少内存碎片,内存使用率更高。如果分配的基本单位是页,则称为分页内存管理;如果基本单位是段,则称为分段内存管理。

    当前的操作系统,普遍采用非连续内存管理方式。不过因为分配粒度较大,对于内存较小的嵌入式系统,一般采用连续内存管理。本文主要对嵌入式系统中常用的连续内存管理的分区式内存管理进行介绍。

    四、分区式内存管理 分区式内存管理分为固定分区和动态分区。

    固定分区

    事先就把内存划分为若干个固定大小的区域。分区大小既可以相等也可以不等。固定分区易于实现,但是会造成分区内碎片浪费,而且分区总数固定,限制了可以并发执行的进程数量。

    动态分区

    根据进程的实际需要,动态地给进程分配所需内存。

    五、动态分区内存管理 运作机制

    动态分区管理一般采用空闲链表法,即基于一个双向链表来保存空闲分区。对于初始状态,整个内存块都会被作为一个大的空闲分区加入到空闲链表中。当进程申请内存时,将会从这个空闲链表中找到一个大小满足要求的空闲分区。如果分区大于所需内存,则从该分区中拆分出需求大小的内存交给进程,并将此拆分出的内存从空闲链表中移除,剩下的内存仍然是一个挂在空闲链表中的空闲分区。

    数据结构

    空闲链表法有多种数据结构实现,这里介绍一种较为简单的数据结构。每个空闲分区的数据结构中包含分区的大小,以及指向前一个分区和后一个分区的指针,这样就能将各个空闲分区链接成一个双向链表。

    内存分配算法

    First Fit(首次适应算法)

    First Fit 要求空闲分区链表以地址从小到大的顺序链接。分配内存时,从链表的第一个空闲分区开始查找,将最先能够满足要求的空闲分区分配给进程。

    Next Fit(循环首次适应算法)

    Next Fit 由 First Fit 算法演变而来。分配内存时,从上一次刚分配过的空闲分区的下一个开始查找,直至找到能满足要求的空闲分区。查找时会采用循环查找的方式,即如果直到链表最后一个空闲分区都不能满足要求,则返回到第一个空闲分区开始查找。

    Best Fit(最佳适应算法)

    从所有空闲分区中找出能满足要求的、且大小最小的空闲分区。为了加快查找速度,Best Fit 算法会把所有空闲分区按其容量从小到大的顺序链接起来,这样第一次找到的满足大小要求的内存必然是最小的空闲分区。

    Worst Fit(最坏适应算法)

    从所有空闲分区中找出能满足要求的、且大小最大的空闲分区。Worst Fit 算法按其容量从大到小的顺序链接所有空闲分区。

    Two LevelSegregated Fit(TLSF)

    使用两层链表来管理空闲内存,将空闲分区大小进行分类,每一类用一个空闲链表表示,其中的空闲内存大小都在某个特定值或者某个范围内。这样存在多个空闲链表,所以又用一个索引链表来管理这些空闲链表,该表的每一项都对应一种空闲链表,并记录该类空闲链表的表头指针。

    3b9ed2546c6f3dafaca43743a3461dc6.png

    图中,第一层链表将空闲内存块的大小根据 2 的幂进行分类。第二层链表是具体的每一类空闲内存块按照一定的范围进行线性分段。比如 25 这一类,以 23 即 8 分为 4 个内存区间【25,25+8),【25+8,25+16),【25+16,25+24),【25+24,25+32);216 这一类,以 214 分为 4 个小区间【216,216+214),【216+214,216+2*214),【216+2*214,216+3*214),【216+3*214,216+4*214)。同时为了快速检索到空闲块,每一层链表都有一个 bitmap 用于标记对应的链表中是否有空闲块,比如第一层 bitmap 后 3 位 010,表示 25 这一类内存区间有空闲块。对应的第二层 bitmap 为 0100 表示【25+16,25+24)这个区间有空闲块,即下面的 52Byte。

    Buddysystems(伙伴算法)

    Segregated Fit 算法的变种,具有更好的内存拆分和回收合并效率。伙伴算法有很多种类,比如 BinaryBuddies,Fibonacci Buddies 等。Binary Buddies 是最简单也是最流行的一种,将所有空闲分区根据分区的大小进行分类,每一类都是具有相同大小的空闲分区的集合,使用一个空闲双向链表表示。BinaryBuddies 中所有的内存分区都是 2 的幂次方。 因为无论是已分配的或是空闲的分区,其大小均为 2 的幂次方,即使进程申请的内存小于分配给它的内存块,多余的内存也不会再拆分出来给其他进程使用,这样就容易造成内部碎片。 当进程申请一块大小为 n 的内存时的分配步骤为:

    1、计算一个 i 值,使得 2i-1

    2、在空闲分区大小为 2i 的空闲链表中查找

    3、如果找到空闲块,则分配给进程

    4、如果 2i 的空闲分区已经耗尽,则在分区大小为 2i+1 的空闲链表中查找

    5、如果存在 2i+1 的空闲分区,则将此空闲块分为相等的两个分区,这两分区就是一对伙伴,其中一块分配给进程,另一块挂到分区大小为 2i 的空闲链表中

    6、如果 2i+1 的空闲分区还是不存在,则继续查找大小为 2i+2 的空闲分区。如果找到,需要进行两次拆分。第一次拆分为两块大小为 2i+1 的分区,一块分区挂到大小为 2i+1 的空闲链表中,另一块分区继续拆分为两块大小为 2i 的空闲分区,一块分配给进程,另一块挂到大小为 2i 的空闲链表中

    7、如果 2i+2 的空闲分区也找不到,则继续查找 2i+3,以此类推

    在内存回收时,如果待回收的内存块与空闲链表中的一块内存互为伙伴,则将它们合并为一块更大的内存块,如果合并后的内存块在空闲链表中还有伙伴,则继续合并到不能合并为止,并将合并后的内存块挂到对应的空闲链表中。

    8267d72599d335d94beac6fbb22383ab.png

    下面的表格对上面 6 种算法的优缺点进行了比较:

    1645e96627fb7c6beb5b69d1851bab06.png
    展开全文
  • 关于进程调度算法的实现程序和内存管理算法的实现程序,开发语言c++,内存管理是采用分页管理机制。
  • c++ 内存管理算法和实现
  • python的内存管理算法与优化 前期准备 我们可以用python的gc模块控制python的内存管理和回收 gc.disable()# 暂停自动垃圾回收 gc.collect()# 执行完整的垃圾回收,返回无法到达的对象的数量 gc.set_threshold()# ...

    python的内存管理算法与优化

    前期准备

    1. 我们可以用python的gc模块控制python的内存管理和回收
      • gc.disable()# 暂停自动垃圾回收
      • gc.collect()# 执行完整的垃圾回收,返回无法到达的对象的数量
      • gc.set_threshold()# 设置垃圾回收的阈值
      • gc.set_debug()# 设置垃圾回收的调试标记. 调试信息会被写入std.err.
    2. sys跟objgraph库

    python内存管理算法

    python的内存管理机制有两种:引用计数和分代垃圾回收

    引用次数
    1. 引用计数+1的情况
      对象被创建 a=‘123’
      对象被引用 b=a
      对象被当作参数传入函数 fun(a)
      对象最为元素存储到容器中 c={a:’1’}
    2. 引用计数-1的情况
      对象的别名被显式销毁 del b
      对象的别名被赋予其它值 b=1
      对象离开它的作用域,比如函数执行完毕后,函数里面的局部变量的引用计数-1
      对象从容器中删除,或者所在的容器被销毁 del c
    3. 引用计数的优点
      高效
      回收内存的时间是分布的,引用计数为0马上回收,不会给系统造成停顿
      对象生命周期明确
      容易实现
    4. 引用计数缺点
      额外空间维护引用计数
      无法解决循环引用的情况
      循环引用的例子
    a=[1]
    b=[2]
    a.append(b)
    b.append(a)
    
    
    del a
    del b
    
    #del a del b只是把引用计数-1,del后ab原来所指的对象的引用计数为1 无法进行资源回收,但也无法访问
    
    
    
    1. 查看引用计数的方法
      sys.getrefcount()
      objgraph.count()
    垃圾回收机制

    python的垃圾回收机制就是为了解决循环引用的问题
    python的垃圾回收机制分为mark-sweep算法和分代(generational)算法

    1. mark-sweep算法
      分为mark(标记)和sweep(清除)两部分
      python中所有能够引用其它对象的对象都叫做container(容器),只有container之间才会出现循环引用
      把所有的容器都放到一个双向链表中,使用双向链表是为了方便快速插入删除对象

    mark部分具体的操作如下

    • 每个容器设置一个gc_ref,并初始化为该容器的引用计数值ob_ref
    • 对每个容器,找到它引用的所有对象,将被引用对象的gc_ref-1
    • 对所有容器执行完上述操作后,所有gc_ref不为0的容器则还存在被引用的情况,不能销毁,把他们放到另一个集合A
    • 上一个操作中的集合A中,他们所引用的对象也是不能释放的,也放进集合A中
    • 剩下的不在集合A里面的则可以进行回收

    需要回收的内存就是存在循环引用的容器,循环引用的容器集合会成为一个孤岛,外部没有办法访问到,mark部分的原理其实就是模拟了一次容器自身的释放,这样就可以打破循环引用的容器集合中互相依赖的情况

    sweep部分可以略过,就是对mark找出来的部分进行回收

    1. 分代(generational)算法
      python根据容器的活跃程度把容器分为三代:0代、1代、2代,每一代都是一个由双向链表实现的容器集合
      上述的mark-sweep算法其实并非每次都对所有容器都进行标记清除,而是每次对同一代的容器进行标记清除

    给容器分代的原因—弱代假说

    • 弱代假说的观点:年轻的对象更快销毁,年老的对象可能存活更长时间,比如局部变量跟全局变量的对比
    • 如果不用分代算法,每次都对所有容器进行mark-sweep,实际上有一部分容器还没到达销毁时间,我们不希望这部分容器被频繁地执行算法,所以有了分代算法

    分代算法的过程跟触发每一代的规则

    • 每当容器被创建时,python把它加入0代链表中
    • 0代:当被分配的对象的数量减去被释放对象后的差值大于设置的threshold0时,启动0代中的mark-sweep算法,产生的不被销毁的容器集合并入1代链表中
    • 1代:当0代启动mark-sweep算法的次数大于设置的threshold1时,启动1代中的mark-sweep算法,产生的不被销毁的容器集合并入2代链表中
    • 2代:当1代启动mark-sweep算法的次数大于设置的threshold2时,启动2代中的mark-sweep算法

    通过gc.set_threshold()可以设置threshold0、threshold1、threshold2的值

    python内存管理优化

    每一次python进行垃圾回收,都要对所有的容器进行两次遍历(第一次设置gc_ref值,第二次让gc_ref-1),所以消耗会很大,我们可以在程序层面进行一些调优

    调优方式
    1. 手动垃圾回收
    • 关闭自动回收gc.disable()
    • 合适的时候用gc.collect()触发垃圾回收,比如打游戏过程中不进行垃圾回收,在用户等待或游戏结算的时候再出发垃圾回收
    1. 提高垃圾回收阈值
      通过gc.set_threshold()设置回收阈值,减少垃圾回收的次数

    2. 避免循环引用
      整个垃圾回收机制都是为了解决循环引用的问题,如果代码能保证没有循环引用问题,则可以直接关闭垃圾回收

    常见手段

    • 手动解循环引用
    class A(object):
       def __init__(self):
           self.child = None
    
    
       def destroy(self):
           self.child = None
    
    
    class B(object):
       def __init__(self):
           self.parent = None
    
    
       def destroy(self):
           self.parent = None
    
    
    def test3():
       a = A()
       b = B()
       a.child = b
       b.parent = a
       a.destroy()
       b.destroy()
    
    
    test3()
    print 'Object count of A:', objgraph.count('A’) #0
    print 'Object count of B:', objgraph.count('B’) #0
    
    
    
    • 使用弱引用,python自带的弱引用库weakref 弱引用相关参考:https://yuerblog.cc/2018/08/28/python-weakref-real-usage/
    def test4():
       a = A()
       b = B()
       a.child = weakref.ref(b)
       b.parent = weakref.ref(a)
    
    
    test4()
    print 'Object count of A:', objgraph.count('A’) #0
    print 'Object count of B:', objgraph.count('B’) #0
    
    
    

    内存泄露

    有了引用计数和垃圾回收,python仍然有可能发生内存泄露,发生的情况如下

    • 对象被另一个生命周期特别长的对象所引用,比如网络服务器,可能存在一个全局的单例ConnectionManager,管理所有的连接Connection,如果当Connection理论上不再被使用的时候,没有从ConnectionManager中删除,那么就造成了内存泄露。
    • 循环引用的对象中定义了__del__函数,如果定义了这个函数,python无法判断析构对象的顺序,因此会不做处理

    参考

    http://www.doc88.com/p-78747715867.html
    http://kkpattern.github.io/2015/06/20/python-memory-optimization-zh.html
    https://blog.csdn.net/xiongchengluo1129/article/details/80462651
    https://www.cnblogs.com/xybaby/p/7491656.html

    展开全文
  • 仿照linux的buddy+slub内存管理算法,可以在裸机中应用标准内存管理库函数,如malloc free等
  • 内存管理算法实现

    千次阅读 2016-11-03 21:08:45
    在上一节,我们得知可用内存的大小后,我们就可以开发一个简单的管理算法去管理和分配可用用内存
  • 随机给出一个页面执行序列,如:1,...要求计算以下几种置换算法的缺页数、缺页率和命中率。  最佳置换算法OPT(Optimal)  先进先出算法FIFO(First In First Out)  最近最少使用算法LRU(Least Recently Used)
  • RT-thread内核之小内存管理算法

    千次阅读 2016-07-04 14:35:20
    一、动态内存管理 ...RT-Thread系统为了满足不同的需求,提供了两套不同的动态内存管理算法,分别是小内存管理算法和SLAB内存管理算法。小堆内存管理模块主要针对系统资源比较少,一般用于小于2M内
  • buddy system内存管理,努力让内存分配与相邻内存合并能快速进行(对于普通算法来讲,合并内存相当困难),它利用的是计算机擅长处理2的幂运算。 我们创建一系列空闲块列表,每一种都是2的倍数。 举个例子,如果最小...
  • 系统空间的内存管理算法: 仅列出关键结构和逻辑,代码神码的是各种繁琐额。。。 1 非换页内存池管理算法 非换页内存池 一个是MmNonPagedPoolStart这个是已经申请好物理内存的,另外还有一个...
  • rt-thread的小内存管理算法分析

    千次阅读 2016-08-10 20:12:10
    rt-thread的小内存管理是rt-thread操作系统默认堆内存管理算法,是一种简单的内存分配算法,当有可用的内存的时候,会从中分割一块来作为分配的内存,而剩下的则返回到动态内存堆中.此算法采用了一个静态链表来实现的,其...
  • 引进SLAB内存管理算法,BUDDY算法来说,如果要存放很少字节内容而分配一个页,会照成很大的浪费。内存管理引进了SLAB内存管理。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,904
精华内容 3,161
关键字:

内存管理算法