Android计算开机完成之后kernel所消耗的总的内存(不可回收)

【性能】【内存】Android内存分析命令 常用的Android内存分析命令 阅读详情

1. 开机后各可用内存和实际物理内存之间的关系

要计算开机之后剩余的总内存,首先必须弄清楚kernel在开机之后出现的几个可用内存变量之间的关系,今天以一个项目的log来分析开机之后memory的计算方式和各可用内存和总的实际内存之间的关系:

我们在开机之后kernel会有一句log如下:

[html]  view plain  copy
  1. [    0.000000] <0>-(0)[0:swapper]Memory: 3919424K/4027408K available (12244K kernel code, 1856K rwdata, 5636K rodata, 1056K init, 13278K bss, 107984K reserved)  

内存初始化信息的解读如下:

absent:表示不可用的物理内存大小。譬如有一些物理内存被BIOS保留、对kernel是不可用的,这部分物理内存被计入”absent”之中,这里没有出现。

107984k reserved:包括【initrd】和【内核代码及数据】等,其中内核代码和部分数据包含在下列统计值中:

12244k kernel code :表示kernel的代码,属于reserved memory;

1856k rwdata和5636K rodata :表示kernel的可读可写的数据和只读数据大小,属于reserved memory;

1056k init :表示init code和init data,属于reserved memory,但引导完成之后会释放给free memory;

13278k bss:表示kernel bss段的大小;

它们之间的关系如下:

reserved 包括 kernel code, data 和 init,由于它还包括initrd和其它更多的内容,所以reserved远远大于 kernel code + data + init 之和;

此时会有以下几个疑惑:

1. 这里的4027408K是从哪里计算出来的,他与实际总内存4G之间差值包含了哪些内容?

2. 3919424K又是如何计算出来的?

经过查看kernel code可以回答上面的两个问题:

[cpp]  view plain  copy
  1. void __init mem_init_print_info(const char *str)  
  2. {  
  3.     unsigned long physpages, codesize, datasize, rosize, bss_size;  
  4.     unsigned long init_code_size, init_data_size;  
  5.   
  6.     physpages = get_num_physpages();  
  7.     codesize = _etext - _stext;  
  8.     datasize = _edata - _sdata;  
  9.     rosize = __end_rodata - __start_rodata;  
  10.     bss_size = __bss_stop - __bss_start;  
  11.     init_data_size = __init_end - __init_begin;  
  12.     init_code_size = _einittext - _sinittext;  
  13. ……  
  14. printk("Memory: %luK/%luK available "  
  15.            "(%luK kernel code, %luK rwdata, %luK rodata, "  
  16.            "%luK init, %luK bss, %luK reserved"  
  17. #ifdef  CONFIG_HIGHMEM  
  18.            ", %luK highmem"  
  19. #endif  
  20.            "%s%s)\n",  
  21.            nr_free_pages() << (PAGE_SHIFT-10), physpages << (PAGE_SHIFT-10),  
  22. codesize >> 10, datasize >> 10, rosize >> 10,  
  23.            (init_data_size + init_code_size) >> 10, bss_size >> 10,  
  24.            (physpages - totalram_pages) << (PAGE_SHIFT-10),  
  25. #ifdef  CONFIG_HIGHMEM  
  26.            totalhigh_pages << (PAGE_SHIFT-10),  
  27. #endif  
  28.            str ? ", " : "", str ? str : "");  
  29. kernel_reserve_meminfo.available = nr_free_pages() << (PAGE_SHIFT - 10);  
  30.         kernel_reserve_meminfo.total = physpages << (PAGE_SHIFT - 10);  
  31.         kernel_reserve_meminfo.kernel_code = codesize >> 10;  
  32.         kernel_reserve_meminfo.rwdata = datasize >> 10;  
  33.         kernel_reserve_meminfo.rodata = rosize >> 10;  
  34.         kernel_reserve_meminfo.init = (init_data_size + init_code_size) >> 10;  
  35. kernel_reserve_meminfo.bss = bss_size >> 10;  
  36.         kernel_reserve_meminfo.reserved =  
  37.             (physpages - totalram_pages) << (PAGE_SHIFT-10);  
  38.   
  39. #ifdef CONFIG_HIGHMEM  
  40.         kernel_reserve_meminfo.highmem = totalhigh_pages << (PAGE_SHIFT - 10);  
  41. #endif  
  42. }  
有上面的代码可以看到:

