mem.c

/*
==4KB==
        memset L1/L2        1.8[usec],     2230.9[MB/s]
           memset L2        1.9[usec],     2198.6[MB/s]
           memset L1        5.9[usec],      696.6[MB/s]
     memset wo cache       19.9[usec],      206.2[MB/s]
            flush wb       10.1[usec],      406.2[MB/s]
          flush4k wb        8.9[usec],      459.9[MB/s]
         flush empty        4.1[usec],      990.8[MB/s]
       flush4k empty        3.2[usec],     1270.1[MB/s]
      invalidate wb?        4.8[usec],      858.2[MB/s]
    invalidate empty        4.5[usec],      907.2[MB/s]
      flush L1 empty        3.1[usec],     1333.3[MB/s]
      flush L2 empty        3.3[usec],     1242.3[MB/s]
  flush L1->L2 empty        6.3[usec],      651.4[MB/s]
     flush entire wb      197.6[usec],       20.7[MB/s]
  flush entire empty      196.3[usec],       20.9[MB/s]
==256KB==
        memset L1/L2       98.5[usec],     2660.3[MB/s]
           memset L2       98.7[usec],     2656.6[MB/s]
           memset L1      388.8[usec],      674.3[MB/s]
     memset wo cache     1229.5[usec],      213.2[MB/s]
            flush wb      614.9[usec],      426.3[MB/s]
          flush4k wb      553.7[usec],      473.4[MB/s]
         flush empty      246.1[usec],     1065.4[MB/s]
       flush4k empty      198.2[usec],     1322.5[MB/s]
      invalidate wb?      258.8[usec],     1012.9[MB/s]
    invalidate empty      258.5[usec],     1014.1[MB/s]
      flush L1 empty      184.5[usec],     1420.7[MB/s]
      flush L2 empty      196.8[usec],     1331.8[MB/s]
  flush L1->L2 empty      381.3[usec],      687.6[MB/s]
     flush entire wb      270.3[usec],      969.7[MB/s]
  flush entire empty      196.3[usec],     1335.2[MB/s]
==4MB==
        memset L1/L2     1916.9[usec],     2188.0[MB/s]
           memset L2     1923.6[usec],     2180.5[MB/s]
           memset L1     6225.7[usec],      673.7[MB/s]
     memset wo cache    19661.5[usec],      213.3[MB/s]
            flush wb     4497.7[usec],      932.5[MB/s]
          flush4k wb     3876.0[usec],     1082.1[MB/s]
         flush empty     3759.6[usec],     1115.6[MB/s]
       flush4k empty     3169.0[usec],     1323.6[MB/s]
      invalidate wb?     4129.5[usec],     1015.7[MB/s]
    invalidate empty     4129.4[usec],     1015.7[MB/s]
      flush L1 empty     2949.4[usec],     1422.1[MB/s]
      flush L2 empty     3146.0[usec],     1333.2[MB/s]
  flush L1->L2 empty     6095.3[usec],      688.1[MB/s]
     flush entire wb      374.4[usec],    11201.7[MB/s]
  flush entire empty      196.3[usec],    21362.0[MB/s]
 */

#include <stdio.h>
#include "platform.h"
#include "xil_printf.h"
#include "xil_cache_l.h"
#include "xil_cache.h"
#include "sleep.h"
#include "xtime_l.h"
#include "xreg_cortexa9.h"
#include "xpseudo_asm.h"


#define SIZE (1024*1024*4)

char buffer[SIZE];

static void
show(const char *tag, unsigned long long dt, int size)
{
    double sec = dt/(double)COUNTS_PER_SECOND;
    double bps = size / sec;

    printf("%20s %10.1f[usec], %10.1f[MB/s]\n",
           tag, sec*1000000, bps/(1000*1000));
}

