What's the maximum RAM size on STM32H743VITx?

jarofmolasses · October 4, 2024, 1:08am

https://docs.platformio.org/en/latest/boards/ststm32/weact_mini_h743vitx.html

Currently Platformio says the RAM size for the STM32H743VITx is 512KB, but that should be 1024KB, right?

https://www.digikey.com/en/products/detail/stmicroelectronics/STM32H743VIT6/7809237

maxgerhardt · October 4, 2024, 11:19am

Sadly this is more complicated.

stm32duino/Arduino_Core_STM32/blob/822d249b7cf35daa0c9196be764d164e05a16a99/variants/STM32H7xx/H742V(G-I)(H-T)_H743V(G-I)(H-T)_H750VBT_H753VI(H-T)/ldscript.ld#L44-L53


      
          /* Specify the memory areas */
          MEMORY
          {
            FLASH (rx)     : ORIGIN = 0x08000000, LENGTH = 2048K
            RAM (xrw)      : ORIGIN = 0x20000000, LENGTH = 128K
            RAM_D1 (xrw)   : ORIGIN = 0x24000000, LENGTH = 512K
            RAM_D2 (xrw)   : ORIGIN = 0x30000000, LENGTH = 288K
            RAM_D3 (xrw)   : ORIGIN = 0x38000000, LENGTH = 64K
            ITCMRAM (xrw)  : ORIGIN = 0x00000000, LENGTH = 64K
          }

This microcontroller physically has the 1MB of RAM, but the memory address space is fragmented, and some RAM can only be accessed by certain parts of the microcontroller or processor.

So e.g., the RAM starting at 0x20000000 with length of 128K has an address range of

RAM 0x20000000 to 0x20020000

Which is discontinuous with where the next block of RAM starts, that is, 0x24000000.

So, what the Arduino framework here does (and other projects similiarly), is that it points the “main chunk of RAM” to the biggest block, which is the D1 512K SRAM block. (more about that in the product manual). Specifically, the ARM Cortex processor wants to know where the stack starts. Typically, the initial stack pointer is setup at “the end of RAM”, but since it’s discontinious here, we must narrow the view to the “end of the biggest block of RAM”.

Some frameworks would like to know, as a variable, what the start address and the length of the RAM. Then they compute the initial SP as “the end of RAM” as START(RAM) + LENGTH(RAM). If PlatformIO would say “start of RAM is 0x20000000 and length is 1 MB”, the resulting address would be 0x20100000 – no memory is mapped there, the processor would instantly crash when trying to do anything with the stack.

And thus, the PlatformIO board info in this special case says "we only have 512K of RAM and it starts at 0x24000000.

Physically, your microcontroller still has 1MByte of RAM. You just have to be a little bit fancy on how to put objects into these different RAM regions, e.g., allocating a heap on the RAM_D2 part, etc. Not sure if the Arduino framework even implements this or leaves it as “it has 512K of RAM.”

maxgerhardt · October 4, 2024, 11:26am

Actually, we discussed a very similiar case in here.

github.com/platformio/platformio-core

PlatformIO is architecturally wrong about RAM

opened 10:56PM - 21 Sep 21 UTC

maxgerhardt

feature build system

### Configuration **Operating system**: Win 10 x64 **PlatformIO Version** …(`platformio --version`): 5.2.1b2 ### Description of problem As outlined in https://github.com/platformio/platform-ststm32/issues/537 and recently in https://github.com/platformio/platform-ststm32/issues/563, PlatformIO has a **real** problem when it comes to microcontrollers that have multiple banks of RAM which live in non-continuous sections of the memory map. The board files do not describe all the RAM section a microcontroller has actually, but accumulate the number in `upload.maximum_ram_size`. This is fatal and has lead to the bugs shown above -- linker scripts using this value and assuming they can do things like [setting the initial SP to the end of RAM](https://github.com/stm32duino/Arduino_Core_STM32/blob/6dec3b655fda17ba0f33cf12cef16b64d0333abd/variants/STM32F4xx/F427Z%28G-I%29T_F429ZET_F429Z%28G-I%29%28T-Y%29_F437Z%28G-I%29T_F439Z%28G-I%29%28T-Y%29%2Fldscript.ld#L31-L43) with end of RAM being RAM start address + RAM length lead to an immediate crash, since the "end of RAM" is not necessarily at that address when the RAM is not organized in a perfectly linear, contiguous way. Further, since the PlatformIO core only understand a singular "maximum RAM size" value, it does not understand (and thus e.g. display) the usage of the distinct RAM sections. For example, for a Nucleo-H723ZG, which has ```ld MEMORY { ITCMRAM (xrw) : ORIGIN = 0x00000000, LENGTH = 64K RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K FLASH (rx) : ORIGIN = 0x08000000, LENGTH = 1024K RAM_D1 (xrw) : ORIGIN = 0x24000000, LENGTH = 320K RAM_D2 (xrw) : ORIGIN = 0x30000000, LENGTH = 32K RAM_D3 (xrw) : ORIGIN = 0x38000000, LENGTH = 16K } ``` all PlatformIO can display is ``` RAM: [ ] 4.6% (used 20336 bytes from 442368 bytes) Flash: [ ] 2.1% (used 21772 bytes from 1048576 bytes) ``` when more informatively, it should be doing something like ``` ITCRAM: [ ] 0.0% (used 0 bytes from 65535 bytes) RAM: [ ] 4.6% (used 20336 bytes from 131072 bytes) RAM_D1: [ ] 0.0% (used 0 bytes from 327680 bytes) RAM_D2: [ ] 0.0% (used 0 bytes from 32768 bytes) RAM_D3: [ ] 0.0% (used 0 bytes from 16384 bytes) Flash: [ ] 2.1% (used 21772 bytes from 16384 bytes) ``` The previous fixes regarding this like https://github.com/platformio/platform-ststm32/commit/38e325b59c165c954f6f69c70e0299d36f3b9225 are bandaids to the underlying problem: By pretending boards have less RAM than they actually have (to make the linkerscripts work), one may be able to construct a firmware that **links** through GCC but PlatformIO will end with an error message after it itself [checks the firmware size](https://github.com/platformio/platformio-core/blob/develop/platformio/builder/tools/piosize.py). The PlatformIO core and associated platforms should be improved to have a better understanding of different RAM sections of a microcontroller, so that PlatformIO can display RAM usage of these different sections. This would also improve the static memory usage analyzer. And enable builder scripts (e.g. Arduino, CMSIS) to explicitly select the correct RAM size value expected for a framework. #### Steps to Reproduce Build and inspect projects that use multiple RAM sections like https://github.com/maxgerhardt/pio-stm32h7-stm32cube-freertos/ ### Actual Results Actual RAM + Flash usage output as seen above ### Expected Results Expected RAM + Flash usage outpu as seen above ### If problems with PlatformIO Build System: N/A ### Additional info None