CHDK_DE Vorschauversion  Trunk Rev. 5842
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
gui_bench.c-Dateireferenz
#include "camera_info.h"
#include "keyboard.h"
#include "viewport.h"
#include "clock.h"
#include "raw_buffer.h"
#include "lang.h"
#include "gui.h"
#include "gui_lang.h"
#include "gui_draw.h"
#include "cachebit.h"
#include "module_def.h"
#include "simple_module.c"
+ Include-Abhängigkeitsdiagramm für gui_bench.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define draw_txt_string(x, y, s, c)   draw_string((x)*FONT_WIDTH,(y)*FONT_HEIGHT,s,c)
 
#define draw_txt_stringnonalign(x, y, s, c)   draw_string((x)*FONT_WIDTH+1,(y)*FONT_HEIGHT,s,c)
 
#define LOGBUFSIZE   1024
 
#define BENCHLOGFILE   "A/BENCH.LOG"
 
#define BENCH_ALL   1
 
#define BENCH_NOCARD   2
 
#define BENCHTMP   "A/BENCH.TMP"
 
#define BENCH_CTL_START   0
 
#define BENCH_CTL_LOG   1
 
#define BENCH_CTL_SD   2
 
#define BENCH_CTL_MAX   BENCH_CTL_SD
 
#define CYCLES   100000
 
#define INSTPERCYCLE   2
 

Funktionen

void gui_bench_draw ()
 
void gui_module_menu_kbd_process ()
 
int gui_bench_kbd_process ()
 
void gui_bench_init ()
 
static void gui_bench_draw_results_screen (int pos, int value, int ss)
 
static void gui_bench_draw_results_memory (int pos, int value, int value_uc)
 
static void gui_bench_draw_results (int pos, int value)
 
static void gui_bench_draw_results_cpu (int pos, int value)
 
static void gui_bench_draw_results_text (int pos, int value, int valuen, int ss)
 
static void write_log (int really)
 
static void add_to_log (int really, char *title, char *txt)
 
static void add_log_head (int really)
 
static int bench_draw_control_txt (int pos, const char *s, int active)
 
static int bench_draw_checkbox (int pos, const char *title, int active, int checked)
 
static void draw_controls (void)
 
static void run_test (int num)
 
static unsigned int getcurrentmachinetime ()
 
static unsigned int get_usec_diff (unsigned int t)
 
static void bench_screen_write ()
 
static void bench_screen_read ()
 
static void bench_mem_write (int *buff)
 
static void bench_mem_read (int *buff)
 
static void bench_measure_text_write ()
 
void __attribute__ ((naked, noinline))
 
static void bench_measure_cpuspeed ()
 
int basic_module_init ()
 

Variablen

gui_handler GUI_MODE_BENCH
 
struct {
   int   screen_input_bps
 
   unsigned int   screen_input_size
 
   int   screen_output_bps
 
   int   memory_read_bps
 
   int   memory_read_uc_bps
 
   int   memory_write_bps
 
   int   memory_write_uc_bps
 
   int   disk_read_buf_kbps
 
   int   disk_write_buf_kbps
 
   int   disk_write_raw_kbps
 
   int   disk_write_mem_kbps
 
   int   cpu_ips
 
   int   text_cps
 
