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 #define BUF_SIZE (1<<13) /* 32 KB = (1<<13)*sizeof(int) */
  27
  28 #define LOOP_REPEAT_DRAM 256
  29 static volatile int buf_dram[BUF_SIZE];
  30
  31 #if defined(PLUGIN_USE_IRAM)
  32 #define LOOP_REPEAT_IRAM 1024
  33 static volatile int buf_iram[BUF_SIZE] IBSS_ATTR;
  34 #endif
  35
  36 /* (Byte per loop * loops)>>20 * ticks per s * 10 / ticks = dMB per s */
  37 #define dMB_PER_SEC(cnt, delta) ((((BUF_SIZE*sizeof(int)*cnt)>>20)*HZ*10)/delta)
  38
  39 void memset_test(volatile int *buf, int buf_size, int loop_cnt,
  40                  int line, char *ramtype)
  41 {
  42     int delta, dMB, i;
  43     int last_tick = *rb->current_tick;
  44
  45     for(i=0; i < loop_cnt; i++)
  46         memset((void *)buf, 0xff, buf_size);
  47
  48     delta = *rb->current_tick - last_tick;
  49     delta = delta>0 ? delta : delta+1;
  50     dMB   = dMB_PER_SEC(loop_cnt, delta);
  51     rb->screens[0]->putsf(0, line, "%s st: %3d.%d MB/s (%2d ticks for %d MB)",
  52                           ramtype, dMB/10, dMB%10, delta,
  53                           (loop_cnt*BUF_SIZE*4)>>20);
  54
  55 }
  56
  57 void memcpy_test(volatile int *buf, int buf_size, int loop_cnt,
  58                  int line, char *ramtype)
  59 {
  60     int delta, dMB, i;
  61     int last_tick = *rb->current_tick;
  62
  63     for(i=0; i < loop_cnt; i++)
  64         memcpy((void *)buf+(buf_size/2), (void *)buf, buf_size/2);
  65
  66     delta = *rb->current_tick - last_tick;
  67     delta = delta>0 ? delta : delta+1;
  68     dMB   = dMB_PER_SEC(loop_cnt, delta);
  69     rb->screens[0]->putsf(0, line, "%s cp: %3d.%d MB/s (%2d ticks for %d MB)",
  70                           ramtype, dMB/10, dMB%10, delta,
  71                           (loop_cnt*BUF_SIZE*4)>>21);
  72
  73 }
  74
  75 void write_test(volatile int *buf, int buf_size, int loop_cnt,
  76                 int line, char *ramtype)
  77 {
  78     int delta, dMB;
  79     int last_tick = *rb->current_tick;
  80
  81 #if defined(CPU_ARM)
  82     asm volatile (
  83             "mov r0, #0           \n"
  84             "mov r1, #1           \n"
  85             "mov r2, #2           \n"
  86             "mov r3, #3           \n"
  87             "mov r6, %[loops]     \n"
  88         ".outer_loop_read:        \n"
  89             "mov r4, %[buf_p]     \n"
  90             "mov r5, %[size]      \n"
  91         ".inner_loop_read:        \n"
  92             "stmia r4!, {r0-r3}   \n"
  93             "stmia r4!, {r0-r3}   \n"
  94             "subs r5, r5, #8      \n"
  95             "bgt .inner_loop_read \n"
  96             "subs r6, r6, #1      \n"
  97             "bgt .outer_loop_read \n"
  98             :
  99             : [loops] "r" (loop_cnt), [size] "r" (buf_size), [buf_p] "r" (buf)
 100             : "r0", "r1", "r2", "r3", "r4", "r5", "r6"
 101         );
 102 #else
 103     int i, j;
 104     for(i = 0; i < loop_cnt; i++)
 105     {
 106         for (j = 0; j < buf_size; j+=4)
 107         {
 108             buf[j  ] = j;
 109             buf[j+1] = j+1;
 110             buf[j+2] = j+2;
 111             buf[j+3] = j+3;
 112         }
 113     }
 114 #endif
 115     delta = *rb->current_tick - last_tick;
 116     delta = delta>0 ? delta : delta+1;
 117     dMB   = dMB_PER_SEC(loop_cnt, delta);
 118     rb->screens[0]->putsf(0, line, "%s wr: %3d.%d MB/s (%2d ticks for %d MB)",
 119                           ramtype, dMB/10, dMB%10, delta,
 120                           (loop_cnt*BUF_SIZE*4)>>20);
 121 }
 122
 123 void read_test(volatile int *buf, int buf_size, int loop_cnt,
 124                int line, char *ramtype)
 125 {
 126     int delta, dMB;
 127     int last_tick = *rb->current_tick;
 128
 129 #if defined(CPU_ARM)
 130     asm volatile (
 131             "mov r6, %[loops]      \n"
 132         ".outer_loop_write:        \n"
 133             "mov r4, %[buf_p]      \n"
 134             "mov r5, %[size]       \n"
 135         ".inner_loop_write:        \n"
 136             "ldmia r4!, {r0-r3}    \n"
 137             "ldmia r4!, {r0-r3}    \n"
 138             "subs r5, r5, #8       \n"
 139             "bgt .inner_loop_write \n"
 140             "subs r6, r6, #1       \n"
 141             "bgt .outer_loop_write \n"
 142             :
 143             : [loops] "r" (loop_cnt), [size] "r" (buf_size), [buf_p] "r" (buf)
 144             : "r0", "r1", "r2", "r3", "r4", "r5", "r6"
 145         );
 146 #else
 147     int i, j, x;
 148     for(i = 0; i < loop_cnt; i++)
 149     {
 150         for(j = 0; j < buf_size; j+=4)
 151         {
 152             x = buf[j  ];
 153             x = buf[j+2];
 154             x = buf[j+3];
 155             x = buf[j+4];
 156         }
 157     }
 158 #endif
 159     delta = *rb->current_tick - last_tick;
 160     delta = delta>0 ? delta : delta+1;
 161     dMB   = dMB_PER_SEC(loop_cnt, delta);
 162     rb->screens[0]->putsf(0, line, "%s rd: %3d.%d MB/s (%2d ticks for %d MB)",
 163                           ramtype, dMB/10, dMB%10, delta,
 164                           (loop_cnt*BUF_SIZE*4)>>20);
 165 }
 166
 167
 168 enum plugin_status plugin_start(const void* parameter)
 169 {
 170     (void)parameter;
 171     bool done = false;
 172     bool boost = false;
 173     int count = 0;
 174
 175     rb->lcd_setfont(FONT_SYSFIXED);
 176
 177     rb->screens[0]->clear_display();
 178     rb->screens[0]->putsf(0, 0, "patience, may take some seconds...");
 179     rb->screens[0]->update();
 180
 181     while (!done)
 182     {
 183         int line = 0;
 184
 185         rb->screens[0]->clear_display();
 186         rb->screens[0]->putsf(0, line++, "%s", boost?"boosted":"unboosted");
 187 #ifndef SIMULATOR
 188         rb->screens[0]->putsf(0, line++, "clock: %d Hz", *rb->cpu_frequency);
 189 #endif
 190         rb->screens[0]->putsf(0, line++, "loop#: %d", ++count);
 191
 192         read_test (buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 193         write_test(buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 194         memset_test(buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 195         memcpy_test(buf_dram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "DRAM");
 196 #if defined(PLUGIN_USE_IRAM)
 197         read_test (buf_iram, BUF_SIZE, LOOP_REPEAT_IRAM, line++, "IRAM");
 198         write_test(buf_iram, BUF_SIZE, LOOP_REPEAT_IRAM, line++, "IRAM");
 199         memset_test(buf_iram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "IRAM");
 200         memcpy_test(buf_iram, BUF_SIZE, LOOP_REPEAT_DRAM, line++, "IRAM");
 201 #endif
 202
 203         rb->screens[0]->update();
 204
 205         switch (rb->get_action(CONTEXT_STD, HZ/5))
 206         {
 207 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 208             case ACTION_STD_PREV:
 209                 if (!boost)
 210                 {
 211                     rb->cpu_boost(true);
 212                     boost = true;
 213                 }
 214                 break;
 215
 216             case ACTION_STD_NEXT:
 217                 if (boost)
 218                 {
 219                     rb->cpu_boost(false);
 220                     boost = false;
 221                 }
 222                 break;
 223 #endif
 224             case ACTION_STD_CANCEL:
 225                 done = true;
 226                 break;
 227         }
 228     }
 229
 230     return PLUGIN_OK;
 231 }