apps/plugins/test_mem.c

   1 /***************************************************************************
   2 *             __________               __   ___.
   3 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7 *                     \/            \/     \/    \/            \/
   8 * $Id$
   9 *
  10 * Copyright (C) 2010 Thomas Martitz, Andree Buschmann
  11 *
  12 * This program is free software; you can redistribute it and/or
  13 * modify it under the terms of the GNU General Public License
  14 * as published by the Free Software Foundation; either version 2
  15 * of the License, or (at your option) any later version.
  16 *
  17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18 * KIND, either express or implied.
  19 *
  20 ****************************************************************************/
  21
  22 #include "plugin.h"
  23
  24 PLUGIN_HEADER
  25
  26 #if PLUGIN_BUFFER_SIZE <= 0x8000
  27 #define BUF_SIZE (1<<12) /* 16 KB = (1<<12)*sizeof(int) */
  28 #else
  29 #define BUF_SIZE (1<<13) /* 32 KB = (1<<13)*sizeof(int) */
  30 #endif
  31
  32 #define LOOP_REPEAT_DRAM 256
  33 static volatile int buf_dram[BUF_SIZE];
  34
  35 #if defined(PLUGIN_USE_IRAM)
  36 #define LOOP_REPEAT_IRAM 1024
  37 static volatile int buf_iram[BUF_SIZE] IBSS_ATTR;
  38 #endif
  39
  40 /* (Byte per loop * loops)>>20 * ticks per s * 10 / ticks = dMB per s */
  41 #define dMB_PER_SEC(cnt, delta) ((((BUF_SIZE*sizeof(int)*cnt)>>20)*HZ*10)/delta)
  42
  43 void memset_test(volatile int *buf, int buf_size, int loop_cnt,
  44                  int line, char *ramtype)
  45 {
  46     int delta, dMB, i;
  47     int last_tick = *rb->current_tick;
  48
  49     for(i=0; i < loop_cnt; i++)
  50     {
  51         memset((void *)buf, 0xff, buf_size*sizeof(int));
  52     }
  53
  54     delta = *rb->current_tick - last_tick;
  55     delta = delta>0 ? delta : delta+1;
  56     dMB   = dMB_PER_SEC(loop_cnt, delta);
  57     rb->screens[0]->putsf(0, line, "%s st: %3d.%d MB/s (%3d ticks for %d MB)",
  58                           ramtype, dMB/10, dMB%10, delta,
  59                           (loop_cnt*BUF_SIZE*4)>>20);
  60 }
  61
  62 void memcpy_test(volatile int *buf, int buf_size, int loop_cnt,
  63                  int line, char *ramtype)
  64 {
  65     int delta, dMB, i;
  66     int last_tick = *rb->current_tick;
  67
  68     /* double loop count to compensate for half size memcpy */
  69     for(i=0; i < loop_cnt*2; i++)
  70     {
  71         memcpy((void *)buf+(buf_size*sizeof(int)/2),
  72                (void *)buf, buf_size*sizeof(int)/2);
  73     }
  74
  75     delta = *rb->current_tick - last_tick;
  76     delta = delta>0 ? delta : delta+1;
  77     dMB   = dMB_PER_SEC(loop_cnt, delta);
  78     rb->screens[0]->putsf(0, line, "%s cp: %3d.%d MB/s (%3d ticks for %d MB)",
  79                           ramtype, dMB/10, dMB%10, delta,
  80                           (loop_cnt*BUF_SIZE*4)>>21);
  81 }
  82
  83 void write_test(volatile int *buf, int buf_size, int loop_cnt,
  84                 int line, char *ramtype)
  85 {
  86     int delta, dMB;
  87     int last_tick = *rb->current_tick;
  88
  89 #if defined(CPU_ARM)
  90     asm volatile (
  91             "mov r0, #0           \n"
  92             "mov r1, #1           \n"
  93             "mov r2, #2           \n"
  94             "mov r3, #3           \n"
  95             "mov r6, %[loops]     \n"
  96         ".outer_loop_read:        \n"
  97             "mov r4, %[buf_p]     \n"
  98             "mov r5, %[size]      \n"
  99         ".inner_loop_read:        \n"
 100             "stmia r4!, {r0-r3}   \n"
 101             "stmia r4!, {r0-r3}   \n"
 102             "subs r5, r5, #8      \n"
 103             "bgt .inner_loop_read \n"
 104             "subs r6, r6, #1      \n"
 105             "bgt .outer_loop_read \n"
 106             :
 107             : [loops] "r" (loop_cnt), [size] "r" (buf_size), [buf_p] "r" (buf)
 108             : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "memory", "cc"
 109         );
 110 #else
 111     int i, j;
 112     for(i = 0; i < loop_cnt; i++)
 113     {
 114         for (j = 0; j < buf_size; j+=4)
 115         {
 116             buf[j  ] = j;
 117             buf[j+1] = j+1;
 118             buf[j+2] = j+2;
 119             buf[j+3] = j+3;
 120         }
 121     }
 122 #endif
 123     delta = *rb->current_tick - last_tick;
 124     delta = delta>0 ? delta : delta+1;
 125     dMB   = dMB_PER_SEC(loop_cnt, delta);
 126     rb->screens[0]->putsf(0, line, "%s wr: %3d.%d MB/s (%3d ticks for %d MB)",
 127                           ramtype, dMB/10, dMB%10, delta,
 128                           (loop_cnt*BUF_SIZE*4)>>20);
 129 }
 130
 131 void read_test(volatile int *buf, int buf_size, int loop_cnt,
 132                int line, char *ramtype)
 133 {
 134     int delta, dMB;
 135     int last_tick = *rb->current_tick;
 136
 137 #if defined(CPU_ARM)
 138     asm volatile (
 139             "mov r6, %[loops]      \n"
 140         ".outer_loop_write:        \n"
 141             "mov r4, %[buf_p]      \n"
 142             "mov r5, %[size]       \n"
 143         ".inner_loop_write:        \n"
 144             "ldmia r4!, {r0-r3}    \n"
 145             "ldmia r4!, {r0-r3}    \n"
 146             "subs r5, r5, #8       \n"
 147             "bgt .inner_loop_write \n"
 148             "subs r6, r6, #1       \n"
 149             "bgt .outer_loop_write \n"
 150             :
 151             : [loops] "r" (loop_cnt), [size] "r" (buf_size), [buf_p] "r" (buf)
 152             : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "memory", "cc"
 153         );
 154 #else
 155     int i, j, x;
 156     for(i = 0; i < loop_cnt; i++)
 157     {
 158         for(j = 0; j < buf_size; j+=4)
 159         {
 160             x = buf[j  ];
 161             x = buf[j+2];
 162             x = buf[j+3];
 163             x = buf[j+4];
 164         }
 165     }
 166 #endif
 167     delta = *rb->current_tick - last_tick;
 168     delta = delta>0 ? delta : delta+1;
 169     dMB   = dMB_PER_SEC(loop_cnt, delta);
 170     rb->screens[0]->putsf(0, line, "%s rd: %3d.%d MB/s (%3d ticks for %d MB)",
 171                           ramtype, dMB/10, dMB%10, delta,
 172                           (loop_cnt*BUF_SIZE*4)>>20);
 173 }
 174
 175
 176 enum plugin_status plugin_start(const void* parameter)
 177 {
 178     (void)parameter;
 179     bool done = false;
 180     bool boost = false;
 181     int count = 0;
 182
 183 #ifdef HAVE_LCD_BITMAP
 184     rb->lcd_setfont(FONT_SYSFIXED);
 185 #endif
 186
 187     rb->screens[0]->clear_display();
 188     rb->screens[0]->putsf(0, 0, "patience, may take some seconds...");
 189     rb->screens[0]->update();
 190
 191     while (!done)
 192     {
 193         int line = 0;
 194
 195         rb->screens[0]->clear_display();
 196         rb->screens[0]->putsf(0, line++, "%s", boost?"boosted":"unboosted");
 197 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
 198         rb->screens[0]->putsf(0, line++, "clock: %d Hz", *rb->cpu_frequency);
 199 #endif
 200         rb->screens[0]->putsf(0, line++, "loop#: %d", ++count);
 201
 202         read_test  (buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 203         write_test (buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 204         memset_test(buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 205         memcpy_test(buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 206 #if defined(PLUGIN_USE_IRAM)
 207         read_test  (buf_iram, BUF_SIZE, LOOP_REPEAT_IRAM, line++, "IRAM");
 208         write_test (buf_iram, BUF_SIZE, LOOP_REPEAT_IRAM, line++, "IRAM");
 209         memset_test(buf_iram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "IRAM");
 210         memcpy_test(buf_iram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "IRAM");
 211 #endif
 212
 213         rb->screens[0]->update();
 214
 215         switch (rb->get_action(CONTEXT_STD, HZ/5))
 216         {
 217 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 218             case ACTION_STD_PREV:
 219                 if (!boost)
 220                 {
 221                     rb->cpu_boost(true);
 222                     boost = true;
 223                 }
 224                 break;
 225
 226             case ACTION_STD_NEXT:
 227                 if (boost)
 228                 {
 229                     rb->cpu_boost(false);
 230                     boost = false;
 231                 }
 232                 break;
 233 #endif
 234             case ACTION_STD_CANCEL:
 235                 done = true;
 236                 break;
 237         }
 238     }
 239
 240     return PLUGIN_OK;
 241 }