RTOS/AM5728: The speed of hepbuf is more slow than memory

user4652979

Part Number: AM5728

Tool/software: TI-RTOS

I have write a function to test the speed of memory and hepbuf. The heapbuf's speed to alloc memory is faster than memory, but the heapbuf's assignment speed is more slow than memory. Is there some mistakes?

Following is the test result:

....................

cpu performance test:memory
BIOS cpu freq: 1176000000 Hz
Timestamp freq: 1176000000 Hz
rtn=100,loop=100,time=1676 us.[from 109833022 to 111804625clks]
....................

cpu performance test:heapbuf alloc
BIOS cpu freq: 1176000000 Hz
Timestamp freq: 1176000000 Hz
rtn=100,loop=100,time=381 us.[from 133030120 to 133478566clks]
....................

cpu performance test:memory calculate
BIOS cpu freq: 1176000000 Hz
Timestamp freq: 1176000000 Hz
rtn=10250000,loop=10000,time=168643 us.[from 175988237 to 374313319clks]
cclock_start=2300,clock_stop=2400,clock_per_second=100,time=1 s.
....................

cpu performance test:heapbuf calculate
BIOS cpu freq: 1176000000 Hz
Timestamp freq: 1176000000 Hz
rtn=10000,loop=10000,time=1515941 us.[from 422841607 to 2205588507clks]
cclock_start=2400,clock_stop=7200,clock_per_second=100,time=48 s.

Here is the code:

//MEMORY ALLOC
int cpu_memoryalloc_benchmark_test_group(void)
{
    xdc_runtime_Types_FreqHz time_freq,bios_freq;
    Timestamp_getFreq(&time_freq);
    BIOS_getCpuFreq(&bios_freq);

    appPrint("\n....................\n");
    appPrint("\ncpu performance test:memory");
    appPrint("\nBIOS cpu freq: %u Hz",bios_freq.lo);
    appPrint("\nTimestamp freq: %u Hz",time_freq.lo);

    Uint32 timer_0;
    Uint32 timer_1;
    Uint32 timer_us;
    int ret=0;
    int loop = 100;
    timer_0 = Timestamp_get32();
    ret = cpu_memoryalloc_benchmark(loop);
    timer_1 = Timestamp_get32();
    timer_us = (timer_1-timer_0)/(time_freq.lo/1000000);
    appPrint("\nrtn=%d,loop=%d,time=%u us.[from %u to %uclks]",ret,loop,timer_us,timer_0,timer_1);
    return timer_us;
}

int cpu_memoryalloc_benchmark(int loop)
{
    int ret = 0;
    unsigned char *address = 0;
    for(int i=0;i<loop;i++)
    {
        address=malloc(1024*1024*1);
        if(address == 0)
        {
            ret = -1;
            return ret;
        }
        else
        {
            ret+=1;
            free(address);
        }
    }
    return ret;
}
//20190131 heapbuf—_alloc
int cpu_heapbufalloc_benchmark_test_group(void)
{
    xdc_runtime_Types_FreqHz time_freq,bios_freq;
    Timestamp_getFreq(&time_freq);
    BIOS_getCpuFreq(&bios_freq);

    appPrint("\n....................\n");
    appPrint("\ncpu performance test:heapbuf alloc");
    appPrint("\nBIOS cpu freq: %u Hz",bios_freq.lo);
    appPrint("\nTimestamp freq: %u Hz",time_freq.lo);

    Uint32 timer_0;
    Uint32 timer_1;
    Uint32 timer_us;
    int ret=0;
    int loop = 100;
    timer_0 = Timestamp_get32();
    ret = cpu_heapbufalloc_benchmark(loop);
    timer_1 = Timestamp_get32();
    timer_us = (timer_1-timer_0)/(time_freq.lo/1000000);
    appPrint("\nrtn=%d,loop=%d,time=%u us.[from %u to %uclks]",ret,loop,timer_us,timer_0,timer_1);
    return timer_us;
}
int cpu_heapbufalloc_benchmark(int loop)
{
    int ret = 0;
    unsigned char *address = 0;
    for(int i=0;i<loop;i++)
    {
        //address=malloc(1024*1024*1);

        address=Memory_alloc(otherHeap,1024*1024*1,0,NULL);
        if(address == 0)
        {
            ret = -1;
            return ret;
        }
        else
        {
            ret+=1;
            //free(address);
            Memory_free(otherHeap,address,1024*1024*1);

        }
    }
    return ret;
}
//20190213 memory--calculate
int cpu_memorycalculate_benchmark_test_group(void)
{
    xdc_runtime_Types_FreqHz time_freq,bios_freq;
    Timestamp_getFreq(&time_freq);
    BIOS_getCpuFreq(&bios_freq);

    appPrint("\n....................\n");
    appPrint("\ncpu performance test:memory calculate");
    appPrint("\nBIOS cpu freq: %u Hz",bios_freq.lo);
    appPrint("\nTimestamp freq: %u Hz",time_freq.lo);

    Uint32 timer_0;
    Uint32 timer_1;
    Uint32 timer_us;
    int ret=0;
    int loop = 10000;
    clock_t clock_start = clock();
    timer_0 = Timestamp_get32();
    ret = cpu_memory_calculate_benchmark(loop);
    timer_1 = Timestamp_get32();
    timer_us = (timer_1-timer_0)/(time_freq.lo/1000000);
    clock_t clock_stop = clock();
    appPrint("\nrtn=%d,loop=%d,time=%u us.[from %u to %uclks]",ret,loop,timer_us,timer_0,timer_1);
    appPrint("\ncclock_start=%d,clock_stop=%d,clock_per_second=%d,time=%u s.",clock_start,clock_stop,CLOCKS_PER_SEC,((clock_stop-clock_start)/CLOCKS_PER_SEC));
    return timer_us;
}
int cpu_memory_calculate_benchmark(int loop)
{
    int ret = 0;
    unsigned char *address = 0;
    for(int i=0;i<loop;i++)
    {
        address=malloc(1024*1024*1);

        //address=Memory_alloc(otherHeap,1024*1024*1,0,NULL);
        if(address == 0)
        {
            ret = -1;
            return ret;
        }
        else
        {
            memset(address,0,1024*1024*1);
            for(int m=0;m<1024;m++)
            {
                for(int j=0;j<1024;j++)
                {
                        address[m*1024+j]=255;
                }
                ret+=1;
            }
            ret+=1;
            free(address);
            //Memory_free(otherHeap,address,1024*1024*1);

        }
    }
    return ret;
}

