CHDK_DE Vorschauversion  Trunk Rev. 5232
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
gui_bench.c-Dateireferenz
#include "camera_info.h"
#include "stdlib.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 58 der Datei gui_bench.c.

#define BENCH_CTL_LOG   1

Definiert in Zeile 64 der Datei gui_bench.c.

#define BENCH_CTL_MAX   BENCH_CTL_SD

Definiert in Zeile 66 der Datei gui_bench.c.

#define BENCH_CTL_SD   2

Definiert in Zeile 65 der Datei gui_bench.c.

#define BENCH_CTL_START   0

Definiert in Zeile 63 der Datei gui_bench.c.

#define BENCH_NOCARD   2

Definiert in Zeile 59 der Datei gui_bench.c.

#define BENCHLOGFILE   "A/BENCH.LOG"

Definiert in Zeile 47 der Datei gui_bench.c.

#define BENCHTMP   "A/BENCH.TMP"

Definiert in Zeile 61 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 16 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 17 der Datei gui_bench.c.

#define INSTPERCYCLE   2

Definiert in Zeile 506 der Datei gui_bench.c.

#define LOGBUFSIZE   1024

Definiert in Zeile 46 der Datei gui_bench.c.

Dokumentation der Funktionen

void __attribute__ ( (naked, noinline)  )

Definiert in Zeile 490 der Datei gui_bench.c.

490  {
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 171 der Datei gui_bench.c.

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

Definiert in Zeile 165 der Datei gui_bench.c.

165  {
166  if ((txtbufptr >= LOGBUFSIZE-48) || !really)
167  return;
168  txtbufptr+=sprintf(txtbuf+txtbufptr,"%s %s\n",title, txt);
169 }
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 190 der Datei gui_bench.c.

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

Definiert in Zeile 180 der Datei gui_bench.c.

180  {
181  twoColors cl;
182  if(active) {
184  } else {
185  cl = user_color(conf.menu_color);
186  }
187  draw_txt_string(pos, 0, s, cl);
188  return pos+strlen(s);
189 }
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 451 der Datei gui_bench.c.

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

Definiert in Zeile 418 der Datei gui_bench.c.

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

Definiert in Zeile 385 der Datei gui_bench.c.

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

Definiert in Zeile 354 der Datei gui_bench.c.

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

Definiert in Zeile 324 der Datei gui_bench.c.

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

Definiert in Zeile 314 der Datei gui_bench.c.

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

Definiert in Zeile 310 der Datei gui_bench.c.

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

Definiert in Zeile 207 der Datei gui_bench.c.

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

Definiert in Zeile 114 der Datei gui_bench.c.

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

Definiert in Zeile 126 der Datei gui_bench.c.

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

Definiert in Zeile 103 der Datei gui_bench.c.

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

Definiert in Zeile 92 der Datei gui_bench.c.

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

Definiert in Zeile 138 der Datei gui_bench.c.

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

Definiert in Zeile 71 der Datei gui_bench.c.

71  {
72  bench.screen_input_bps=-1;
73  bench.screen_input_size=0;
74  bench.screen_output_bps=-1;
75  bench.memory_read_bps=-1;
76  bench.memory_read_uc_bps=-1;
77  bench.memory_write_bps=-1;
78  bench.memory_write_uc_bps=-1;
79  bench.disk_read_buf_kbps=-1;
80  bench.disk_write_buf_kbps=-1;
81  bench.disk_write_raw_kbps=-1;
82  bench.disk_write_mem_kbps=-1;
83  bench.cpu_ips=-1;
84  bench.text_cps=-1;
85  bench.textnonalign_cps=-1;
86  bench_to_run = 0;
87  bench_mode = 0;
88  bench_to_draw = 1;
89 }
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 464 der Datei gui_sokoban.c.

465 {
466  running = 0;
468 }
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 153 der Datei gui_bench.c.

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

Variablen-Dokumentation

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

Definiert in Zeile 67 der Datei gui_bench.c.

int bench_log = 0
static

Definiert in Zeile 56 der Datei gui_bench.c.

int bench_mode = 0
static

Definiert in Zeile 55 der Datei gui_bench.c.

int bench_mode_next = BENCH_ALL
static

Definiert in Zeile 68 der Datei gui_bench.c.

int bench_to_draw = 0
static

Definiert in Zeile 54 der Datei gui_bench.c.

int bench_to_run = 0
static

Definiert in Zeile 53 der Datei gui_bench.c.

int* benchbuf = NULL
static

Definiert in Zeile 51 der Datei gui_bench.c.

char buf[48]
static

Definiert in Zeile 44 der Datei gui_bench.c.

char clearline[48]
static

Definiert in Zeile 52 der Datei gui_bench.c.

int cpu_ips

Definiert in Zeile 39 der Datei gui_bench.c.

int disk_read_buf_kbps

Definiert in Zeile 35 der Datei gui_bench.c.

int disk_write_buf_kbps

Definiert in Zeile 36 der Datei gui_bench.c.

int disk_write_mem_kbps

Definiert in Zeile 38 der Datei gui_bench.c.

int disk_write_raw_kbps

Definiert in Zeile 37 der Datei gui_bench.c.

gui_handler GUI_MODE_BENCH
Initialisierung:

Definiert in Zeile 23 der Datei gui_bench.c.

int memory_read_bps

Definiert in Zeile 31 der Datei gui_bench.c.

int memory_read_uc_bps

Definiert in Zeile 32 der Datei gui_bench.c.

int memory_write_bps

Definiert in Zeile 33 der Datei gui_bench.c.

int memory_write_uc_bps

Definiert in Zeile 34 der Datei gui_bench.c.

int screen_input_bps

Definiert in Zeile 28 der Datei gui_bench.c.

unsigned int screen_input_size

Definiert in Zeile 29 der Datei gui_bench.c.

int screen_output_bps

Definiert in Zeile 30 der Datei gui_bench.c.

int text_cps

Definiert in Zeile 40 der Datei gui_bench.c.

int textnonalign_cps

Definiert in Zeile 41 der Datei gui_bench.c.

char txtbuf[LOGBUFSIZE]
static

Definiert in Zeile 49 der Datei gui_bench.c.

int txtbufptr = 0
static

Definiert in Zeile 50 der Datei gui_bench.c.