3919424K = nr_free_pages() * 4;

4027408K = get_num_physpages() * 4;

这里的get_num_physpages()是遍历memory node上面所有的page得出的总的内存大小值,具体可以参见代码:

[cpp]  view plain  copy
  1. static inline unsigned long get_num_physpages(void)  
  2. {  
  3.     int nid;  
  4.     unsigned long phys_pages = 0;  
  5.   
  6.     for_each_online_node(nid)  
  7.         phys_pages += node_present_pages(nid);  
  8.   
  9.     return phys_pages;  
  10. }  
那么这里就有一个疑问,既然是遍历所有memory node上的page得出的总的内存大小,那为什么不等于总的实际物理内存4G的大小呢?刚开始在这里也是百思不得其解,最后透过整理整个memory layout发现结论,这里讲一下如何整理整个项目的memory layout。

首先在kernel log中搜索PHY layout,得出如下结果:

[html]  view plain  copy
  1. [    0.000000] <0>-(0)[0:swapper][PHY layout]atf-reserved-memory@44600000   :   0x44600000 - 0x4460ffff (0x10000)  
  2. [    0.000000] <0>-(0)[0:swapper][PHY layout]atf-ramdump-memory@44610000   :   0x44610000 - 0x4463ffff (0x30000)  
  3. [    0.000000] <0>-(0)[0:swapper][PHY layout]cache-dump-memory@44640000   :   0x44640000 - 0x4466ffff (0x30000)  
  4. [    0.000000] <0>-(0)[0:swapper][PHY layout]consys-reserve-memory   :   0xbde00000 - 0xbdffffff (0x200000)  
  5. [    0.000000] <0>-(0)[0:swapper][PHY layout]spm-reserve-memory   :   0xbe180000 - 0xbe195fff (0x16000)  
  6. [    0.000000] <0>-(0)[0:swapper][PHY layout]reserve-memory-scp_share   :   0x8f000000 - 0x8fffffff (0x1000000)  
  7. [    0.000000] <0>-(0)[0:swapper][PHY layout]spi-reserve-memory   :   0xbe160000 - 0xbe175fff (0x16000)  
  8. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0x40000000 - 0x445fffff (0x4600000)  
  9. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0x44670000 - 0x87ffffff (0x43990000)  
  10. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0x88200000 - 0x8effffff (0x6e00000)  
  11. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0x90000000 - 0xb3ffffff (0x24000000)  
  12. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0xbb000000 - 0xbddfffff (0x2e00000)  
  13. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0xbe000000 - 0xbe15ffff (0x160000)  
  14. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0xbe176000 - 0xbe17ffff (0xa000)  
  15. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0xbe196000 - 0xbe19ffff (0xa000)  
  16. [    0.000000] <0>-(0)[0:swapper][PHY layout]kernel   :   0xc0000000 - 0x13fffffff (0x80000000)  
  17. [    0.468130] <4>.(4)[1:swapper/0][PHY layout]tee_reserved_mem   :   0xbff80000 - 0xbffbffff (0x40000)  
  18. [    0.469290] <4>[PHY layout]FB (dt) :  0xbe3a0000 - 0xbff7ffff  (0x1be0000)  
  19. [    1.613119] <4>.(4)[1:swapper/0][PHY layout]ccci_md0 at LK  :  0xb4000000 - 0xbaffffff  (0x7000000)  
  20. [    1.615123] <4>.(4)[1:swapper/0][PHY layout]ccci_share_mem at LK  :  0x88000000 - 0x881fffff  (0x200000)  
将所有的地址按照顺序连接起来,发现少了两块内存,在kernel log中搜索确实内存块的起始地址的地址可以发现是被mblock_reserve所保留(注:在搜索PHY layout中所缺少的memory块都可以通过在kernel log中搜索相应的缺失块的起始地址而找到相应的reserve的块以及用途) ,最后得出memory layout如下:

end0x13fffffffkernelsize: 0x80000000
start0xc0000000
end0xbfffffffmblock reservesize: 0x40000
start0xbffc0000
end0xbffbfffftee_reserved_mem(security)size: 0x40000
start0xbff80000
end0xbff7ffffFrame Buffersize: 0x1be0000
start0xbe3a0000
end0xbe39ffffmblock reservesize: 0x200000
start0xbe1a0000
end0xbe19ffffkernelsize: 0xa000
start0xbe196000
end0xbe195fffspm-reserve-memorysize: 0x16000
start0xbe180000
end0xbe17ffffkernelsize: 0xa000
start0xbe176000
end0xbe175fffspi-reserve-memorysize: 0x16000
start0xbe160000
end0xbe15ffffkernelsize: 0x160000
start0xbe000000
end0xbdffffffconsys-reserve-memory(BT&WIFI)size: 0x200000
start0xbde00000
end0xbddfffffkernelsize: 0x2e00000
start0xbb000000
end0xbaffffffccci_md0(Modem)size: 0x7000000
start0xb4000000
end0xb3ffffffkernelsize: 0x24000000
start0x90000000
end0x8fffffffreserve-memory-scp_sharesize: 0x1000000
start0x8f000000
end0x8effffffkernelsize: 0x6e00000
start0x88200000
end0x881fffffccci_share_mem(Modem)size: 0x200000
start0x88000000
end0x87ffffffkernelsize: 0x43990000
start0x44670000
end0x4466ffffcache-dump-memorysize: 0x30000
start0x44640000
end0x4463ffffatf-ramdump-memory(security)size: 0x30000
start0x44610000
end0x4460ffffatf-reserved-memory(Security)size: 0x10000
start0x44600000
end0x445fffffkernelsize: 0x4600000
start0x40000000

我们用总的内存4G减去所有reserve的内存:

4*1024*1024*1024-(0x10000 + 0x30000 + 0x30000 + 0x200000 + 0x1000000 + 0x7000000 + 0x200000 + 0x16000 + 0x16000 + 0x200000 + 0x1be0000 + 0x40000 + 0x40000) = 4027408K,这回答了文章开头的第一个问题,所以开机get_num_physpages()所获得的总的内存是实际的物理内存减掉kernel所reserve的所有的内存块之后剩余的内存。

第二个问题3919424K,他等于nr_free_pages() * 4,这个值其实就是4027408K减掉kernel此时用于保留reserved(initrd、初始化代码init、内核代码及数据)的数据之后所剩余的内存。即4027408K - (107984K + absent(如果有)) = 3919424K,这个值就是实际开机运行之后所能使用的最大内存,讲到这里就会有一个疑问,在执行cat /proc/meminfo所得到的结果中:

[cpp]  view plain  copy
  1. cat proc/meminfo  
  2. MemTotal:        3922896 kB  
  3. MemFree:         1629172 kB  
  4. MemAvailable:    2602560 kB  
  5. Buffers:           13848 kB  
  6. Cached:           994316 kB  
  7. SwapCached:            0 kB  
此时的MemTotal的值大于3919424K,此时3922896K - 3919424K = 3472K.

那么这里的3472K去了是从哪里回收回来的呢?通过查阅相关资料,发现:

initrd和初始化代码init在引导完成之后会被释放掉,所以最终的可用内存会比dmesg显示的available更多一点,相应的源代码可参见函数:

free_initrd_mem() 和 free_initmem();

查看代码之后再kernel log中搜索Freeing得出如下结论:

[cpp]  view plain  copy
  1. [    2.321286] <4>.(4)[1:swapper/0]Freeing initrd memory: 2340K (ffffffc005000000 - ffffffc005249000)  
  2. [    5.318178] <4>.(4)[1:swapper/0]Freeing unused kernel memory: 1056K (ffffffc0011f9000 - ffffffc001301000)  
  3. [    5.319419] <4>.(4)[1:swapper/0]Freeing alternatives memory: 76K (ffffffc001301000 - ffffffc001314000)  
这里的76K + 1056K + 2340K = 3472K,而3472K + 3919424K = 3922896K,刚好就是meminfo里面的MemTotal的大小。 (注:大多数log开始打出来的可用内存和后面free掉的内存之和相加等于meminfo的MemTotal值,有部分时候这两者之和可能略小于meminfo的MemTotal的值,这是由于log打印问题导致log未完全打印出所有的freeing的memory块(大多数情况如果按照以上方式计算出来的结果如果不等于meminfo的MemTotal可以大胆的怀疑是log未打全),但是meminfo里面统计到了这部分内存)

到这里这几个总的可用内存和实际的物理内存之间的关系算是理清了。

2. 计算Android开机之后kernel消耗的物理内存

通过第一节的介绍我们可以得出在开机之后kernel所reserve的内存计算公式就是:

实际的物理内存 - meminfo的Memtotal值,争对此例就是:

