glibc内存管理ptmalloc

1、前言

今天想谈谈ptmalloc如何为应用程序分配释放内存的，基于以下几点原因才聊它：

  1. C/C++ 70%的问题是内存问题。了解一点分配器原理对解决应用程序内存问题肯定有帮助。
  2. C++也在用ptmalloc. 当你在C++中new一个对象时，底层还是依赖glibc中的ptmalloc.
  3. 虽然市面上还有jemalloc/tcmalloc, 但ptmalloc被glibc内嵌，用的最广.

2、初识ptmalloc

ptmalloc是glibc（GNU C库）中使用的内存分配器，它基于dlmalloc（Doug Lea’s Malloc）的设计。ptmalloc的主要目标是为多线程应用程序提供高效的内存分配和释放，其名称中的“pt”代表“pthreads”，即POSIX线程库。

ptmalloc所有版本的源代码可在Index of /gnu/glibc下载，其中2.26为了增强多线程情况下的性能引入了tcache, 不过为了使讲解简单，我们还是以2.26之前的版本2.17来分析其原理。

相信很多程序员都思考过一个问题而且也知道答案：

free函数释放内存时只有一个参数 -- 要释放内存的指针，那要释放多大的内存哪？？？

答案就是这块内存前面的8个字节（64bit下，之后默认都是64bit）存了这块内存大小，让我们看个例子快速入门一下：

void *p1= malloc(10);
memset(p1,'a',10);

 就像大大小小不同种类的卡车都有个车斗拉东西，ptmalloc的卡车叫malloc chunk用来拉内存, 它有自重，0x602000~0x602010便是自重（大小：0x10字节，有个特例，以后再说），对用户来说浪费掉了不能用来拉东西，还剩0x20-0x10=0x10个字节可以放用户数据，比我们申请的10个字节多一点点，这是故意预留的。

ptmalloc本质就是一个内存缓冲池，缓存的最小单位就是malloc chunk. 之后我们提到chunk或者malloc chunk都是一个东西。即使free的内存实际可能并没有free，而是被ptmalloc管理了起来。

3、卡车的定义 malloc_chunk

通过上面的例子我们看到了卡车的一个零部件：size（卡车大小）。那它有其它零部件吗？让我们看下它的庐山真面目：

struct malloc_chunk
{

  INTERNAL_SIZE_T prev_size; /* 上一个malloc_chunk的size（如果它是free状态）.  */
  INTERNAL_SIZE_T size;      /*  本malloc_chunk的size，包括16个字节的自重 */

  struct malloc_chunk *fd; /* 用来构造双向链表 -- 仅仅用在free的chunk上. */
  struct malloc_chunk *bk; /* 用来构造双向链表 -- 仅仅用在free的chunk上. */

  /* 以下两个字段用在large chunk上，以后介绍.  */
  struct malloc_chunk *fd_nextsize; 
  struct malloc_chunk *bk_nextsize;
};

 正如代码组织所暗示，两两一组, prev_size & size, fd & bk, fd_nextsize & bk_nextsize. 

后两组只有在本chunk free的状态下才有意义，不然就存储用户数据。

3.1、prev_size & size 物理相邻的chunk

prev_size表示上个chunk的大小，只有上个chunk是free时才有此意义。size表示本chunk大小，但是最后三位从最不重要的位开始由特别意义分别表示：

  1. 物理上上个chunk在用（非free, PREV_INUSE)
  2. 本chunk是由mmap()分配的（IS_MMAPPED）
  3. 本chunk是属于非主arena的（NON_MAIN_ARENA）

我们着重讲下第一个PREV_INUSE：

所有的chunk在物理上都是相邻的，就像火车车厢一样连在一起，

不过与直觉相反的是：不是自己表示自己空不空，而是由下一个chunk表示上一个chunk空不空（原因在下面的总结中）。

下面看个例子理解下PREV_INUSE、prev_size：