//20190213 heapbuf—_calculate
int cpu_heapbufcalculate_benchmark_test_group(void)
{
    xdc_runtime_Types_FreqHz time_freq,bios_freq;
    Timestamp_getFreq(&time_freq);
    BIOS_getCpuFreq(&bios_freq);

    appPrint("\n....................\n");
    appPrint("\ncpu performance test:heapbuf calculate");
    appPrint("\nBIOS cpu freq: %u Hz",bios_freq.lo);
    appPrint("\nTimestamp freq: %u Hz",time_freq.lo);

    Uint32 timer_0;
    Uint32 timer_1;
    Uint32 timer_us;
    int ret=0;
    int loop = 10000;
    clock_t clock_start = clock();
    timer_0 = Timestamp_get32();
    ret = cpu_heapbuf_calculate_benchmark(loop);
    timer_1 = Timestamp_get32();
    timer_us = (timer_1-timer_0)/(time_freq.lo/1000000);
    clock_t clock_stop = clock();
    appPrint("\nrtn=%d,loop=%d,time=%u us.[from %u to %uclks]",ret,loop,timer_us,timer_0,timer_1);
    appPrint("\ncclock_start=%d,clock_stop=%d,clock_per_second=%d,time=%u s.",clock_start,clock_stop,CLOCKS_PER_SEC,((clock_stop-clock_start)/CLOCKS_PER_SEC));
    return timer_us;
}
int cpu_heapbuf_calculate_benchmark(int loop)
{
    int ret = 0;
    unsigned char *address = 0;
    for(int i=0;i<loop;i++)
    {
        //address=malloc(1024*1024*1);

        address=Memory_alloc(otherHeap,1024*1024*1,0,NULL);
        if(address == 0)
        {
            ret = -1;
            return ret;
        }
        else
        {
            memset(address,0,1024*1024*1);
            for(int m=0;m<1024;m++)
            {
                for(int j=0;j<1024;j++)
                {
                    address[m*1024+j]=255;
                }
            }
            ret+=1;
            //free(address);
            Memory_free(otherHeap,address,1024*1024*1);

        }
    }
    return ret;
}

over 6 years ago

0 ToddMullanix over 6 years ago

TI__Guru* 96960 points

Hi,

This looks like more of a clock() issue. The Timestamp module confirms both times the Memory_alloc call was faster than the malloc. Note: I'm assuming "otherHeap" is the system heap. For SYS/BIOS, malloc basically does a Memory_alloc from the default system heap (plus some book-keeping to store the size of the malloc request in the header "before" the block of memory that is returned).

What compiler and version are you using?

Todd

0 user4652979 over 6 years ago in reply to ToddMullanix

Expert 1860 points

The timestamp show the time for memory calculate is 168643 us and for heapbuf is 1515941 us. So, the speed of heapbuf calculate is more slow than memory. The default system heap is Bios.heap which is a memory and "otherHeap" is a heapbuf which I created. Is there some mistakes in my test code?

0 user4652979 over 6 years ago in reply to user4652979

Expert 1860 points

My compiler is GNU v7.2.1(Linaro).

0 ToddMullanix over 6 years ago in reply to user4652979

TI__Guru* 96960 points

Sorry, I missed the extra digit. There is no reason why the Memory_alloc would be slower than the malloc. Can you confirm the "otherHeap" is the default heap....or just run the test with Memory_alloc(NULL,...)?

Todd

0 user4652979 over 6 years ago in reply to ToddMullanix

Expert 1860 points

Thanks for your reply.
Maybe I didn't explain the problem clearly. It's not a different between Memory_alloc() and malloc(). It's the different between memory and heapbuf. The speed of alloc from memory is more slower than hepbuf. But, if you add the callulate and assignment cedes, the speed of heapbuf is more slower than memory.

0 user4652979 over 6 years ago in reply to ToddMullanix

Expert 1860 points

The malloc() function alloc memory space from the BIOS.heap. The otherHeap is another heapbuf which I created and I use the Memory_alloc() to alloc memory space from otherHeap which isn't the BIOS.heap.

0 ToddMullanix over 6 years ago in reply to user4652979

TI__Guru* 96960 points

I don't think it a fair comparison then. Do both heaps have their memory in the same memory area (e.g. internal RAM vs external RAM), what are the cache settings, etc.

Try doing the comparison on the same heap with Memory_alloc and malloc. I expect this will show that Memory_alloc is slightly faster.

0 ToddMullanix over 6 years ago in reply to ToddMullanix

TI__Guru* 96960 points

Did this get resolved?

Todd

[2/20 Update: Marking this as TI Thinks Resolved due to no response from original poster.]

0 user4652979 over 6 years ago in reply to ToddMullanix

Expert 1860 points

yes, there is a mistake in the test program.

Processors

Processors forum

RTOS/AM5728: The speed of hepbuf is more slow than memory