4*1024*1024K - 3922896K = 271408K

而Android开机之后kernel实际消耗的物理内存还得加上kernel stack,slab,shmem,pagetables,vmalloc_used的大小,当然以上的变量大小是变化的。

所以这里仅仅只是值开机之后的kernel消耗的内存大小,而以上各变量之和可以用dumpsys meminfo中的一个值来概括:

[cpp]  view plain  copy
  1. Total RAM: 3,922,896K (status normal)  
  2. Free RAM: 2,290,037K (  129,229K cached pss +   913,696K cached kernel +   999,820K free +    51,584K ion cached +   195,708K gpu cached)  
  3. Used RAM: 1,635,654K (1,184,850K used pss +   366,316K kernel +    40,960K trace buffer +    43,528K ion disp +         0K cma usage)  
  4. Lost RAM:    -2,803K  
  5.      ZRAM:         8K physical used for         0K in swap (1,961,444K total swap)  
  6. Tuning: 192 (large 384), oom   322,560K, restore limit   107,520K (high-end-gfx)  

就是Used RAM中的kernel选项的值,在framework中的定义如下:

[cpp]  view plain  copy
  1. public long getKernelUsedSizeKb() {  
  2.     return mInfos[Debug.MEMINFO_SHMEM] + mInfos[Debug.MEMINFO_SLAB]  
  3.             + mInfos[Debug.MEMINFO_VM_ALLOC_USED] + mInfos[Debug.MEMINFO_PAGE_TABLES]  
  4.             + mInfos[Debug.MEMINFO_KERNEL_STACK];  
  5. }  
这个值在使用当中是不断变化的,只有kernel reserve部分的值是恒定不变的,无论Android使用多长时间, 所以这里特指在Android开机之后的时刻的值:

即4*1024*1024K - 3922896K + 366316K = 637724K

讲到这里基本就搞清楚了开机kernel所消耗内存大小的计算方法。

嵌入式Linux屏与安卓屏选型实战:开机、稳定性、成本对比与踩坑总结 在工业人机交互设备与智能终端的开发中,如何选择合适的显示方案是产品经理和工程师常面临的难题。嵌入式Linux与安卓系统分别代表专用系统与通用系统的两条技术路线,其底层软件栈厚度不同,导致在启动速度、系统稳定性、硬件成本及维护效率上存在显著差异。对于冷启动要求严格、需长时间稳定运行的工业HMI、医疗或车载设备,嵌入式Linux凭借秒级启动和可控性强成为首选;而界面复杂、需频繁更新或依赖生态的场景,安卓屏则更具优势。本文结合真实量产经验,解析两类系统在文件系统掉电保护、进程管理、看门狗策略及BOM成本等方面的差 阅读详情

相关推荐

MTK手机开机慢?带你一步步拆解LK启动流程,从crt0.S到拉起Kernel

本文深入解析MTK手机LK启动流程,从crt0.S汇编初始化到拉起Kernel的全过程,揭示启动慢的关键瓶颈。通过代码级优化策略,如向量表重定位、BSS段清零优化和存储驱动加速,显著提升启动速度。结合MTK平台实测数据,提供从硬件初始化到内核交接的完整优化方案。

weixin_29213525的博客 137

一次看似kernel内存泄漏分析

tmp目录爆满导致的kernel内存过大

qq_27629673的博客 1588

安卓启动性能优化:使用bootchart分析启动瓶颈与优化策略

在嵌入式系统和移动开发领域,系统启动性能是衡量用户体验和产品竞争力的关键指标。启动过程涉及从内核初始化到用户空间服务就绪的复杂时序,传统盲测方法效率低下。性能分析工具通过采集进程CPU、磁盘I/O和时序数据,生成可视化图表,帮助开发者透视启动黑盒。其技术价值在于以极低开销实现无侵入式监控,精准定位如Zygote预加载、服务初始化阻塞等瓶颈。在安卓系统优化场景中,该工具能有效识别CPU密集型任务和磁盘I/O瓶颈,指导并行化初始化、调整服务启动顺序等优化实践。本文聚焦bootchart这一启动分析利器,详解其数

weixin_34090562的博客 617

认识Kernel 内存泄漏

dumpsys meminfo 看到内核内存Used RAM中,kernel达到了800+MB,这就是内存泄漏~[10:53:13]Total PSS by category:[10:53:13]    276,057K: Native[10:53:13]     78,172K: GL mtrack[10:53:13]     63,058K: .dex mmap[10:53:13]     5...

