PSRAM 开了为什么还是内存不足？分别看堆、DMA 和碎片

# POSIX shell · 配合本节前提逐项执行
export LAB_PROJECT="$PWD"
export LAB_BUILD="$HOME/esp32-labs/r03-safe"
python "$IDF_PATH/tools/idf.py" -C "$LAB_PROJECT" -B "$LAB_BUILD" -D SDKCONFIG="$LAB_BUILD/sdkconfig" build
# 确认板型、串口和备份后才自行执行；本文没有执行烧录。
python "$IDF_PATH/tools/idf.py" -C "$LAB_PROJECT" -B "$LAB_BUILD" -p YOUR_SERIAL_PORT flash monitor

# POSIX shell · 配合本节前提逐项执行
export LAB_QEMU_BUILD="$HOME/esp32-labs/r03-qemu"
python "$IDF_PATH/tools/idf.py" -C "$LAB_PROJECT" -B "$LAB_QEMU_BUILD" -D SDKCONFIG="$LAB_QEMU_BUILD/sdkconfig" -D 'SDKCONFIG_DEFAULTS=sdkconfig.defaults;config/qemu.defaults' build
# 通过本版官方工具清单选择对应OS/CPU的QEMU；不安装另一套SDK。
python "$IDF_PATH/tools/idf_tools.py" install qemu-xtensa
. "$IDF_PATH/export.sh"
python host/run_qemu.py --build "$LAB_QEMU_BUILD" --log /tmp/r03-qemu.log --timeout 90

# POSIX shell · 配合本节前提逐项执行
cc -std=c11 -Wall -Wextra -Werror -Imain host/heap_test.c -o /tmp/r03-test
/tmp/r03-test
cc -std=c11 -Wall -Wextra -Werror -Imain host/classify.c -o /tmp/r03-classifier
python host/check_csv.py --classifier /tmp/r03-classifier
python tools/analyse_heap.py --csv heap-snapshots.csv --classifier /tmp/r03-classifier

// ---- main/main.c ----
/* SPDX-License-Identifier: MIT */
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "esp_heap_caps.h"
#include "esp_psram.h"
#include "esp_memory_utils.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "mem_model.h"
#include "pool_probe.h"
static void snapshot(const char *name,uint32_t caps) {
 multi_heap_info_t i;heap_caps_get_info(&i,caps);size_t total=heap_caps_get_total_size(caps);
 printf("HEAP name=%s t_us=%"PRId64" caps=%"PRIu32" total=%zu free=%zu largest=%zu min_sum=%zu request=4096 class=%d\n",name,esp_timer_get_time(),caps,total,i.total_free_bytes,i.largest_free_block,i.minimum_free_bytes,mem_classify(total,i.total_free_bytes,i.largest_free_block,4096));
}
static void snapshots(void){snapshot("internal8",MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);snapshot("external8",MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);snapshot("internal_dma8",MALLOC_CAP_INTERNAL|MALLOC_CAP_DMA|MALLOC_CAP_8BIT);snapshot("external_dma8",MALLOC_CAP_SPIRAM|MALLOC_CAP_DMA|MALLOC_CAP_8BIT);snapshot("general8",MALLOC_CAP_8BIT);}
#if CONFIG_HX_POOL_SELFTEST
void app_main(void) {
 void *arena=heap_caps_malloc(65536,MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT);
 if(!arena){puts("R03_POOL_TEST_COMPLETE failures=1 allocation");return;}
 PoolResult r=pool_probe(arena,65536);heap_caps_free(arena);
 unsigned fail=!(r.blocks>4 && r.free_bytes>=4096 && r.largest<4096 && r.failed4096 && r.coalesced);
 printf("R03_POOL_TEST_COMPLETE failures=%u; actual32-bit SDK allocator, no PSRAM or peripheral test\n",fail);
}
#else
void app_main(void) {
 printf("R03 physical PSRAM reported_bytes=%zu; require8388608 for this N8R8 lab; no measured values supplied in article\n",esp_psram_get_size());
 snapshots(); if(esp_psram_get_size()!=8388608) { puts("PSRAM_SCOPE_MISMATCH; stop pool experiment");return; }
 puts("Commands: snapshot / pool. Default only metadata, no stress loop. Caps overlap: DO NOT SUM rows.");char line[40];
 for(;;) {
  if(!fgets(line,sizeof line,stdin)){clearerr(stdin);vTaskDelay(pdMS_TO_TICKS(20));continue;}
  line[strcspn(line,"\r\n")]=0;
  if(!strcmp(line,"snapshot"))snapshots();
  else if(!strcmp(line,"pool")) {
   void *dma=heap_caps_malloc(256,MALLOC_CAP_INTERNAL|MALLOC_CAP_DMA|MALLOC_CAP_8BIT);
   if(dma){printf("DMA pointer internal_capable=%u ext_dma_region=%u; peripheral contract/alignment still required\n",esp_ptr_dma_capable(dma),esp_ptr_dma_ext_capable(dma));heap_caps_free(dma);}else puts("DMA_256_ALLOC_FAILED");
   void *extdma=heap_caps_aligned_alloc(64,256,MALLOC_CAP_SPIRAM|MALLOC_CAP_DMA|MALLOC_CAP_8BIT);
   if(extdma){printf("EXTERNAL_DMA region=%u; no DMA transfer/descriptors tested\n",esp_ptr_dma_ext_capable(extdma));heap_caps_free(extdma);}else puts("EXTERNAL_DMA_256_UNAVAILABLE");
   void *arena=heap_caps_malloc(65536,MALLOC_CAP_SPIRAM|MALLOC_CAP_8BIT);
   if(!arena){puts("EXTERNAL_ARENA_ALLOC_FAILED: keep before/after snapshots");snapshots();continue;}
   printf("ARENA external=%u; private pool not global capability registration\n",esp_ptr_external_ram(arena));pool_probe(arena,65536);heap_caps_free(arena);snapshots();
  } else puts("UNKNOWN_COMMAND; no allocation");
 }
}