int main(int argc, char* argv[])
{
        void *p1= malloc(192); //192是故意的，较小的数字free后会到fastbin中
                               //PREV_INUSE依然保持1，那样达不到演示PREV_INUSE的效果
        memset(p1,'a',192);    //原因在fastbin中介绍

        void *p2= malloc(20);
        memset(p2,'b',20);

        free(p1);
}

调试到free但还没free，通过下图理解下p2所在malloc chunk前两个字段的意义。

(gdb) p *(mchunkptr)(p2-16)
$2 = {prev_size = 0, size = 33, fd = 0x6262626262626262, bk = 0x6262626262626262, fd_nextsize = 0x62626262,
  bk_nextsize = 0x20f11}

然后把p1释放，再看下p2 malloc chunk.size:

 

(gdb) p *(mchunkptr)(p2-16)
$3 = {prev_size = 208, size = 32, fd = 0x6262626262626262, bk = 0x6262626262626262, fd_nextsize = 0x62626262,
  bk_nextsize = 0x20f11}

这里眼尖的同学可能已经注意到prev_size只有在上个chunk free的状态下有意义，如果上个chunk分配给用户了则什么也没存，浪费掉了！ptmalloc的作者早就想到了这一点：prev_size这8个字节还真可以让渡给上个chunk用来存用户数据，我们把上面程序中的192改成194或者200看一看

  

总结一下： 

1. prev size, prev inuse中的prev指的是物理上相邻的两个chunk的前一个（内存地址小的那个）

2. size字段指本chunk自己的size大小，包括自重（overhead）。size的最不重要的三位（bit）是三个flag，其中最后那个位(bit)表示上个chunk是否free，如果上个chunk是free则prev_size有意义且表示上个chunk的size。为什么要在一个chunk里存上一个chunk的size哪？这是为了方便两者都是free时好合并成一个大的chunk， p - prev_size就指向了上一个chunk。

3. malloc_chunk虽然有这么多数据成员，但只有size永远有意义，为了提高负载率其它字段在某种情况下会被用来放用户数据：a. 本chunk假如分配出去了（malloc），则fd、bk、fd_nextsize、bk_nextsize都无意义，可以用来放用户数据； b. 上个chunk假如分配出去了(malloc)且malloc的大小%8<=8, 则本chunk的prev_size字段会被用来存储上个chunk的用户数据。

3.2、fd & bk 逻辑上把free的chunk串起来

ptmalloc中有个bin的概念，正如字面意思就是回收垃圾用的垃圾桶（放free掉的chunk），bin有如下几类：

fastbin - 单向链表，放小chunk，默认为小到0x20大到0x80大小的，以16字节递进。比如main_arena.fastbinsY[0]指向大小为0x20的chunk链表，main_arena.fastbinsY[1]指向大小为0x30的chunk链表...

unsortedbin - 双向链表，临时垃圾桶，里面的chunk的size不一致。

smallbin - 双向链表，也是放小chunk，但上限到0x3F0, 以16字节递进, 共62个smallbin。

largebin - 双向链表，放大chunk, 63个.（largebin本节不具体展开）

main_arena是一个全局变量，它是一个很好的入口去找到这些bin，如下图示：

4、fastbin

fastbin, 正如它的名字，是用的最频繁的bin。当一块小内存被释放后，极大可能会被放到对应大小的fastbin链条上的，以加快下次分配同样大小的内存。

void* p1 = malloc(10);
free(p1);
void* p2 = malloc(10);

上面这段代码，p1 p2应该是相等的。 

fastbin是单链表，fd指向下一个；先释放的在链尾，后释放的放在链头。也就是说那些最近别使用过得内存更容易被再次使用；那些很久以前free掉最近都没用过的内存，有较大的概率被swap out了，重新使用的代价可能较大。

下面看个例子：