xlnaan的博客 5895

拼多多Android面试题及参考答案

Android 系统采用分层架构设计,从底层到上层依次为Linux 内核层硬件抽象层(HAL)系统运行时库层应用框架层应用层,共五层。位置:Linux 内核层与系统运行时库层之间,是“硬件与系统的隔离层”。核心作用:屏蔽硬件差异,为上层提供统一的硬件访问接口,解决 Android 开源与硬件厂商闭源的矛盾,具体功能如下:硬件能力抽象:将硬件的具体实现(如不同厂商的摄像头芯片、音频芯片)封装为标准化接口(如Camera HALAudio HAL。

大模型大数据攻城狮的专栏 1286

8227掌讯安卓导航开机慢?从动画、自启动到深度睡眠的系统优化指南

安卓车机在低配硬件上常面临开机慢、卡顿问题,根源在于系统启动链路中的动画渲染、第三方自启动抢占资源以及电源管理策略。通过adb禁用系统动画、移除bootanimation、设置深度睡眠快速启动、精简预装应用等固件与系统层调优,可显著缩短冷启动耗时。本文以8227掌讯800x480方案为例,结合实测数据与避坑经验,给出可复制的车机优化路径,适用于车载导航维护与工程调试场景。

weixin_29174385的博客 51

linux iwap虚拟内存,性能优化工具(十)- Android内存分析命令

一、内存指标Item全称含义等价USSUnique Set Size物理内存进程独占的内存PSSProportional Set Size物理内存PSS= USS+ 按比例包含共享库RSSResident Set Size物理内存RSS= USS+ 包含共享库VSSVirtual Set Size虚拟内存VSS= RSS+ 未分配实际物理内存内存的大小关系:VSS >= RSS >= ...

weixin_30290673的博客 843

ENVI水体提取流程实践与问题

ENVI水体提取流程实践与问题 卫片解译中,水体属于比较好判别的一类。有水体指数、阈值法、监督分类等一系列方法进行提取,今天介绍利用水体指数和ENVI提取水体的过程。 1.所用数据 Landsat8卫片1景、ENVI5.3。 2.辐射定标与水陆分离 由于要对卫片进行水体指数的计算,因此需要对数据进行辐射定标以及大气校正的预处理。 辐射定标就是将图像的数字量化值(DN)转化为辐射亮度值或者反射率或者表面温度等物理量的处理过程。在工具栏中搜索Radiometric Correction,点开进行辐射定标。

Soul_taker的博客 4万+

嵌入式Linux屏与安卓屏怎么选?开机、稳定、成本全对比

在嵌入式系统开发中,操作系统选型直接决定产品的性能表现与工程成本。嵌入式Linux与安卓虽然同源,但在系统架构、启动流程、资源开销上差异巨大。理解两者的底层原理,有助于开发者从开机时间、长期稳定性和综合成本等维度做出理性判断。嵌入式Linux凭借精简的启动链路和低硬件需求,适合对响应速度要求高、功能固定的工业控制、医疗仪器等场景;而安卓系统依托完整的服务框架、应用生态和自恢复机制,更适合需要复杂交互、远程运维和频繁升级的智能终端。本文结合真实项目,对两类显示方案进行深度对比,并分享选型中的踩坑记录与排查方法

weixin_34043301的博客 409

跨域问题 - 其他 method 都没有跨域问题,只有delete有跨域的问题

跨域的配置等一切正常,GETPOSTPUTOPTIONS都可以正常访问, 唯独有一个DELETE有跨域的问题, 经过排查发现这个DELETE请求有body, 经过一系列排查, 发现头部有一个不太正常的值是为了避免浏览器的影响, 直接在 postman 中新建一个请求, 竟然也有跨域的问题, 后来把的值改成了请求就可以正常调用了.

galoiszhou的博客 528

【爬虫】Python实现爬取淘宝商品信息(超详细)

项目基于Python的第三方库Selenium模拟浏览器运行、PyQuery解析和操作HTML文档,获取淘宝平台中某类商品的详细信息(商品标题、价格、销量、商铺名称、地区、商品详情页链接、商铺链接等),并基于第三方库openpyxl建立、存储于Excel表格中。# 全局变量count = 1 # 写入Excel商品计数# 启动ChromeDriver服务# 关闭自动测试状态显示 // 会导致浏览器报:请停用开发者模式# 把chrome设为selenium驱动的浏览器代理;# 窗口最大化。

qq_46315152的博客 4万+

Android15、红帽9.6压测refault比MGLRU大幅降低、mysql最大延迟降低1半、安卓15低内存场景app启动最大耗时降低40%—linux内核以文件为单位的file_area内存回收

以文件为单位的新型linux内核内存回收算法:Android15低内存场景启动app最大耗时比MGLRU降低40%+、refault page降低5倍+,红帽9.6 mysql压测refault page比MGLRU降低80%+、最大延迟降低1半

dongzhiyan_hjp 436

【stata基础代码大全 】 可独立完成一篇实证

用stata打开,直接替换自己需要的变量就行,小白友好❗️❗️❗️。八、八.中介效应检验:路径分析(三种方法)第二种方法即Sobel-Goodman检验。*(7)Winsor处理,剔除异常值。六、内生性问题解决方法(附具体模型)其三,工具变量:两阶段最小二乘。第三种方法即Bootstrap检验。二、Stata中数据的基本处理。*(5)生成行业、年度虚拟变量。PSM1————近邻匹配。七、调节效应检验:机制分析。*(2)剔除数据中的样本。*(4)给变量添加标签。*(3)生成新的变量。*(6)基本数据匹配。

J_Giser的博客 8027

嵌入式Linux屏与安卓屏选型对比:从开机时间、稳定性到成本

在工业设备与智能交互终端领域,显示系统的选型直接影响产品体验与长期可靠性。嵌入式Linux与安卓作为两大主流系统方案,其底层架构差异决定了启动速度、运行稳定性与开发维护成本。嵌入式Linux通过精简内核与定制根文件系统,可实现数秒内快速启动,并具备低资源占用和高可靠性;安卓则凭借丰富生态和成熟UI框架,适合复杂交互场景,但系统服务繁重,开机时间与长期稳定性面临挑战。理解两者在系统裁剪、驱动适配、生命周期管理上的原理区别,能够帮助工程师根据实际应用场景(如医疗设备、控制面板、自助终端)做出合理决策。本文基于实

weixin_34319817的博客 307

实战篇(七):使用Processing和PixelFlow库创建交互式流体太极动画

类:用于配置流体运动的参数,比如圆的位置、半径、运动的角度和速度以及颜色等。类:实现了接口,用于更新流体物理仿真的状态,同时整合声音输入作为流体动态变化的一部分。my_update方法:是流体物理仿真更新的核心,它计算流体粒子的速度和位置,并且将这些数据传递给流体库来模拟流动。现在,让我们进一步分析并解释每个部分的作用以及如何操作。float x;// 圆心位置xfloat y;// 圆心位置y// 半径// 是否是顺时针// 圆周运动,弧上的点位置,以及上一帧的点位置// 角度。

帅小柏的博客 1636

2025华为杯第二十二届中国研究生数学建模竞赛E题:高速列车轴承智能故障诊断问题 - 完整解题分析+完整MATLAB源码!

🎓 本文收录于 《滚雪球学数学建模》专栏,本专栏专注于从零基础出发,带你循序渐进掌握数学建模的核心方法与思维路径。通过“滚雪球式”学习法,从最简单的生活化案例到经典建模工具,再到省赛、国赛真题实战演练,逐步积累知识与技能,帮助你搭建完整的建模体系。无论你是刚接触建模的新生,还是希望提升科研与竞赛能力的学者与工程师,本专栏都将为你提供一条清晰、高效、可实操的建模成长路线,助力你快速进阶,突破难点,迈向数学建模竞赛与实际应用的更高峰 🚀!

**My Coding Family** 2002

RK3568 Android 11开机动画优化实战:从资源压缩到源码裁剪

开机动画是Android系统启动路径中最早被用户感知的视觉反馈,但其解码与合成过程会与系统服务抢占CPU、IO和SurfaceFlinger资源,尤其在RK3568这类四核A55平台上,启动阶段资源争抢往往导致整机卡顿。理解BootAnimation的启动时序与SurfaceFlinger合成机制是优化前提,而借助bootchart量化CPU开销、定位瓶颈是关键步骤。在商显、工控、边缘计算等国产化场景中,通过调整动画帧率、分辨率与编码格式可显著降低负载;配合init.rc调度或源码级裁剪,还能进一步让启动资

weixin_34327223的博客 534

RML2018.01a数据集的读取与使用

基于深度学习的自动调制识别

QAQIknow的博客 1万+

Android 性能优化 【总篇:深入浅出】

本篇的主要针对整机性能的一个解读,主要拆解整机性能有哪些小的领域,对应的测试用例是怎么样的,这类问题优化思路是怎么样的。各家厂商针对性能的测试都设计了不同的用例,因此针对性能测试其实是比较五花八门的。我这里凭着经验来总结一下通常都有哪些场景和性能测试相关。

qq_27672101的博客 517

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

嵌入式屏选型核心指标:开机时间、稳定性与隐性成本

嵌入式Linux与安卓系统选型,本质是硬件启动时序、故障收敛机制和工程成本的综合权衡。开机时间并非单纯OS性能问题,而是BootROM执行、eMMC初始化、DDR唤醒等硬件链路的确定性结果;稳定性也不等于‘不死机’,关键在于WDOG硬复位能力、init进程原子性及跨层故障隔离设计;而所谓‘BOM更便宜’常掩盖eMMC兼容性验证、vendor blob依赖、SELinux策略开发等隐性成本。本文聚焦嵌入式屏在工业HMI、医疗监护、车载终端等场景下的真实约束,解析BootROM耗时占比、init进程模型差异、O

weixin_33797791的博客 312

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

车载开机动画定制指南:从系统原理到DIY实战

开机动画是嵌入式系统启动流程中的重要视觉环节,其本质是在系统引导完成后、用户界面完全启动前播放的一段多媒体内容。从技术原理上看,它紧密依赖于显示驱动初始化、帧缓冲区操作以及轻量级图形渲染服务。在车载信息娱乐系统中,一个精心设计的开机动画不仅能提升用户体验和品牌质感,更成为连接底层硬件、系统启动时序与上层应用的关键技术实践点。对于汽车电子爱好者、车载系统开发者而言,深入理解其背后的系统启动流程、资源打包规范与性能调优方法,是掌握嵌入式图形显示与多媒体处理的绝佳切入点。本文聚焦于车载场景,解析如何从零制作一个兼

weixin_33827731的博客 397

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

2GB内存工业终端Android OOM优化实战:从内核到App的完整方案

Android内存管理是移动与嵌入式开发的核心技术,其原理基于Linux内核的虚拟内存机制与Java堆的垃圾回收策略。在低内存设备上,内存分配节奏与回收时机的控制直接决定系统稳定性。通过zRAM压缩、lmkd进程回收策略调优、Bitmap采样与LruCache缓存限制等技术手段,可显著降低OOM发生率。这些方法广泛应用于工业平板、POS机、车载终端等场景。本文以RK芯片2GB内存工业终端为例,系统梳理从内核参数到业务App的内存治理实践,实现连续运行一个月无OOM。

weixin_34175509的博客 210

RAM测评优化方案

1.目的和意义这是评测方法的优化。RAM作为手机运行时所有内容所容纳加载的地方,重要性不言而喻。了解手机在开机后的RAM剩余大小,能够帮助我们清楚手机能加载多大的程序,运载应用的能力有高。Android是一个不断升级演变的系统,新的版本对RAM的需求也越来越多,了解当前系统在正常使用时,系统耗费RAM大小,也能够帮助开发工程师、开发管理者从底至上地清楚系统本身的状态。对于开发或者决策,提供十分必要的

eyelike的专栏 2721

QNX内存分析实战:用pidin mem定位内存泄漏与系统重启

内存管理是嵌入式系统稳定性与性能的核心环节,尤其对于实时操作系统而言,物理内存的分配与回收直接关系到任务能否在限定时间内完成。在QNX这类硬实时系统中,内存不足可能触发看门狗复位或无规律重启,而排查此类问题往往比普通应用崩溃更棘手。系统级内存快照、进程级占用明细、空闲内存水位监控,构成了内存分析的基本手段。通过对比基线数据和增量变化,工程师能够识别持续增长的内存占用特征,从而定位内存泄漏源。在车载智能座舱、工业控制等长期运行的场景中,这一过程尤为关键。QNX自带的pidin mem命令正是面向此类问题的实用

weixin_34342905的博客 321
上一篇: Android8.1 (O1)GTS 失败项
下一篇: Android O 进入SystemUI Keyguard界面下半部分黑屏1s问题
旧时旅人
博客等级 码龄10年 186粉丝 117原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值