#endif

// ---- main/mem_model.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdint.h>
typedef enum { INVALID_SNAPSHOT, NO_CAPABILITY, TOTAL_PRESSURE, CONTIGUOUS_LIMIT, FITS_SNAPSHOT } MemState;
static inline MemState mem_classify(uint64_t total,uint64_t free_bytes,uint64_t largest,uint64_t request) {
 if(!request || largest>free_bytes || free_bytes>total) return INVALID_SNAPSHOT;
 if(!total) return NO_CAPABILITY;
 if(free_bytes<request) return TOTAL_PRESSURE;
 if(largest<request) return CONTIGUOUS_LIMIT;
 return FITS_SNAPSHOT; /* Not a reservation; metadata/alignment/concurrent users still matter. */
}

// ---- main/pool_probe.h ----
/* SPDX-License-Identifier: MIT */
#pragma once
#include <stdio.h>
#include <stdbool.h>
#include "multi_heap.h"
#include "mem_model.h"
typedef struct { size_t free_bytes,largest; bool failed4096,coalesced; unsigned blocks; } PoolResult;
/* Private allocator only; NEVER heap_caps_add_region over an existing allocation. */
static inline PoolResult pool_probe(void *arena,size_t bytes) {
 PoolResult r={0}; multi_heap_handle_t pool=multi_heap_register(arena,bytes); if(!pool)return r;
 void *blocks[64]={0};
 for(unsigned i=0;i<64;i++) { blocks[i]=multi_heap_malloc(pool,2048); if(!blocks[i])break; r.blocks++; }
 for(unsigned i=0;i<r.blocks;i+=2) { multi_heap_free(pool,blocks[i]); blocks[i]=NULL; }
 multi_heap_info_t info; multi_heap_get_info(pool,&info);r.free_bytes=info.total_free_bytes;r.largest=info.largest_free_block;
 void *trial=multi_heap_malloc(pool,4096);r.failed4096=trial==NULL;
 if(trial)multi_heap_free(pool,trial);
 for(unsigned i=0;i<r.blocks;i++)if(blocks[i])multi_heap_free(pool,blocks[i]);
 trial=multi_heap_malloc(pool,4096);r.coalesced=trial!=NULL;if(trial)multi_heap_free(pool,trial);
 printf("PRIVATE_POOL bytes=%zu blocks=%u free=%zu largest=%zu class=%d request4096_failed=%u after_free4096_ok=%u integrity=%u\n",bytes,r.blocks,r.free_bytes,r.largest,mem_classify(bytes,r.free_bytes,r.largest,4096),r.failed4096,r.coalesced,multi_heap_check(pool,false));
 return r;
}