This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

MSP432-RTOS: [MSP432P401R] how to extend memory space for malloc() function

Part Number: MSP432-RTOS

Hi,

I tried dynamic memory allocation using malloc(1024 * 24), but failed.

For sure, I reduced its size to 9K bytes and found it is the upper limit as of my project in CCS.

Following is the capture of Memory Allocation view.

Memory Allocation view

Following is the project .cmd file:

--diag_suppress=10199

--retain=flashMailbox

--stack_size=2048   /* C stack is also used for ISR stack */

HEAPSIZE = 0x4000;  /* Size of heap buffer used by HeapMem */

MEMORY
{
    MAIN       (RX) : origin = 0x00000000, length = 0x0003F000
    MYDATA     (RX) : origin = 0x0003F000, length = 0x00001000
    INFO       (RX) : origin = 0x00200000, length = 0x00004000
#ifdef  __TI_COMPILER_VERSION__
#if     __TI_COMPILER_VERSION__ >= 15009000
    ALIAS
    {
    SRAM_CODE  (RWX): origin = 0x01000000
    SRAM_DATA  (RW) : origin = 0x20000000
    } length = 0x00010000
#else
    /* Hint: If the user wants to use ram functions, please observe that SRAM_CODE             */
    /* and SRAM_DATA memory areas are overlapping. You need to take measures to separate       */
    /* data from code in RAM. This is only valid for Compiler version earlier than 15.09.0.STS.*/
    SRAM_CODE  (RWX): origin = 0x01000000, length = 0x00010000
    SRAM_DATA  (RW) : origin = 0x20000000, length = 0x00010000
#endif
#endif
}

/* The following command line options are set as part of the CCS project.    */
/* If you are building using the command line, or for some reason want to    */
/* define them here, you can uncomment and modify these lines as needed.     */
/* If you are using CCS for building, it is probably better to make any such */
/* modifications in your CCS project and leave this file alone.              */
/*                                                                           */
/* A heap size of 1024 bytes is recommended when you plan to use printf()    */
/* for debug output to the console window.                                   */
/*                                                                           */
/* --heap_size=1024                                                          */
/* --stack_size=512                                                          */
/* --library=rtsv7M4_T_le_eabi.lib                                           */

/* Section allocation in memory */

SECTIONS
{
#ifndef gen_crc_table
    .intvecs:   > 0x00000000
    .text   :   > MAIN
    .const  :   > MAIN
    .cinit  :   > MAIN
    .pinit  :   > MAIN
    .init_array   :     > MAIN
    .mydata       : {}  > MYDATA
    .binit        : {}  > MAIN

    /* The following sections show the usage of the INFO flash memory        */
    /* INFO flash memory is intended to be used for the following            */
    /* device specific purposes:                                             */
    /* Flash mailbox for device security operations                          */
    .flashMailbox : > 0x00200000
    /* TLV table for device identification and characterization              */
    .tlvTable     : > 0x00201000
    /* BSL area for device bootstrap loader                                  */
    .bslArea      : > 0x00202000
#else
    .intvecs:   > 0x00000000, crc_table(crc_table_for_intvecs)
    .text   :   > MAIN, crc_table(crc_table_for_text)
    .const  :   > MAIN, crc_table(crc_table_for_const)
    .cinit  :   > MAIN, crc_table(crc_table_for_cinit)
    .pinit  :   > MAIN, crc_table(crc_table_for_pinit)
    .init_array   :     > MAIN, crc_table(crc_table_for_init_array)
    .mydata       : {}  > MYDATA, crc_table(crc_table_for_init_array)
    .binit        : {}  > MAIN, crc_table(crc_table_for_binit)

    /* The following sections show the usage of the INFO flash memory        */
    /* INFO flash memory is intended to be used for the following            */
    /* device specific purposes:                                             */
    /* Flash mailbox for device security operations                          */
    .flashMailbox : > 0x00200000, crc_table(crc_table_for_flashMailbox)
    /* TLV table for device identification and characterization              */
    /* This one is read only memory in flash - generate no CRC               */
    .tlvTable     : > 0x00201000
    /* BSL area for device bootstrap loader                                  */
    .bslArea      : > 0x00202000, crc_table(crc_table_for_bslArea)
    .TI.crctab    : > MAIN
#endif

    .vtable :   > 0x20000000
    .data   :   > SRAM_DATA
    .bss    :   > SRAM_DATA
    .sysmem :   > SRAM_DATA

    /* Heap buffer used by HeapMem */
    .priheap   : {
        __primary_heap_start__ = .;
        . += HEAPSIZE;
        __primary_heap_end__ = .;
    } > SRAM_DATA align 8

    .stack  :   > SRAM_DATA (HIGH)

#ifdef  __TI_COMPILER_VERSION__
#if     __TI_COMPILER_VERSION__ >= 15009000
    .TI.ramfunc : {} load=MAIN, run=SRAM_CODE, table(BINIT)
#endif
#endif
}

/* Symbolic definition of the WDTCTL register for RTS */
WDTCTL_SYM = 0x4000480C;

Kindly advise me how to modify my cmd file to make 24K bytes memory allocated dynamically successfully.

Appreciated any tips and advises in advance.

HaeSeung   

  • Hi HaeSeung

    It seems you don' t have enough SRAM area to be used for 24k bytes. Recommend to reduce global variable and use local variable instead that can save some SRAM area.

  • Hi Gary,


    I reduced about 3K bytes with my application, following your advice.

    But, It is not enough.  So, to make malloc() function test simple, I import uartecho TIRTOS CCS project, put malloc() function here and test if there is any way to change the location of dynamic memory allocation from  SRAM area to MAIN area ?

    MAIN area seems like having enough memory for 24K bytes allocation.

    I change .sysmem defined in SECTIONS area in linker .cmd file as follows, but it DOES NOT work:

        SECTIONS
        {
        .text : > MAIN
        .TI.ramfunc : {} load=MAIN, run=SRAM_CODE, table(BINIT)
        .const : > MAIN
        .cinit : > MAIN
        .pinit : > MAIN
        .init_array : > MAIN
        .sysmem : > MAIN

        .data : > SRAM_DATA
        .bss : > SRAM_DATA
       /* .sysmem : > SRAM_DATA */

    Is there any way to change dynamic memory allocation area to MAIN area from SRAM ?

    Many thanks in advance,

    HaeSeung

  • I can give the comments below 

    1. Try to use high level code size optimization in CCS or IAR

    2. For CCS use the release version instead of debug version to verify the code size

    3. More tips you can refer to this 

    https://stackoverflow.com/questions/5685454/how-to-optimize-or-reduce-ram-size-in-embedded-system-software