static void
flush_4k(unsigned char *ptr)
{
    int line_size = 32;
    int num_line_per_iter = 1;
    int nloop = (4096/line_size) / num_line_per_iter;
    int li;
    volatile uint32_t *l2_clean_pa = (volatile uint32_t*)0xF8F027B0;

    for (li=0; li<nloop; li++) {
        __asm__ __volatile__("mcr p15, 0, %0, c7, c14, 1\n\t" :: "r" (ptr+line_size*0));
        *l2_clean_pa = ptr+line_size*0;
        ptr += num_line_per_iter * 32;
    }

    volatile uint32_t *sync = (volatile uint32_t*)0xf8f02730;
    *sync = 0;
}

static void
flush_large(unsigned char *ptr, int size)
{
    int si;
    for (si=0; si<size; si+=4096) {
        flush_4k(ptr);
        ptr += 4096;
    }
}

int test(int size)
{
    unsigned long long t0, t1;

    Xil_DCacheEnable();
    XTime_GetTime(&t0);
    memset(buffer, 0, size);
    XTime_GetTime(&t1);
    show("memset L1/L2", t1-t0, size);

    Xil_L1DCacheDisable();
    XTime_GetTime(&t0);
    memset(buffer, 0, size);
    XTime_GetTime(&t1);
    show("memset L2", t1-t0, size);

    Xil_L1DCacheEnable();
    Xil_L2CacheDisable();
    XTime_GetTime(&t0);
    memset(buffer, 0, size);
    XTime_GetTime(&t1);
    show("memset L1", t1-t0, size);


    Xil_DCacheDisable();
    XTime_GetTime(&t0);
    memset(buffer, 0, size);
    XTime_GetTime(&t1);
    show("memset wo cache", t1-t0, size);

    Xil_DCacheEnable();

    memset(buffer, 0, size);
    XTime_GetTime(&t0);
    Xil_DCacheFlushRange(buffer, size);
    XTime_GetTime(&t1);
    show("flush wb", t1-t0, size);


    memset(buffer, 0, size);
    XTime_GetTime(&t0);
    flush_large(buffer, size);
    XTime_GetTime(&t1);
    show("flush4k wb", t1-t0, size);


    XTime_GetTime(&t0);
    Xil_DCacheFlushRange(buffer, size);
    XTime_GetTime(&t1);
    show("flush empty", t1-t0, size);

    XTime_GetTime(&t0);
    flush_large(buffer, size);
    XTime_GetTime(&t1);
    show("flush4k empty", t1-t0, size);



    memset(buffer, 0, size);
    XTime_GetTime(&t0);
    Xil_DCacheInvalidateRange(buffer, size);
    XTime_GetTime(&t1);
    show("invalidate wb?", t1-t0, size);

    XTime_GetTime(&t0);
    Xil_DCacheInvalidateRange(buffer, size);
    XTime_GetTime(&t1);
    show("invalidate empty", t1-t0, size);

    XTime_GetTime(&t0);
    Xil_L1DCacheFlushRange(buffer, size);
    XTime_GetTime(&t1);
    show("flush L1 empty", t1-t0, size);

    XTime_GetTime(&t0);
    Xil_L2CacheFlushRange(buffer, size);
    XTime_GetTime(&t1);
    show("flush L2 empty", t1-t0, size);

    XTime_GetTime(&t0);
    Xil_L1DCacheFlushRange(buffer, size);
    Xil_L2CacheFlushRange(buffer, size);
    XTime_GetTime(&t1);
    show("flush L1->L2 empty", t1-t0, size);


    memset(buffer, 0, size);
    XTime_GetTime(&t0);
    Xil_DCacheFlush();
    XTime_GetTime(&t1);
    show("flush entire wb", t1-t0, size);

    XTime_GetTime(&t0);
    Xil_DCacheFlush();
    XTime_GetTime(&t1);
    show("flush entire empty", t1-t0, size);

    sleep(1);
}

int main()
{
    init_platform();

    while (1) {
        printf("==4KB==\n");
        test(4*1024);

        printf("==256KB==\n");
        test(256*1024);
        printf("==4MB==\n");
        test(SIZE);
    }

    cleanup_platform();

    return 0;
}