CHDK_DE Vorschauversion  Trunk Rev. 5163
 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
 
   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 502 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 503 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 487 der Datei gui_bench.c.

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

Definiert in Zeile 169 der Datei gui_bench.c.

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

Definiert in Zeile 163 der Datei gui_bench.c.

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

Definiert in Zeile 662 der Datei gui_bench.c.

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

Definiert in Zeile 188 der Datei gui_bench.c.

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

Definiert in Zeile 178 der Datei gui_bench.c.

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

Definiert in Zeile 505 der Datei gui_bench.c.

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

Definiert in Zeile 448 der Datei gui_bench.c.

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

Definiert in Zeile 415 der Datei gui_bench.c.

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

Definiert in Zeile 382 der Datei gui_bench.c.

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

Definiert in Zeile 352 der Datei gui_bench.c.

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

Definiert in Zeile 322 der Datei gui_bench.c.

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

Definiert in Zeile 312 der Datei gui_bench.c.

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

Definiert in Zeile 308 der Datei gui_bench.c.

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

Definiert in Zeile 205 der Datei gui_bench.c.

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

Definiert in Zeile 112 der Datei gui_bench.c.

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

Definiert in Zeile 124 der Datei gui_bench.c.

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

Definiert in Zeile 101 der Datei gui_bench.c.

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

Definiert in Zeile 90 der Datei gui_bench.c.

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

Definiert in Zeile 136 der Datei gui_bench.c.

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

Definiert in Zeile 70 der Datei gui_bench.c.

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

Definiert in Zeile 626 der Datei gui_bench.c.

627 {
628  if (bench_to_run) return 0; // ignore keyboard during tests
629  switch (kbd_get_autoclicked_key()) {
630  case KEY_SET:
631  switch(bench_cur_ctl) {
632  case BENCH_CTL_START:
633  gui_bench_init();
635  bench_to_run = 1;
636  break;
637  case BENCH_CTL_LOG:
638  bench_log = !bench_log;
639  bench_to_draw = 1;
640  break;
641  case BENCH_CTL_SD:
643  bench_to_draw = 1;
644  break;
645  }
646  break;
647  // switch controls
648  case KEY_LEFT:
650  bench_to_draw = 1;
651  break;
652  case KEY_RIGHT:
654  bench_to_draw = 1;
655  break;
656  }
657  return 0;
658 }
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 522 der Datei gui_bench.c.

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

Definiert in Zeile 151 der Datei gui_bench.c.

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

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 23 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 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.