int main(int argc, char* argv[])
{
        void *p1= malloc(10);
        memset(p1,'a',10);

        void *p2= malloc(10);
        memset(p2,'b',10);

        void *p3= malloc(30);
        memset(p3,'c',10);

        void *p4= malloc(30);
        memset(p4,'d',10);

        free(p1);
        free(p2);
        free(p3);
        free(p4);

        getchar();

#链接我自己编译出来的glibc
[mzhai]$ gcc fastbin.c -I/usr/local/glibc-2.17/include -L/usr/local/glibc-2.17/lib -Wl,--rpath=/usr/local/glibc-2.17/lib -Wl,--rpath=/lib64 -Wl,--dynamic-linker=/usr/local/glibc-2.17/lib/ld-2.17.so -g
[mzhai]$ gdb ./a.out

运行到getchar, 看下fastbinsY[0] & [1],

(gdb) p main_arena
$2 = {mutex = 0, flags = 0, fastbinsY = {0x602020, 0x602070, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, top = 0x6020a0,
  last_remainder = 0x0, bins = {0x7ffff7dd7678 <main_arena+88>, 0x7ffff7dd7678 <main_arena+88>,

#chunk大小为0x20的链表. 
(gdb) p /x *(mchunkptr)0x602020
$7 = {prev_size = 0x0, size = 0x21, fd = 0x602000, bk = 0x6262, fd_nextsize = 0x0, bk_nextsize = 0x31}
(gdb) p /x *(mchunkptr)0x602000
$8 = {prev_size = 0x0, size = 0x21, fd = 0x0, bk = 0x6161, fd_nextsize = 0x0, bk_nextsize = 0x21}

#chunk大小为0x30的链表。
(gdb) p /x *(mchunkptr)0x602070
$9 = {prev_size = 0x0, size = 0x31, fd = 0x602040, bk = 0x6464, fd_nextsize = 0x0, bk_nextsize = 0x0}
(gdb)  p /x *(mchunkptr)0x602040
$10 = {prev_size = 0x0, size = 0x31, fd = 0x0, bk = 0x6363, fd_nextsize = 0x0, bk_nextsize = 0x0}

 

fastbin共有最多10个链表 ，已由arena.fastbinY[10]限制死，默认7个。用户能通过mallopt(M_MXFAST, value)个性化设置链表个数，但意义不大，最多也就10个。

 5、unsortedbin 

双向链表，临时垃圾桶，里面的chunk的size不一致。

是第二常用的bin，free时没进fastbin则大概率要进unsortedbin. 之后的malloc可能会把unsortedbin上的chunk挪到smallbin.

int main(int argc, char* argv[])
{
        void *p1= malloc(200);
        memset(p1,'a',200);

        void *temp1= malloc(10); //把p1 p2隔开，防止合并
        memset(temp1,'b',10);

        void *p2= malloc(300);
        memset(p2,'a',300);

        void *temp2= malloc(10); //把p2 top 隔开，防止合并
        memset(temp2,'c',10);

        free(p1);
        free(p2);

        getchar();

调试到getchar, 

(gdb) p main_arena
$1 = {mutex = 0, flags = 1, fastbinsY = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, top = 0x602250,
  last_remainder = 0x0, bins = {0x6020f0, 0x602000

(gdb) p *(mchunkptr)0x6020f0
$4 = {prev_size = 0, size = 321, fd = 0x602000, bk = 0x7ffff7dd7678 <main_arena+88>, fd_nextsize = 0x6161616161616161,
  bk_nextsize = 0x6161616161616161}
(gdb) p *(mchunkptr)0x602000
$5 = {prev_size = 0, size = 209, fd = 0x7ffff7dd7678 <main_arena+88>, bk = 0x6020f0, fd_nextsize = 0x6161616161616161,
  bk_nextsize = 0x6161616161616161}

6、smallbin

 双向链表，也是放小chunk，但上限到0x3F0, 以16字节递进, 共62个smallbin。

smallbin与unsortedbin相似，都是双向链表，不同的是：smallbin每个链上chunk大小相等，这一点与fastbin一致。

free时不会直接往smallbin里扔chunk，而是malloc时把unsortedbin里的chunk整理到对应的smallbin链上。

请看下面的例子：

int main(int argc, char* argv[])
{
        void *p1= malloc(30);
        void *temp1= malloc(10);

        void *p2= malloc(30);
        void *temp2= malloc(10);

        void *p3= malloc(30);
        void *temp3= malloc(10);

        free(p1);
        free(p2);
        free(p3); //fastbin 0x30链表上p3->p2->p1

        void* large = malloc(1024); //fastbin->unsortedbin->smallbin
        getchar();

free(p3)后

(gdb) p main_arena
$1 = {mutex = 0, flags = 0, fastbinsY = {0x0, 0x6020a0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, top = 0x6020f0,
  last_remainder = 0x0, bins = {0x7ffff7dd7678 <main_arena+88>, 0x7ffff7dd7678 <main_arena+88>,
    0x7ffff7dd7688 <main_arena+104>, 0x7ffff7dd7688 <main_arena+104>, 0x7ffff7dd7698 <main_arena+120>,

(gdb) p *(mchunkptr)0x6020a0
$2 = {prev_size = 0, size = 49, fd = 0x602050, bk = 0x0, fd_nextsize = 0x0, bk_nextsize = 0x0}
(gdb) p *(mchunkptr)0x602050
$3 = {prev_size = 0, size = 49, fd = 0x602000, bk = 0x0, fd_nextsize = 0x0, bk_nextsize = 0x0}
(gdb) p *(mchunkptr)0x602000
$4 = {prev_size = 0, size = 49, fd = 0x0, bk = 0x0, fd_nextsize = 0x0, bk_nextsize = 0x0} 

之后要分配1024字节，加上自重共1040个字节，借助这个malloc我们过一下malloc的大体流程：

1. 首先从fastbin中寻找。因为1040大于fastbin的范围（0x20~0x80/0xa0)，找不到。

if ((unsigned long)(nb) <= (unsigned long)(get_max_fast ()))

2. 从smallbin中寻找。1040已超过smallbin的范围。

3315      if (in_smallbin_range(nb))
3355      else {                                                                                                      
3356        idx = largebin_index(nb);                                                                                 
3357        if (have_fastchunks(av))                                                                                  
3358          malloc_consolidate(av); //fastbin -> unsortedbin   
              //只有要申请的字节数>=1024 且 fastbin不空 才触发 fastbin -> unsortedbin                                                                          
              //这才是我们的例子中要申请1024字节的原因
3359      }

(gdb) p main_arena
$7 = {mutex = 1, flags = 1, fastbinsY = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, top = 0x6020f0,
  last_remainder = 0x0, bins = {0x602000, 0x6020a0, 0x7ffff7dd7688 <main_arena+104>, 0x7ffff7dd7688 <main_arena+104>,
    0x7ffff7dd7698 <main_arena+120>, 0x7ffff7dd7698 <main_arena+120>, 0x7ffff7dd76a8 <main_arena+136>,

(gdb) p *(mchunkptr)0x602000
$8 = {prev_size = 0, size = 49, fd = 0x602050, bk = 0x7ffff7dd7678 <main_arena+88>, fd_nextsize = 0x0, bk_nextsize = 0x0}
(gdb) p *(mchunkptr)0x602050
$9 = {prev_size = 0, size = 49, fd = 0x6020a0, bk = 0x602000, fd_nextsize = 0x0, bk_nextsize = 0x0}
(gdb) p *(mchunkptr)0x6020a0
$10 = {prev_size = 0, size = 49, fd = 0x7ffff7dd7678 <main_arena+88>, bk = 0x602050, fd_nextsize = 0x0, bk_nextsize = 0x0}

fastbin上的3个chunk 已被move到 unsortedbin上

3. 整理unsortedbin上的chunk到smallbin/largebin上

3377        while ( (victim = unsorted_chunks(av)->bk) != unsorted_chunks(av)) { 
//从unsortedbin的最后一个chunk开始，unsorted_chunks(av)是那个虚拟chunk

3422          /* 把victic从unsortedbin上摘下来 */ 
3423          unsorted_chunks(av)->bk = bck;
3424          bck->fd = unsorted_chunks(av); 

3439         /* 把victim放到相应的bin上（smallbin、largebin） */                       
3440                                                        
3441          if (in_smallbin_range(size)) {                
3442            victim_index = smallbin_index(size);        
3443            bck = bin_at(av, victim_index);             
3444            fwd = bck->fd;                              
3445          }                                             
3446          else {                                        
3447            victim_index = largebin_index(size);        
3448            bck = bin_at(av, victim_index);             
3449            fwd = bck->fd;

4. 搜索largebin

5. 从top chunk割一块下来

 chunk move的过程，fastbin -> unsortedbin -> smallbin/largebin

​​​​​​​

虽然这个例子很好的演示了chunk move的过程，但并没有诠释move的意义：正如malloc_consolidate名字所暗示的，它会合并fastbin中相邻的chunk以减少碎片，要知道fastbin的哲学是期盼同样小的内存申请很快到来，所以它不会合并相邻的chunk，这样时间长了碎片就会很多。看下面这个例子：

int main(int argc, char* argv[])
{
        void *p1= malloc(30);
        void *temp1= malloc(10);

        void *p2= malloc(30);
        void *temp2= malloc(10);

        void *p3= malloc(30);
        void *temp3= malloc(10);

        free(p1);
        free(p2);
        free(p3);

        void* large = malloc(1024);

(gdb) p main_arena
$1 = {mutex = 0, flags = 1, fastbinsY = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, top = 0x6024d0,
  last_remainder = 0x0, bins = {0x7ffff7dd7678 <main_arena+88>, 0x7ffff7dd7678 <main_arena+88>,
    0x7ffff7dd7688 <main_arena+104>, 0x7ffff7dd7688 <main_arena+104>, 0x7ffff7dd7698 <main_arena+120>,
    0x7ffff7dd7698 <main_arena+120>, 0x7ffff7dd76a8 <main_arena+136>, 0x7ffff7dd76a8 <main_arena+136>,
    0x7ffff7dd76b8 <main_arena+152>, 0x7ffff7dd76b8 <main_arena+152>, 0x7ffff7dd76c8 <main_arena+168>,
    0x7ffff7dd76c8 <main_arena+168>, 0x7ffff7dd76d8 <main_arena+184>, 0x7ffff7dd76d8 <main_arena+184>,
    0x7ffff7dd76e8 <main_arena+200>, 0x7ffff7dd76e8 <main_arena+200>, 0x602000, 0x602000,

(gdb) p *(mchunkptr)0x602000
$2 = {prev_size = 0, size = 145, fd = 0x7ffff7dd76f8 <main_arena+216>, bk = 0x7ffff7dd76f8 <main_arena+216>,
  fd_nextsize = 0x0, bk_nextsize = 0x0}

三个相邻的小碎片被 合体了！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/477238.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

jmeter的函数助手使用方法

jmeter的函数助手使用方法

如某个上传文件接口&#xff0c;一个文件只能同时被一个接口调用&#xff0c;如果被并发同时调用就会报错 创建多个测试文件 比如50并发&#xff0c;创建更多的文件防止并发多时随机数生成重复 生成随机数函数 工具–函数助手-选择random-输入范围&#xff08;1-696&#…
阅读更多...
vue3父子通信、跨层通信

vue3父子通信、跨层通信

子传父 通过 ref标识 获取真实的 dom对象或者组件实例对象 父组件获取子组件内部属性和方法 顶层组件向任意的底层组件传递数据和方法&#xff0c;实现跨层组件通信 非响应式数据父修改不了子的内容 子组件调用父组件方法
阅读更多...
若依微服务跑起来-微服务小白入门（1）

若依微服务跑起来-微服务小白入门（1）

背景 若依的基本框架系列&#xff0c;已经构建起来&#xff0c;请参照 小白入门系列 - 鸡毛掸子 这些东西理解&#xff0c;并且实际板砖以后&#xff0c;有必要对现在流行的一些概念做一些升级&#xff0c;现在我们就进入到所谓的cloud版本&#xff0c;其实&#xff0c;前面的…
阅读更多...
【C++】多态 （上）

【C++】多态 （上）

在实际生活中我们也经常见到多态的例子&#xff0c;多态就是不同的对象完成同一个行为时会产生不同的状态&#xff0c;比如成人和儿童购票就是不一样的&#xff0c;多态是可以基于继承的&#xff0c;我们本篇博客的多态就是基于继承的&#xff0c;下面我们先看一个简单例子 cla…
阅读更多...
JsonUtility.ToJson 和UnityWebRequest 踩过的坑记录

JsonUtility.ToJson 和UnityWebRequest 踩过的坑记录

项目场景&#xff1a; 需求&#xff1a;我在做网络接口链接&#xff0c;使用的unity自带的 UnityWebRequest &#xff0c;数据传输使用的json&#xff0c;json和自定义数据转化使用的也是unity自带的JsonUtility。使用过程中发现两个bug。 1.安全验证失败。 报错为&#xff1a…
阅读更多...
.NET Framework 服务实现监控可观测性最佳实践

.NET Framework 服务实现监控可观测性最佳实践

环境信息 系统环境&#xff1a;Windows Server开发语言&#xff1a;.NET Framework > 4.6.1APM探针包&#xff1a;ddtrace 准备工作 安装 Datakit 主机部署&#xff1a; 主机安装 - 观测云文档 打开采集 APM 采集器 Windows 主机配置 # 到如下路径&#xff0c;把ddtr…
阅读更多...
Spring常用设计模式-实战篇之单例模式

Spring常用设计模式-实战篇之单例模式

实现案例&#xff0c;饿汉式 Double-Check机制 synchronized锁 /*** 以饿汉式为例* 使用Double-Check保证线程安全*/ public class Singleton {// 使用volatile保证多线程同一属性的可见性和指令重排序private static volatile Singleton instance;public static Singleton …
阅读更多...
VUE中添加视频播放功能

VUE中添加视频播放功能

转载https://www.cnblogs.com/gg-qq/p/10782848.html 常见错误 vue-video-player下载后‘vue-video-player/src/custom-theme.css‘找不到 解决方法 卸载原来的video-play版本 降低原来的版本 方法一 npm install vue-video-player5.0.1 --save 方法二 或者是在pack.json中直…
阅读更多...
huggingface的transformers训练gpt

huggingface的transformers训练gpt

目录 1.原理 2.安装 3.运行 ​编辑 4.数据集 ​编辑 4.代码 4.1 model init​编辑 forward&#xff1a; 总结&#xff1a; 关于loss和因果语言模型&#xff1a; ​编辑 交叉熵&#xff1a;​编辑 记录一下transformers库训练gpt的过程。 transformers/examples/…
阅读更多...
使用 Amazon SageMaker 微调 Llama 2 模型

使用 Amazon SageMaker 微调 Llama 2 模型

本篇文章主要介绍如何使用 Amazon SageMaker 进行 Llama 2 模型微调的示例。 这个示例主要包括: Llama 2 总体介绍Llama 2 微调介绍Llama 2 环境设置Llama 2 微调训练 前言 随着生成式 AI 的热度逐渐升高&#xff0c;国内外各种基座大语言竞相出炉&#xff0c;在其基础上衍生出…
阅读更多...
MIT的研究人员最近开发了一种名为“FeatUp”的新算法，这一突破性技术为计算机视觉领域带来了高分辨率的洞察力

MIT的研究人员最近开发了一种名为“FeatUp”的新算法，这一突破性技术为计算机视觉领域带来了高分辨率的洞察力

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
vuecli创建vue3项目

vuecli创建vue3项目

第一步&#xff1a; 在文件夹中输入 vue create xxx 第二步&#xff1a; 勾选下面带有*号的&#xff0c;经验最好把Linter/Formatter勾掉&#xff0c;不然会出现eslint报错 第三步&#xff1a; 选择3.x 第四步&#xff1a; 意思为是否用history模式来创建路由&#xff0…
阅读更多...
mineadmin前端安装启动

mineadmin前端安装启动

在上一篇文章中&#xff0c; 我们已经搭建好了后端环境并启动 mineadmin 快速安装部署&#xff08;docker环境&#xff09; 一、下载前端项目 1、在搭建后端时候&#xff0c;使用php bin/hyperf.php mine:install 的时候&#xff0c;有一个步骤是安装前端项目的。安装目录为&a…
阅读更多...
【有源码】buildroot根文件系统编译和常见问题

【有源码】buildroot根文件系统编译和常见问题

前言 编译好的含有QT5等工具包的buildroot根文件 仓库&#xff1a;https://gitee.com/wangyoujie11/atkboard_-linux_-driver 编译过程如下 1.下载源码&#xff0c;解压tar -vxjf xxx.tar.bz2 https://buildroot.org/ 这里以如下版本实验 2.在解压之后的buildroot-2019.02.…
阅读更多...
智慧公厕的系统构成与功能解析

智慧公厕的系统构成与功能解析

智慧公厕系统是通过传感器和云平台相结合的创新技术&#xff0c;旨在提供更好的公厕管理与服务。智慧公厕从系统的构成来看&#xff0c;主要分为感知层&#xff08;数据收集&#xff09;、传输层&#xff08;数据传输&#xff09;、平台层&#xff08;数据处理&#xff09;和应…
阅读更多...
【vue-小知识】var、let 和 const之间的区别

【vue-小知识】var、let 和 const之间的区别

文章目录 结论1、重复定义变量名var&#xff1a;允许重复定义变量名let和const&#xff1a;不可以重复定义变量名 2、修改值var&#xff1a;允许修改值let&#xff1a;允许修改值const&#xff1a;不允许修改值&#xff0c;会报错 3、变量提升var : 支持变量提升let和const&…
阅读更多...
查看VMWare ESXi 6.5/6.7服务器上 GPU直通的状态

查看VMWare ESXi 6.5/6.7服务器上 GPU直通的状态

VMWare ESXi 6.5/6.7服务器状态 查看配置参数
阅读更多...
Google的MELON: 通过未定位图像重建精确3D模型的突破性算法

Google的MELON: 通过未定位图像重建精确3D模型的突破性算法

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
OFC2023活动剪影

OFC2023活动剪影

马上就要OFC 2024了&#xff0c;应该有些新图可以发一发了 先发点老图&#xff0c;丢在这里&#xff0c;怕下次不知道去哪里找 以上是以太网联盟Ethernet Alliance 在OFC2023上展示的一个演示机柜 以下是我们参与OFC2023的剪影&#xff0c;除了参与EA的演示&#xff0c;还有独…
阅读更多...
从错误中进行上下文学习

从错误中进行上下文学习

1、写作动机&#xff1a; 在上下文学习中&#xff0c;也称为少样本提示&#xff08;ICL&#xff09;&#xff0c;一直是调整LLM适应下游任务的标准方法&#xff0c;通过从少量输入-输出示例中学习。然而&#xff0c;所有基于ICL的方法都只从正确的输入-输出对中学习。 2、主要…
阅读更多...
最新文章

Copyright @ 2022~2023