   int   textnonalign_cps
 
bench
 
static char buf [48]
 
static char txtbuf [LOGBUFSIZE]
 
static int txtbufptr = 0
 
static int * benchbuf = NULL
 
static char clearline [48]
 
static int bench_to_run = 0
 
static int bench_to_draw = 0
 
static int bench_mode = 0
 
static int bench_log = 0
 
static int bench_cur_ctl = BENCH_CTL_START
 
static int bench_mode_next = BENCH_ALL
 
ModuleInfo _module_info
 

Makro-Dokumentation

#define BENCH_ALL   1

Definiert in Zeile 57 der Datei gui_bench.c.

#define BENCH_CTL_LOG   1

Definiert in Zeile 63 der Datei gui_bench.c.

#define BENCH_CTL_MAX   BENCH_CTL_SD

Definiert in Zeile 65 der Datei gui_bench.c.

#define BENCH_CTL_SD   2

Definiert in Zeile 64 der Datei gui_bench.c.

#define BENCH_CTL_START   0

Definiert in Zeile 62 der Datei gui_bench.c.

#define BENCH_NOCARD   2

Definiert in Zeile 58 der Datei gui_bench.c.

#define BENCHLOGFILE   "A/BENCH.LOG"

Definiert in Zeile 46 der Datei gui_bench.c.

#define BENCHTMP   "A/BENCH.TMP"

Definiert in Zeile 60 der Datei gui_bench.c.

#define CYCLES   100000

Definiert in Zeile 505 der Datei gui_bench.c.

#define draw_txt_string (   x,
  y,
  s,
 
)    draw_string((x)*FONT_WIDTH,(y)*FONT_HEIGHT,s,c)

Definiert in Zeile 15 der Datei gui_bench.c.

#define draw_txt_stringnonalign (   x,
  y,
  s,
 
)    draw_string((x)*FONT_WIDTH+1,(y)*FONT_HEIGHT,s,c)

Definiert in Zeile 16 der Datei gui_bench.c.

#define INSTPERCYCLE   2

Definiert in Zeile 506 der Datei gui_bench.c.

#define LOGBUFSIZE   1024

Definiert in Zeile 45 der Datei gui_bench.c.

Dokumentation der Funktionen

void __attribute__ ( (naked, noinline)  )

Definiert in Zeile 489 der Datei gui_bench.c.

489  {
490  (void)loops;
491  asm volatile (
492 #if defined(__thumb__)
493  ".code 16\n"
494  "bx pc\n"
495  ".code 32\n"
496 #endif
497  ".align 4\n"
498  "z1:\n"
499  "subs r0, r0, #1\n"
500  "bhi z1\n"
501  "bx lr\n"
502  );
503 }
static void add_log_head ( int  really)
static

Definiert in Zeile 170 der Datei gui_bench.c.

170  {
171  if ((txtbufptr >= LOGBUFSIZE-200) || !really)
172  return;
176  txtbufptr+=sprintf(txtbuf+txtbufptr,"Mode : 0x%x\n\n",camera_info.state.mode);
177 }
static void add_to_log ( int  really,
char *  title,
char *  txt 
)
static

Definiert in Zeile 164 der Datei gui_bench.c.

164  {
165  if ((txtbufptr >= LOGBUFSIZE-48) || !really)
166  return;
167  txtbufptr+=sprintf(txtbuf+txtbufptr,"%s %s\n",title, txt);
168 }
int basic_module_init ( )

Definiert in Zeile 665 der Datei gui_bench.c.

666 {
669  if (cl < 27)
670  {
671  strncpy(clearline+cl, " ", 27-cl);
672  }
673 
674  gui_bench_init();
676  return 1;
677 }
static int bench_draw_checkbox ( int  pos,
const char *  title,
int  active,
int  checked 
)
static

Definiert in Zeile 189 der Datei gui_bench.c.

189  {
190  pos = bench_draw_control_txt(pos,title,active);
191  pos = bench_draw_control_txt(pos," [",active);
192  pos = bench_draw_control_txt(pos,(checked)?"\x95":" ",active);
193  pos = bench_draw_control_txt(pos,"]",active);
194  return pos;
195 }
static int bench_draw_control_txt ( int  pos,
const char *  s,
int  active 
)
static

Definiert in Zeile 179 der Datei gui_bench.c.

179  {
180  twoColors cl;
181  if(active) {
183  } else {
184  cl = user_color(conf.menu_color);
185  }
186  draw_txt_string(pos, 0, s, cl);
187  return pos+strlen(s);
188 }
static void bench_measure_cpuspeed ( )
static

Definiert in Zeile 508 der Datei gui_bench.c.

508  {
509  unsigned int t, best, c;
510 
511  // 4 test runs, return the best speed
512  best = 0xffffffff;
513  for (c=0; c<4; c++) {
514  t = getcurrentmachinetime();
515  busyloop_thumb(CYCLES);
516  t = get_usec_diff(t);
517  msleep(10);
518  if (t < best) best = t;
519  }
520  bench.cpu_ips = (best==0)?0:INSTPERCYCLE*CYCLES/best; // MIPS
521 }
static void bench_measure_text_write ( )
static

Definiert in Zeile 450 der Datei gui_bench.c.

450  {
451  unsigned int t, best, d;
452  register int c;
453 
454  // 4 test runs, return the best speed
455  best = 0xffffffff;
456  for (d=0; d<4; d++) {
457  t = getcurrentmachinetime();
458  for (c=0; c<16; c++) {
459  // draw 80 chars
460  draw_txt_string(1, 1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_+", MAKE_COLOR(COLOR_BLACK, COLOR_WHITE));
461  draw_txt_string(1, 1, "abcdefghijklmnopqrstuvwxyz0123456789.-_+", MAKE_COLOR(COLOR_GREEN, COLOR_RED));
462  };
463  t = get_usec_diff(t);
464  msleep(10);
465  if (t < best) best = t;
466  }
467  bench.text_cps = (best==0)?0:16*80*1000000/best;
468  best = 0xffffffff;
469  for (d=0; d<4; d++) {
470  t = getcurrentmachinetime();
471  for (c=0; c<16; c++) {
472  // draw 80 chars
473  draw_txt_stringnonalign(1, 1, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_+", MAKE_COLOR(COLOR_BLACK, COLOR_WHITE));
474  draw_txt_stringnonalign(1, 1, "abcdefghijklmnopqrstuvwxyz0123456789.-_+", MAKE_COLOR(COLOR_GREEN, COLOR_RED));
475  };
476  t = get_usec_diff(t);
477  msleep(10);
478  if (t < best) best = t;
479  }
480  bench.textnonalign_cps = (best==0)?0:16*80*1000000/best;
481 }
static void bench_mem_read ( int *  buff)
static

Definiert in Zeile 417 der Datei gui_bench.c.

417  {
418  long t, m;
419  register unsigned int n;
420  register char *buf = (char *)buff;
421  int *result[2];
422  result[0]=&bench.memory_read_bps;
423  result[1]=&bench.memory_read_uc_bps;
424  for (m=0; m<2; m++) {
425  if (m==1) {
426  buf=ADR_TO_UNCACHED(buf);
427  }
428  t = get_tick_count();
429  for (n=0; n<1024; ++n) {
430  asm volatile (
431  "mov r0, %0\n"
432  "mov r1, %2\n"
433  "bmr_loop:\n"
434  "ldr r1, [r0]\n"
435  "add r0, r0, #4\n"
436  "cmp r0, %1\n"
437  "bne bmr_loop\n"
438  :: "r" (buf), "r" (buf+0x10000), "r" (n) : "r0", "r1"
439  );
440  };
441  t = get_tick_count() - t;
442  *result[m] = (t==0)?0:0x10000*100 / (t/10) * 1024;
443  msleep(10);
444  }
445 }
static void bench_mem_write ( int *  buff)
static

Definiert in Zeile 384 der Datei gui_bench.c.

384  {
385  long t, m;
386  register unsigned int n;
387  register char *buf = (char *)buff;
388  int *result[2];
389  result[0]=&bench.memory_write_bps;
390  result[1]=&bench.memory_write_uc_bps;
391  for (m=0; m<2; m++) {
392  if (m==1) {
393  buf=ADR_TO_UNCACHED(buf);
394  }
395  t = get_tick_count();
396  for (n=0; n<1024; ++n) {
397  asm volatile (
398  "mov r0, %0\n"
399  "mov r1, %2\n"
400  "bmw_loop:\n"
401  "str r1, [r0]\n"
402  "add r0, r0, #4\n"
403  "cmp r0, %1\n"
404  "bne bmw_loop\n"
405  :: "r" (buf), "r" (buf+0x10000), "r" (n) : "r0", "r1"
406  );
407  };
408  t = get_tick_count() - t;
409  *result[m] = (t==0)?0:0x10000*100 / (t/10) * 1024;
410  msleep(10);
411  }
412 }
static void bench_screen_read ( )
static

Definiert in Zeile 353 der Datei gui_bench.c.

353  {
354  long t;
355  register unsigned int n, s;
356  register char *scr;
357 
359  if (!scr) return;
361  // limit used mem area (due to low speed access)
362  if ((s < 1) || (s > 360*240*3)) s = 360*240*3;
363  bench.screen_input_size = s;
364  t = get_tick_count();
365  for (n=0; n<32; ++n) {
366  asm volatile (
367  "mov r1, %0\n"
368  "bsr_loop:\n"
369  "ldrb r0, [r1]\n"
370  "add r1, r1, #1\n"
371  "cmp r1, %1\n"
372  "bne bsr_loop\n"
373  :: "r" (scr), "r" (scr+s) : "r0", "r1"
374  );
375  };
376  t = get_tick_count() - t;
377  bench.screen_input_bps = (t==0)?0:s*32*100 / (t/10);
378  msleep(10);
379 }
static void bench_screen_write ( )
static

Definiert in Zeile 323 der Datei gui_bench.c.

323  {
324  long t;
325  register unsigned int s;
326  register char c;
327  register char *scr;
328 
329  scr = vid_get_bitmap_fb();
331  t = get_tick_count();
332 
333  for (c=0; c<64; ++c) {
334  asm volatile (
335  "mov r0, %0\n"
336  "mov r1, %1\n"
337  "bsw_loop:\n"
338  "strb r0, [r1]\n"
339  "add r1, r1, #1\n"
340  "cmp r1, %2\n"
341  "bne bsw_loop\n"
342  :: "r" (c), "r" (scr), "r" (scr+s) : "r0", "r1"
343  );
344  };
345  t = get_tick_count() - t;
346  bench.screen_output_bps = (t==0)?0:s*64*100 / (t/10);
347  msleep(10);
348 }
static void draw_controls ( void  )
static
static unsigned int get_usec_diff ( unsigned int  t)
static

Definiert in Zeile 313 der Datei gui_bench.c.

313  {
314  unsigned int v = *(unsigned int*)0xc0242014;
315  if (v<t)
316  return 0x100000+v-t;
317  return v-t;
318 }
static unsigned int getcurrentmachinetime ( )
static

Definiert in Zeile 309 der Datei gui_bench.c.

309  {
310  return *(unsigned int*)0xc0242014; // should be masked to the lower 20 bits (but high order bits are 0 in practice)
311 }
void gui_bench_draw ( )

Definiert in Zeile 206 der Datei gui_bench.c.

206  {
207  int log_run = 0;
208  switch (bench_to_run) {
209  case 0:
210  break;
211  case 1:
212  benchbuf = malloc(0x10000);
213  txtbufptr = 0;
214  // fall through
215  case 2:
216  case 3:
217  case 4:
218  case 5:
219  case 7:
220  case 8:
221  case 9:
223  bench_to_run++;
224  break;
225  case 6:
226  if (bench_mode!=BENCH_NOCARD) {
228  bench_to_run++;
229  break;
230  }
231  // fall through
232  case 10:
234  if (bench_mode!=BENCH_NOCARD) {
235  remove(BENCHTMP);
236  }
237  bench_to_run = 0;
238  bench_mode = 0;
239  bench_to_draw = 1;
240  log_run = 1;
241  if (benchbuf)
242  free(benchbuf);
243  break;
244  }
245  switch (bench_to_draw) {
246  case 1:
248  draw_controls();
249 
251 
255 
259 
261 
267 
268  /* no break here */
269  case 2:
270  add_log_head(log_run);
271  gui_bench_draw_results_cpu(2, bench.cpu_ips);
272  add_to_log(log_run,"CPU :",buf);
273 
275  add_to_log(log_run,"Screen write :",buf);
276  gui_bench_draw_results_screen(5, bench.screen_input_bps, bench.screen_input_size);
277  add_to_log(log_run,"Viewport read :",buf);
278 
279  gui_bench_draw_results_memory(7, bench.memory_write_bps, bench.memory_write_uc_bps);
280  add_to_log(log_run,"Memory write :",buf);
281  gui_bench_draw_results_memory(8, bench.memory_read_bps, bench.memory_read_uc_bps);
282  add_to_log(log_run,"Memory read :",buf);
283 
285  add_to_log(log_run,"Text drawing :",buf);
286  buf[0] = 0; // empty buffer before optional tests to avoid confusing output when those are not enabled
287 
288  gui_bench_draw_results(11, bench.disk_write_raw_kbps);
289  add_to_log(log_run,"Card write (RAW):",buf);
290  gui_bench_draw_results(12, bench.disk_write_mem_kbps);
291  add_to_log(log_run,"Card write (MEM):",buf);
292  gui_bench_draw_results(13, bench.disk_write_buf_kbps);
293  add_to_log(log_run,"Card write (64k):",buf);
294  gui_bench_draw_results(14, bench.disk_read_buf_kbps);
295  add_to_log(log_run,"Card read (64k):",buf);
296 
297  write_log(log_run);
298 
299  bench_to_draw = 0;
300  break;
301  default:
302  bench_to_draw = 0;
303  break;
304  }
305 }
static void gui_bench_draw_results ( int  pos,
int  value 
)
static

Definiert in Zeile 113 der Datei gui_bench.c.

113  {
114  if (value!=-1) {
115  if (value)
116  sprintf(buf, "%7d Kb/s ", value);
117  else
118  strcpy(buf, clearline);
120  }
121 }
static void gui_bench_draw_results_cpu ( int  pos,
int  value 
)
static

Definiert in Zeile 125 der Datei gui_bench.c.

125  {
126  if (value!=-1) {
127  if (value)
128  sprintf(buf, "%7d MIPS ", value);
129  else
130  strcpy(buf, clearline);
132  }
133 }
static void gui_bench_draw_results_memory ( int  pos,
int  value,
int  value_uc 
)
static

Definiert in Zeile 102 der Datei gui_bench.c.

102  {
103  if (value!=-1) {
104  if (value)
105  sprintf(buf, "%7d C, %6d UC Kb/s ", value/1024, value_uc/1024);
106  else
107  strcpy(buf, clearline);
109  }
110 }
static void gui_bench_draw_results_screen ( int  pos,
int  value,
int  ss 
)
static

Definiert in Zeile 91 der Datei gui_bench.c.

91  {
92  if (value!=-1) {
93  if (value)
94  sprintf(buf, "%7d Kb/s %3d FPS", value/1024, (ss==0)?0:value/ss);
95  else
98  }
99 }
static void gui_bench_draw_results_text ( int  pos,
int  value,
int  valuen,
int  ss 
)
static

Definiert in Zeile 137 der Datei gui_bench.c.

137  {
138  if (value!=-1) {
139  if (value) {
140  int s=(ss==0)?0:FONT_WIDTH*FONT_HEIGHT*value/ss;
141  int sn=(ss==0)?0:FONT_WIDTH*FONT_HEIGHT*valuen/ss;
142  sprintf(buf, " %d, %d c/s %d, %d FPS", value, valuen, s, sn);
143  }
144  else
145  strcpy(buf, clearline);
147  }
148 }
void gui_bench_init ( )

Definiert in Zeile 70 der Datei gui_bench.c.

70  {
71  bench.screen_input_bps=-1;
72  bench.screen_input_size=0;
73  bench.screen_output_bps=-1;
74  bench.memory_read_bps=-1;
75  bench.memory_read_uc_bps=-1;
76  bench.memory_write_bps=-1;
77  bench.memory_write_uc_bps=-1;
78  bench.disk_read_buf_kbps=-1;
79  bench.disk_write_buf_kbps=-1;
80  bench.disk_write_raw_kbps=-1;
81  bench.disk_write_mem_kbps=-1;
82  bench.cpu_ips=-1;
83  bench.text_cps=-1;
84  bench.textnonalign_cps=-1;
85  bench_to_run = 0;
86  bench_mode = 0;
87  bench_to_draw = 1;
88 }
int gui_bench_kbd_process ( )

Definiert in Zeile 629 der Datei gui_bench.c.

630 {
631  if (bench_to_run) return 0; // ignore keyboard during tests
632  switch (kbd_get_autoclicked_key()) {
633  case KEY_SET:
634  switch(bench_cur_ctl) {
635  case BENCH_CTL_START:
636  gui_bench_init();
638  bench_to_run = 1;
639  break;
640  case BENCH_CTL_LOG:
641  bench_log = !bench_log;
642  bench_to_draw = 1;
643  break;
644  case BENCH_CTL_SD:
646  bench_to_draw = 1;
647  break;
648  }
649  break;
650  // switch controls
651  case KEY_LEFT:
653  bench_to_draw = 1;
654  break;
655  case KEY_RIGHT:
657  bench_to_draw = 1;
658  break;
659  }
660  return 0;
661 }
void gui_module_menu_kbd_process ( )

Definiert in Zeile 463 der Datei gui_sokoban.c.

464 {
465  running = 0;
467 }
static void run_test ( int  num)
static

Definiert in Zeile 525 der Datei gui_bench.c.

525  {
526  long t;
527  int x;
528  unsigned int n, s;
529  switch (num) {
530  case 1:
531  bench.cpu_ips = 0;
533  bench.screen_output_bps = 0;
534  bench_to_draw = 2;
535  break;
536  case 2:
538  bench.screen_input_bps = 0;
539  bench_to_draw = 1;
540  break;
541  case 3:
543  bench.memory_write_bps = 0;
544  bench_to_draw = 2;
545  break;
546  case 4:
547  if (benchbuf) {
549  }
550  bench.memory_read_bps = 0;
551  bench_to_draw = 2;
552  break;
553  case 5:
554  if (benchbuf) {
556  }
557  bench.text_cps = 0;
558  bench_to_draw = 2;
559  break;
560  case 6:
562  if (bench_mode!=BENCH_NOCARD) {
563  bench.disk_write_raw_kbps = 0;
564  }
565  bench_to_draw = 1;
566  break;
567  case 7:
568  x = open(BENCHTMP, O_WRONLY|O_CREAT, 0777);
569  if (x>=0) {
570  t = get_tick_count();
572  t = get_tick_count() - t;
573  close(x);
574  bench.disk_write_raw_kbps = (t==0)?0:s*100 / (t/10);
575  }
576  bench.disk_write_mem_kbps = 0;
577  bench_to_draw = 2;
578  break;
579  case 8:
580  x = open(BENCHTMP, O_WRONLY|O_CREAT, 0777);
581  if (x>=0) {
582  t = get_tick_count();
583  s=write(x, (void*)0x10000, 0xC00000)/1024;
584  t = get_tick_count() - t;
585  close(x);
586  bench.disk_write_mem_kbps = (t==0)?0:s*100 / (t/10);
587  }
588  bench.disk_write_buf_kbps = 0;
589  bench_to_draw = 2;
590  break;
591  case 9:
592  if (benchbuf) {
593  x = open(BENCHTMP, O_WRONLY|O_CREAT, 0777);
594  if (x>=0) {
595  s = 0;
596  t = get_tick_count();
597  for (n=0; n<256; ++n)
598  s+=write(x, benchbuf, 0x10000);
599  t = get_tick_count() - t;
600  s = s / 1024;
601  close(x);
602  bench.disk_write_buf_kbps = (t==0)?0:s*100 / (t/10);
603  }
604  }
605  bench.disk_read_buf_kbps = 0;
606  bench_to_draw = 2;
607  break;
608  case 10:
609  if (benchbuf) {
610  x = open(BENCHTMP, O_RDONLY, 0777);
611  if (x>=0) {
612  s = 0;
613  t = get_tick_count();
614  for (n=0; n<256; ++n)
615  s+=read(x, benchbuf, 0x10000);
616  t = get_tick_count() - t;
617  s = s / 1024;
618  close(x);
619  bench.disk_read_buf_kbps = (t==0)?0:s*100 / (t/10);
620  }
621  }
622  bench_to_draw = 2;
623  break;
624  }
625 }
static void write_log ( int  really)
static

Definiert in Zeile 152 der Datei gui_bench.c.

152  {
153  if (!really)
154  return;
155  int fd = open(BENCHLOGFILE, O_WRONLY|O_CREAT|O_APPEND, 0777);
156  if (fd >= 0)
157  {
158  lseek(fd, 0, SEEK_END);
159  write(fd, txtbuf, txtbufptr);
160  close(fd);
161  }
162 }

Variablen-Dokumentation

struct { ... } bench
int bench_cur_ctl = BENCH_CTL_START
static

Definiert in Zeile 66 der Datei gui_bench.c.

int bench_log = 0
static

Definiert in Zeile 55 der Datei gui_bench.c.

int bench_mode = 0
static

Definiert in Zeile 54 der Datei gui_bench.c.

int bench_mode_next = BENCH_ALL
static

Definiert in Zeile 67 der Datei gui_bench.c.

int bench_to_draw = 0
static

Definiert in Zeile 53 der Datei gui_bench.c.

int bench_to_run = 0
static

Definiert in Zeile 52 der Datei gui_bench.c.

int* benchbuf = NULL
static

Definiert in Zeile 50 der Datei gui_bench.c.

char buf[48]
static

Definiert in Zeile 43 der Datei gui_bench.c.

char clearline[48]
static

Definiert in Zeile 51 der Datei gui_bench.c.

int cpu_ips

Definiert in Zeile 38 der Datei gui_bench.c.

int disk_read_buf_kbps

Definiert in Zeile 34 der Datei gui_bench.c.

int disk_write_buf_kbps

Definiert in Zeile 35 der Datei gui_bench.c.

int disk_write_mem_kbps

Definiert in Zeile 37 der Datei gui_bench.c.

int disk_write_raw_kbps

Definiert in Zeile 36 der Datei gui_bench.c.

gui_handler GUI_MODE_BENCH
Initialisierung:

Definiert in Zeile 22 der Datei gui_bench.c.

int memory_read_bps

Definiert in Zeile 30 der Datei gui_bench.c.

int memory_read_uc_bps

Definiert in Zeile 31 der Datei gui_bench.c.

int memory_write_bps

Definiert in Zeile 32 der Datei gui_bench.c.

int memory_write_uc_bps

Definiert in Zeile 33 der Datei gui_bench.c.

int screen_input_bps

Definiert in Zeile 27 der Datei gui_bench.c.

unsigned int screen_input_size

Definiert in Zeile 28 der Datei gui_bench.c.

int screen_output_bps

Definiert in Zeile 29 der Datei gui_bench.c.

int text_cps

Definiert in Zeile 39 der Datei gui_bench.c.

int textnonalign_cps

Definiert in Zeile 40 der Datei gui_bench.c.

char txtbuf[LOGBUFSIZE]
static

Definiert in Zeile 48 der Datei gui_bench.c.

int txtbufptr = 0
static

Definiert in Zeile 49 der Datei gui_bench.c.