summaryrefslogtreecommitdiff
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/settings/sysinfo/benchmarkinfo.cpp9
-rw-r--r--noncore/settings/sysinfo/benchmarkinfo.h1
-rw-r--r--noncore/settings/sysinfo/contrib/dhry.c1010
-rw-r--r--noncore/settings/sysinfo/contrib/dhry.h397
-rw-r--r--noncore/settings/sysinfo/contrib/fft.c (renamed from noncore/settings/sysinfo/fft.c)0
-rw-r--r--noncore/settings/sysinfo/sysinfo.pro9
6 files changed, 1419 insertions, 7 deletions
diff --git a/noncore/settings/sysinfo/benchmarkinfo.cpp b/noncore/settings/sysinfo/benchmarkinfo.cpp
index 62146f7..1d0b140 100644
--- a/noncore/settings/sysinfo/benchmarkinfo.cpp
+++ b/noncore/settings/sysinfo/benchmarkinfo.cpp
@@ -39,5 +39,6 @@
39/* STD */ 39/* STD */
40#include <stdio.h>
41#include <time.h> 40#include <time.h>
41#include <stdio.h>
42#include <stdlib.h> 42#include <stdlib.h>
43#include <math.h>
43 44
@@ -48,2 +49,3 @@ extern "C"
48 void BenchFFT( void ); 49 void BenchFFT( void );
50 double dhry_main( int );
49} 51}
@@ -124,5 +126,4 @@ void BenchmarkInfo::run()
124 { 126 {
125 t.start(); 127 int d = round( dhry_main( DHRYSTONE_RUNS ) );
126 benchInteger(); 128 test_alu->setText( 1, QString( "%1 DHRYS" ).arg( QString::number( d ) ) );
127 test_alu->setText( 1, QString( "%1 secs" ).arg( QString::number( t.elapsed() / 1000.0 ) ) );
128 test_alu->setOn( false ); 129 test_alu->setOn( false );
diff --git a/noncore/settings/sysinfo/benchmarkinfo.h b/noncore/settings/sysinfo/benchmarkinfo.h
index 2c7fa40..2d994b4 100644
--- a/noncore/settings/sysinfo/benchmarkinfo.h
+++ b/noncore/settings/sysinfo/benchmarkinfo.h
@@ -31,2 +31,3 @@ class QListView;
31#define INT_TEST_ITERATIONS 50 31#define INT_TEST_ITERATIONS 50
32#define DHRYSTONE_RUNS 20000000
32#define CHAR_TEST_ITERATIONS 15000 33#define CHAR_TEST_ITERATIONS 15000
diff --git a/noncore/settings/sysinfo/contrib/dhry.c b/noncore/settings/sysinfo/contrib/dhry.c
new file mode 100644
index 0000000..d1dadbd
--- a/dev/null
+++ b/noncore/settings/sysinfo/contrib/dhry.c
@@ -0,0 +1,1010 @@
1/*****************************************************/
2/* Various timer routines. */
3/* Al Aburto, aburto@nosc.mil, 18 Feb 1997 */
4/* */
5/* t = dtime() outputs the current time in seconds. */
6/* Use CAUTION as some of these routines will mess */
7/* up when timing across the hour mark!!! */
8/* */
9/* For timing I use the 'user' time whenever */
10/* possible. Using 'user+sys' time is a separate */
11/* issue. */
12/* */
13/* Example Usage: */
14/* [timer options added here] */
15/* main() */
16/* { */
17/* double starttime,benchtime,dtime(); */
18/* */
19/* starttime = dtime(); */
20/* [routine to time] */
21/* benchtime = dtime() - starttime; */
22/* } */
23/* */
24/* [timer code below added here] */
25/*****************************************************/
26
27/***************************************************************/
28/* Timer options. You MUST uncomment one of the options below */
29/* or compile, for example, with the '-DUNIX' option. */
30/***************************************************************/
31/* #define Amiga */
32/* #define UNIX */
33/* #define UNIX_Old */
34/* #define VMS */
35/* #define BORLAND_C */
36/* #define MSC */
37/* #define MAC */
38/* #define IPSC */
39/* #define FORTRAN_SEC */
40/* #define GTODay */
41/* #define CTimer */
42/* #define UXPM */
43/* #define MAC_TMgr */
44/* #define PARIX */
45/* #define POSIX */
46/* #define WIN32 */
47/* #define POSIX1 */
48/***********************/
49
50/*********************************/
51/* Timer code. */
52/*********************************/
53/*******************/
54/* Amiga dtime() */
55/*******************/
56#ifdef Amiga
57#include <ctype.h>
58#define HZ 50
59
60double dtime()
61{
62 double q;
63
64 struct tt
65 {
66 long days;
67 long minutes;
68 long ticks;
69 } tt;
70
71 DateStamp(&tt);
72
73 q = ((double)(tt.ticks + (tt.minutes * 60L * 50L))) / (double)HZ;
74
75 return q;
76}
77#endif
78
79/*****************************************************/
80/* UNIX dtime(). This is the preferred UNIX timer. */
81/* Provided by: Markku Kolkka, mk59200@cc.tut.fi */
82/* HP-UX Addition by: Bo Thide', bt@irfu.se */
83/*****************************************************/
84#ifdef UNIX
85#include <sys/time.h>
86#include <sys/resource.h>
87
88#ifdef hpux
89#include <sys/syscall.h>
90#define getrusage(a,b) syscall(SYS_getrusage,a,b)
91#endif
92
93struct rusage rusage;
94
95double dtime()
96{
97 double q;
98
99 getrusage(RUSAGE_SELF,&rusage);
100
101 q = (double)(rusage.ru_utime.tv_sec);
102 q = q + (double)(rusage.ru_utime.tv_usec) * 1.0e-06;
103
104 return q;
105}
106#endif
107
108/***************************************************/
109/* UNIX_Old dtime(). This is the old UNIX timer. */
110/* Make sure HZ is properly defined in param.h !! */
111/***************************************************/
112#ifdef UNIX_Old
113#include <sys/types.h>
114#include <sys/times.h>
115#include <sys/param.h>
116
117#ifndef HZ
118#define HZ 60
119#endif
120
121struct tms tms;
122
123double dtime()
124{
125 double q;
126
127 times(&tms);
128
129 q = (double)(tms.tms_utime) / (double)HZ;
130
131 return q;
132}
133#endif
134
135/*********************************************************/
136/* VMS dtime() for VMS systems. */
137/* Provided by: RAMO@uvphys.phys.UVic.CA */
138/* Some people have run into problems with this timer. */
139/*********************************************************/
140#ifdef VMS
141#include time
142
143#ifndef HZ
144#define HZ 100
145#endif
146
147struct tbuffer_t
148 {
149 int proc_user_time;
150 int proc_system_time;
151 int child_user_time;
152 int child_system_time;
153 };
154
155struct tbuffer_t tms;
156
157double dtime()
158{
159 double q;
160
161 times(&tms);
162
163 q = (double)(tms.proc_user_time) / (double)HZ;
164
165 return q;
166}
167#endif
168
169/******************************/
170/* BORLAND C dtime() for DOS */
171/******************************/
172#ifdef BORLAND_C
173#include <ctype.h>
174#include <dos.h>
175#include <time.h>
176
177#define HZ 100
178struct time tnow;
179
180double dtime()
181{
182 double q;
183
184 gettime(&tnow);
185
186 q = 60.0 * (double)(tnow.ti_min);
187 q = q + (double)(tnow.ti_sec);
188 q = q + (double)(tnow.ti_hund)/(double)HZ;
189
190 return q;
191}
192#endif
193
194/**************************************/
195/* Microsoft C (MSC) dtime() for DOS */
196/**************************************/
197#ifdef MSC
198#include <time.h>
199#include <ctype.h>
200
201#define HZ CLOCKS_PER_SEC
202clock_t tnow;
203
204double dtime()
205{
206 double q;
207
208 tnow = clock();
209
210 q = (double)tnow / (double)HZ;
211
212 return q;
213}
214#endif
215
216/*************************************/
217/* Macintosh (MAC) Think C dtime() */
218/*************************************/
219#ifdef MAC
220#include <time.h>
221
222#define HZ 60
223
224double dtime()
225{
226 double q;
227
228 q = (double)clock() / (double)HZ;
229
230 return q;
231}
232#endif
233
234/************************************************************/
235/* iPSC/860 (IPSC) dtime() for i860. */
236/* Provided by: Dan Yergeau, yergeau@gloworm.Stanford.EDU */
237/************************************************************/
238#ifdef IPSC
239extern double dclock();
240
241double dtime()
242{
243 double q;
244
245 q = dclock();
246
247 return q;
248}
249#endif
250
251/**************************************************/
252/* FORTRAN dtime() for Cray type systems. */
253/* This is the preferred timer for Cray systems. */
254/**************************************************/
255#ifdef FORTRAN_SEC
256
257fortran double second();
258
259double dtime()
260{
261 double q;
262
263 second(&q);
264
265 return q;
266}
267#endif
268
269/***********************************************************/
270/* UNICOS C dtime() for Cray UNICOS systems. Don't use */
271/* unless absolutely necessary as returned time includes */
272/* 'user+system' time. Provided by: R. Mike Dority, */
273/* dority@craysea.cray.com */
274/***********************************************************/
275#ifdef CTimer
276#include <time.h>
277
278double dtime()
279{
280 double q;
281 clock_t clock(void);
282
283 q = (double)clock() / (double)CLOCKS_PER_SEC;
284
285 return q;
286}
287#endif
288
289/********************************************/
290/* Another UNIX timer using gettimeofday(). */
291/* However, getrusage() is preferred. */
292/********************************************/
293#ifdef GTODay
294#include <sys/time.h>
295
296struct timeval tnow;
297
298double dtime()
299{
300 double q;
301
302 gettimeofday(&tnow,NULL);
303 q = (double)tnow.tv_sec + (double)tnow.tv_usec * 1.0e-6;
304
305 return q;
306}
307#endif
308
309/*****************************************************/
310/* Fujitsu UXP/M timer. */
311/* Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */
312/*****************************************************/
313#ifdef UXPM
314#include <sys/types.h>
315#include <sys/timesu.h>
316struct tmsu rusage;
317
318double dtime()
319{
320 double q;
321
322 timesu(&rusage);
323
324 q = (double)(rusage.tms_utime) * 1.0e-06;
325
326 return q;
327}
328#endif
329
330/**********************************************/
331/* Macintosh (MAC_TMgr) Think C dtime() */
332/* requires Think C Language Extensions or */
333/* #include <MacHeaders> in the prefix */
334/* provided by Francis H Schiffer 3rd (fhs) */
335/* skipschiffer@genie.geis.com */
336/**********************************************/
337#ifdef MAC_TMgr
338#include <Timer.h>
339#include <stdlib.h>
340
341static TMTask mgrTimer;
342static Boolean mgrInited = false;
343static double mgrClock;
344
345#define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer )
346#define MAX_TIME 1800000000L
347/* MAX_TIME limits time between calls to */
348/* dtime( ) to no more than 30 minutes */
349/* this limitation could be removed by */
350/* creating a completion routine to sum */
351/* 30 minute segments (fhs 1994 feb 9) */
352
353static void Remove_timer( )
354{
355 RMV_TIMER;
356 mgrInited = false;
357}
358
359double dtime( )
360{
361 if( mgrInited ) {
362 RMV_TIMER;
363 mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6;
364 } else {
365 if( _atexit( &Remove_timer ) == 0 ) mgrInited = true;
366 mgrClock = 0.0;
367 }
368
369 if ( mgrInited )
370 {
371 mgrTimer.tmAddr = NULL;
372 mgrTimer.tmCount = 0;
373 mgrTimer.tmWakeUp = 0;
374 mgrTimer.tmReserved = 0;
375 InsTime( (QElemPtr)&mgrTimer );
376 PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME );
377 }
378 return( mgrClock );
379}
380#endif
381
382/***********************************************************/
383/* Parsytec GCel timer. */
384/* Provided by: Georg Wambach, gw@informatik.uni-koeln.de */
385/***********************************************************/
386#ifdef PARIX
387#include <sys/time.h>
388
389double dtime()
390{
391 double q;
392
393 q = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH;
394
395 return q;
396}
397#endif
398
399/************************************************/
400/* Sun Solaris POSIX dtime() routine */
401/* Provided by: Case Larsen, CTLarsen.lbl.gov */
402/************************************************/
403#ifdef POSIX
404#include <sys/time.h>
405#include <sys/resource.h>
406#include <sys/rusage.h>
407
408#ifdef __hpux
409#include <sys/syscall.h>
410#endif
411
412struct rusage rusage;
413
414double dtime()
415{
416 double q;
417
418 getrusage(RUSAGE_SELF,&rusage);
419
420 q = (double)(rusage.ru_utime.tv_sec);
421 q = q + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09;
422
423 return q;
424}
425#endif
426
427
428/****************************************************/
429/* Windows NT (32 bit) dtime() routine */
430/* Provided by: Piers Haken, piersh@microsoft.com */
431/****************************************************/
432#ifdef WIN32
433#include <windows.h>
434
435double dtime(void)
436{
437 double q;
438
439 q = (double)GetTickCount() * 1.0e-03;
440
441 return q;
442}
443#endif
444
445/*****************************************************/
446/* Time according to POSIX.1 - <J.Pelan@qub.ac.uk> */
447/* Ref: "POSIX Programmer's Guide" O'Reilly & Assoc.*/
448/*****************************************************/
449#ifdef POSIX1
450#define _POSIX_SOURCE 1
451#include <unistd.h>
452#include <limits.h>
453#include <sys/times.h>
454
455struct tms tms;
456
457double dtime()
458{
459 double q;
460 times(&tms);
461 q = (double)tms.tms_utime / (double)CLK_TCK;
462 return q;
463}
464#endif
465/*
466 *************************************************************************
467 *
468 * "DHRYSTONE" Benchmark Program
469 * -----------------------------
470 *
471 * Version: C, Version 2.1
472 *
473 * File: dhry_1.c (part 2 of 3)
474 *
475 * Date: May 25, 1988
476 *
477 * Author: Reinhold P. Weicker
478 *
479 *************************************************************************
480 */
481
482#include <stdio.h>
483#include <stdlib.h>
484#include <string.h>
485#include "dhry.h"
486
487/* Global Variables: */
488
489Rec_Pointer Ptr_Glob,
490 Next_Ptr_Glob;
491int Int_Glob;
492Boolean Bool_Glob;
493char Ch_1_Glob,
494 Ch_2_Glob;
495int Arr_1_Glob [50];
496int Arr_2_Glob [50] [50];
497
498char Reg_Define[] = "Register option selected.";
499
500extern char *malloc ();
501Enumeration Func_1 ();
502 /*
503 forward declaration necessary since Enumeration may not simply be int
504 */
505
506#ifndef ROPT
507#define REG
508 /* REG becomes defined as empty */
509 /* i.e. no register variables */
510#else
511#define REG register
512#endif
513
514
515/* variables for time measurement: */
516
517#define Too_Small_Time 2
518 /* Measurements should last at least 2 seconds */
519
520double Begin_Time,
521 End_Time,
522 User_Time;
523
524double Microseconds,
525 Dhrystones_Per_Second,
526 Vax_Mips;
527
528/* end of variables for time measurement */
529
530/**********************************************************************************************/
531
532
533Proc_1 (Ptr_Val_Par)
534/******************/
535
536REG Rec_Pointer Ptr_Val_Par;
537 /* executed once */
538{
539 REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
540 /* == Ptr_Glob_Next */
541 /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */
542 /* corresponds to "rename" in Ada, "with" in Pascal */
543
544 structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
545 Ptr_Val_Par->variant.var_1.Int_Comp = 5;
546 Next_Record->variant.var_1.Int_Comp
547 = Ptr_Val_Par->variant.var_1.Int_Comp;
548 Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
549 Proc_3 (&Next_Record->Ptr_Comp);
550 /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
551 == Ptr_Glob->Ptr_Comp */
552 if (Next_Record->Discr == Ident_1)
553 /* then, executed */
554 {
555 Next_Record->variant.var_1.Int_Comp = 6;
556 Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
557 &Next_Record->variant.var_1.Enum_Comp);
558 Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
559 Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
560 &Next_Record->variant.var_1.Int_Comp);
561 }
562 else /* not executed */
563 structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
564} /* Proc_1 */
565
566
567Proc_2 (Int_Par_Ref)
568/******************/
569 /* executed once */
570 /* *Int_Par_Ref == 1, becomes 4 */
571
572One_Fifty *Int_Par_Ref;
573{
574 One_Fifty Int_Loc;
575 Enumeration Enum_Loc;
576
577 Int_Loc = *Int_Par_Ref + 10;
578 do /* executed once */
579 if (Ch_1_Glob == 'A')
580 /* then, executed */
581 {
582 Int_Loc -= 1;
583 *Int_Par_Ref = Int_Loc - Int_Glob;
584 Enum_Loc = Ident_1;
585 } /* if */
586 while (Enum_Loc != Ident_1); /* true */
587} /* Proc_2 */
588
589
590Proc_3 (Ptr_Ref_Par)
591/******************/
592 /* executed once */
593 /* Ptr_Ref_Par becomes Ptr_Glob */
594
595Rec_Pointer *Ptr_Ref_Par;
596
597{
598 if (Ptr_Glob != Null)
599 /* then, executed */
600 *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
601 Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
602} /* Proc_3 */
603
604
605Proc_4 () /* without parameters */
606/*******/
607 /* executed once */
608{
609 Boolean Bool_Loc;
610
611 Bool_Loc = Ch_1_Glob == 'A';
612 Bool_Glob = Bool_Loc | Bool_Glob;
613 Ch_2_Glob = 'B';
614} /* Proc_4 */
615
616
617Proc_5 () /* without parameters */
618/*******/
619 /* executed once */
620{
621 Ch_1_Glob = 'A';
622 Bool_Glob = false;
623} /* Proc_5 */
624
625
626 /* Procedure for the assignment of structures, */
627 /* if the C compiler doesn't support this feature */
628#ifdef NOSTRUCTASSIGN
629memcpy (d, s, l)
630register char *d;
631register char *s;
632register int l;
633{
634 while (l--) *d++ = *s++;
635}
636#endif
637
638
639Proc_6 (Enum_Val_Par, Enum_Ref_Par)
640/*********************************/
641 /* executed once */
642 /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
643
644Enumeration Enum_Val_Par;
645Enumeration *Enum_Ref_Par;
646{
647 *Enum_Ref_Par = Enum_Val_Par;
648 if (! Func_3 (Enum_Val_Par))
649 /* then, not executed */
650 *Enum_Ref_Par = Ident_4;
651 switch (Enum_Val_Par)
652 {
653 case Ident_1:
654 *Enum_Ref_Par = Ident_1;
655 break;
656 case Ident_2:
657 if (Int_Glob > 100)
658 /* then */
659 *Enum_Ref_Par = Ident_1;
660 else *Enum_Ref_Par = Ident_4;
661 break;
662 case Ident_3: /* executed */
663 *Enum_Ref_Par = Ident_2;
664 break;
665 case Ident_4: break;
666 case Ident_5:
667 *Enum_Ref_Par = Ident_3;
668 break;
669 } /* switch */
670} /* Proc_6 */
671
672
673Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
674/**********************************************/
675 /* executed three times */
676 /* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */
677 /* Int_Par_Ref becomes 7 */
678 /* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
679 /* Int_Par_Ref becomes 17 */
680 /* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
681 /* Int_Par_Ref becomes 18 */
682One_Fifty Int_1_Par_Val;
683One_Fifty Int_2_Par_Val;
684One_Fifty *Int_Par_Ref;
685{
686 One_Fifty Int_Loc;
687
688 Int_Loc = Int_1_Par_Val + 2;
689 *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
690} /* Proc_7 */
691
692
693Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
694/*********************************************************************/
695 /* executed once */
696 /* Int_Par_Val_1 == 3 */
697 /* Int_Par_Val_2 == 7 */
698Arr_1_Dim Arr_1_Par_Ref;
699Arr_2_Dim Arr_2_Par_Ref;
700int Int_1_Par_Val;
701int Int_2_Par_Val;
702{
703 REG One_Fifty Int_Index;
704 REG One_Fifty Int_Loc;
705
706 Int_Loc = Int_1_Par_Val + 5;
707 Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
708 Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
709 Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
710 for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
711 Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
712 Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
713 Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
714 Int_Glob = 5;
715} /* Proc_8 */
716
717
718Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
719/*************************************************/
720 /* executed three times */
721 /* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
722 /* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
723 /* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
724
725Capital_Letter Ch_1_Par_Val;
726Capital_Letter Ch_2_Par_Val;
727{
728 Capital_Letter Ch_1_Loc;
729 Capital_Letter Ch_2_Loc;
730
731 Ch_1_Loc = Ch_1_Par_Val;
732 Ch_2_Loc = Ch_1_Loc;
733 if (Ch_2_Loc != Ch_2_Par_Val)
734 /* then, executed */
735 return (Ident_1);
736 else /* not executed */
737 {
738 Ch_1_Glob = Ch_1_Loc;
739 return (Ident_2);
740 }
741} /* Func_1 */
742
743
744Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
745/*************************************************/
746 /* executed once */
747 /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
748 /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
749
750Str_30 Str_1_Par_Ref;
751Str_30 Str_2_Par_Ref;
752{
753 REG One_Thirty Int_Loc;
754 Capital_Letter Ch_Loc;
755
756 Int_Loc = 2;
757 while (Int_Loc <= 2) /* loop body executed once */
758 if (Func_1 (Str_1_Par_Ref[Int_Loc],
759 Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
760 /* then, executed */
761 {
762 Ch_Loc = 'A';
763 Int_Loc += 1;
764 } /* if, while */
765 if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
766 /* then, not executed */
767 Int_Loc = 7;
768 if (Ch_Loc == 'R')
769 /* then, not executed */
770 return (true);
771 else /* executed */
772 {
773 if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
774 /* then, not executed */
775 {
776 Int_Loc += 7;
777 Int_Glob = Int_Loc;
778 return (true);
779 }
780 else /* executed */
781 return (false);
782 } /* if Ch_Loc */
783} /* Func_2 */
784
785
786Boolean Func_3 (Enum_Par_Val)
787/***************************/
788 /* executed once */
789 /* Enum_Par_Val == Ident_3 */
790Enumeration Enum_Par_Val;
791{
792 Enumeration Enum_Loc;
793
794 Enum_Loc = Enum_Par_Val;
795 if (Enum_Loc == Ident_3)
796 /* then, executed */
797 return (true);
798 else /* not executed */
799 return (false);
800} /* Func_3 */
801
802/*********************************************************************************/
803
804double dhry_main( int n )
805/*****/
806
807 /* main program, corresponds to procedures */
808 /* Main and Proc_0 in the Ada version */
809{
810 One_Fifty Int_1_Loc;
811 REG One_Fifty Int_2_Loc;
812 One_Fifty Int_3_Loc;
813 REG char Ch_Index;
814 Enumeration Enum_Loc;
815 Str_30 Str_1_Loc;
816 Str_30 Str_2_Loc;
817 REG int Run_Index;
818 REG int Number_Of_Runs;
819
820 FILE *Ap;
821
822 /* Initializations */
823
824/* if ((Ap = fopen("dhry.res","a+")) == NULL)
825 {
826 printf("Can not open dhry.res\n\n");
827 exit(1);
828 }
829*/
830 Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
831 Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
832
833 Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
834 Ptr_Glob->Discr = Ident_1;
835 Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
836 Ptr_Glob->variant.var_1.Int_Comp = 40;
837 strcpy (Ptr_Glob->variant.var_1.Str_Comp,
838 "DHRYSTONE PROGRAM, SOME STRING");
839 strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
840
841 Arr_2_Glob [8][7] = 10;
842 /* Was missing in published program. Without this statement, */
843 /* Arr_2_Glob [8][7] would have an undefined value. */
844 /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
845 /* overflow may occur for this array element. */
846
847/*
848 if (Reg)
849 {
850 printf ("Program compiled with 'register' attribute\n");
851 printf ("\n");
852 }
853 else
854 {
855 printf ("Program compiled without 'register' attribute\n");
856 printf ("\n");
857 }
858*/
859 Number_Of_Runs = n;
860
861 /***************/
862 /* Start timer */
863 /***************/
864
865 Begin_Time = dtime();
866
867 for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
868 {
869
870 Proc_5();
871 Proc_4();
872 /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
873 Int_1_Loc = 2;
874 Int_2_Loc = 3;
875 strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
876 Enum_Loc = Ident_2;
877 Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
878 /* Bool_Glob == 1 */
879 while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
880 {
881 Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
882 /* Int_3_Loc == 7 */
883 Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
884 /* Int_3_Loc == 7 */
885 Int_1_Loc += 1;
886 } /* while */
887 /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
888 Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
889 /* Int_Glob == 5 */
890 Proc_1 (Ptr_Glob);
891 for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
892 /* loop body executed twice */
893 {
894 if (Enum_Loc == Func_1 (Ch_Index, 'C'))
895 /* then, not executed */
896 {
897 Proc_6 (Ident_1, &Enum_Loc);
898 strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
899 Int_2_Loc = Run_Index;
900 Int_Glob = Run_Index;
901 }
902 }
903 /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
904 Int_2_Loc = Int_2_Loc * Int_1_Loc;
905 Int_1_Loc = Int_2_Loc / Int_3_Loc;
906 Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
907 /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
908 Proc_2 (&Int_1_Loc);
909 /* Int_1_Loc == 5 */
910
911 } /* loop "for Run_Index" */
912
913 /**************/
914 /* Stop timer */
915 /**************/
916
917 End_Time = dtime();
918
919/*
920 printf ("Execution ends\n");
921 printf ("\n");
922 printf ("Final values of the variables used in the benchmark:\n");
923 printf ("\n");
924 printf ("Int_Glob: %d\n", Int_Glob);
925 printf (" should be: %d\n", 5);
926 printf ("Bool_Glob: %d\n", Bool_Glob);
927 printf (" should be: %d\n", 1);
928 printf ("Ch_1_Glob: %c\n", Ch_1_Glob);
929 printf (" should be: %c\n", 'A');
930 printf ("Ch_2_Glob: %c\n", Ch_2_Glob);
931 printf (" should be: %c\n", 'B');
932 printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]);
933 printf (" should be: %d\n", 7);
934 printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]);
935 printf (" should be: Number_Of_Runs + 10\n");
936 printf ("Ptr_Glob->\n");
937 printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp);
938 printf (" should be: (implementation-dependent)\n");
939 printf (" Discr: %d\n", Ptr_Glob->Discr);
940 printf (" should be: %d\n", 0);
941 printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
942 printf (" should be: %d\n", 2);
943 printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp);
944 printf (" should be: %d\n", 17);
945 printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp);
946 printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
947 printf ("Next_Ptr_Glob->\n");
948 printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
949 printf (" should be: (implementation-dependent), same as above\n");
950 printf (" Discr: %d\n", Next_Ptr_Glob->Discr);
951 printf (" should be: %d\n", 0);
952 printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
953 printf (" should be: %d\n", 1);
954 printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
955 printf (" should be: %d\n", 18);
956 printf (" Str_Comp: %s\n", Next_Ptr_Glob->variant.var_1.Str_Comp);
957 printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
958 printf ("Int_1_Loc: %d\n", Int_1_Loc);
959 printf (" should be: %d\n", 5);
960 printf ("Int_2_Loc: %d\n", Int_2_Loc);
961 printf (" should be: %d\n", 13);
962 printf ("Int_3_Loc: %d\n", Int_3_Loc);
963 printf (" should be: %d\n", 7);
964 printf ("Enum_Loc: %d\n", Enum_Loc);
965 printf (" should be: %d\n", 1);
966 printf ("Str_1_Loc: %s\n", Str_1_Loc);
967 printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n");
968 printf ("Str_2_Loc: %s\n", Str_2_Loc);
969 printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n");
970 printf ("\n");
971*/
972 User_Time = End_Time - Begin_Time;
973
974 if (User_Time < Too_Small_Time) return -1;
975 else
976 {
977 Microseconds = User_Time * Mic_secs_Per_Second
978 / (double) Number_Of_Runs;
979 Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time;
980 Vax_Mips = Dhrystones_Per_Second / 1757.0;
981
982#ifdef ROPT
983 //printf ("Register option selected? YES\n");
984#else
985 //printf ("Register option selected? NO\n");
986 strcpy(Reg_Define, "Register option not selected.");
987#endif
988 printf ("Microseconds for one run through Dhrystone: ");
989 printf ("%7.1lf \n", Microseconds);
990 printf ("Dhrystones per Second: ");
991 printf ("%10.1lf \n", Dhrystones_Per_Second);
992 printf ("VAX MIPS rating = %10.3lf \n",Vax_Mips);
993 printf ("\n");
994
995 return Dhrystones_Per_Second;
996
997/*
998
999 fprintf(Ap,"\n");
1000 fprintf(Ap,"Dhrystone Benchmark, Version 2.1 (Language: C)\n");
1001 fprintf(Ap,"%s\n",Reg_Define);
1002 fprintf(Ap,"Microseconds for one loop: %7.1lf\n",Microseconds);
1003 fprintf(Ap,"Dhrystones per second: %10.1lf\n",Dhrystones_Per_Second);
1004 fprintf(Ap,"VAX MIPS rating: %10.3lf\n",Vax_Mips);
1005 fclose(Ap);
1006*/
1007
1008 }
1009
1010}
diff --git a/noncore/settings/sysinfo/contrib/dhry.h b/noncore/settings/sysinfo/contrib/dhry.h
new file mode 100644
index 0000000..bef07d5
--- a/dev/null
+++ b/noncore/settings/sysinfo/contrib/dhry.h
@@ -0,0 +1,397 @@
1/*
2 *************************************************************************
3 *
4 * "DHRYSTONE" Benchmark Program
5 * -----------------------------
6 *
7 * Version: C, Version 2.1
8 *
9 * File: dhry.h (part 1 of 3)
10 *
11 * Date: May 25, 1988
12 *
13 * Author: Reinhold P. Weicker
14 * Siemens Nixdorf Inf. Syst.
15 * STM OS 32
16 * Otto-Hahn-Ring 6
17 * W-8000 Muenchen 83
18 * Germany
19 * Phone: [+49]-89-636-42436
20 * (8-17 Central European Time)
21 * UUCP: weicker@ztivax.uucp@unido.uucp
22 * Internet: weicker@ztivax.siemens.com
23 *
24 * Original Version (in Ada) published in
25 * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
26 * pp. 1013 - 1030, together with the statistics
27 * on which the distribution of statements etc. is based.
28 *
29 * In this C version, the following C library functions are
30 * used:
31 * - strcpy, strcmp (inside the measurement loop)
32 * - printf, scanf (outside the measurement loop)
33 *
34 * Collection of Results:
35 * Reinhold Weicker (address see above) and
36 *
37 * Rick Richardson
38 * PC Research. Inc.
39 * 94 Apple Orchard Drive
40 * Tinton Falls, NJ 07724
41 * Phone: (201) 834-1378 (9-17 EST)
42 * UUCP: ...!uunet!pcrat!rick
43 *
44 * Please send results to Rick Richardson and/or Reinhold Weicker.
45 * Complete information should be given on hardware and software
46 * used. Hardware information includes: Machine type, CPU, type and
47 * size of caches; for microprocessors: clock frequency, memory speed
48 * (number of wait states). Software information includes: Compiler
49 * (and runtime library) manufacturer and version, compilation
50 * switches, OS version. The Operating System version may give an
51 * indication about the compiler; Dhrystone itself performs no OS
52 * calls in the measurement loop.
53 *
54 * The complete output generated by the program should be mailed
55 * such that at least some checks for correctness can be made.
56 *
57 *************************************************************************
58 *
59 * History: This version C/2.1 has been made for two reasons:
60 *
61 * 1) There is an obvious need for a common C version of
62 * Dhrystone, since C is at present the most popular system
63 * programming language for the class of processors
64 * (microcomputers, minicomputers) where Dhrystone is used
65 * most. There should be, as far as possible, only one C
66 * version of Dhrystone such that results can be compared
67 * without restrictions. In the past, the C versions
68 * distributed by Rick Richardson (Version 1.1) and by
69 * Reinhold Weicker had small (though not significant)
70 * differences.
71 *
72 * 2) As far as it is possible without changes to the
73 * Dhrystone statistics, optimizing compilers should be
74 * prevented from removing significant statements.
75 *
76 * This C version has been developed in cooperation with
77 * Rick Richardson (Tinton Falls, NJ), it incorporates many
78 * ideas from the "Version 1.1" distributed previously by
79 * him over the UNIX network Usenet.
80 * I also thank Chaim Benedelac (National Semiconductor),
81 * David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
82 * Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
83 * for their help with comments on earlier versions of the
84 * benchmark.
85 *
86 * Changes: In the initialization part, this version follows mostly
87 * Rick Richardson's version distributed via Usenet, not the
88 * version distributed earlier via floppy disk by Reinhold
89 * Weicker. As a concession to older compilers, names have
90 * been made unique within the first 8 characters. Inside the
91 * measurement loop, this version follows the version
92 * previously distributed by Reinhold Weicker.
93 *
94 * At several places in the benchmark, code has been added,
95 * but within the measurement loop only in branches that
96 * are not executed. The intention is that optimizing
97 * compilers should be prevented from moving code out of the
98 * measurement loop, or from removing code altogether. Since
99 * the statements that are executed within the measurement
100 * loop have NOT been changed, the numbers defining the
101 * "Dhrystone distribution" (distribution of statements,
102 * operand types and locality) still hold. Except for
103 * sophisticated optimizing compilers, execution times for
104 * this version should be the same as for previous versions.
105 *
106 * Since it has proven difficult to subtract the time for the
107 * measurement loop overhead in a correct way, the loop check
108 * has been made a part of the benchmark. This does have
109 * an impact - though a very minor one - on the distribution
110 * statistics which have been updated for this version.
111 *
112 * All changes within the measurement loop are described
113 * and discussed in the companion paper "Rationale for
114 * Dhrystone version 2".
115 *
116 * Because of the self-imposed limitation that the order and
117 * distribution of the executed statements should not be
118 * changed, there are still cases where optimizing compilers
119 * may not generate code for some statements. To a certain
120 * degree, this is unavoidable for small synthetic
121 * benchmarks. Users of the benchmark are advised to check
122 * code listings whether code is generated for all statements
123 * of Dhrystone.
124 *
125 * Version 2.1 is identical to version 2.0 distributed via
126 * the UNIX network Usenet in March 1988 except that it
127 * corrects some minor deficiencies that were found by users
128 * of version 2.0. The only change within the measurement
129 * loop is that a non-executed "else" part was added to the
130 * "if" statement in Func_3, and a non-executed "else" part
131 * removed from Proc_3.
132 *
133 *************************************************************************
134 *
135 * Defines: The following "Defines" are possible:
136 * -DROPT (default: Not defined)
137 * As an approximation to what an average C
138 * programmer might do, the "register" storage class
139 * is applied (if enabled by -DROPT)
140 * - for local variables, if they are used
141 * (dynamically) five or more times
142 * - for parameters if they are used (dynamically)
143 * six or more times
144 * Note that an optimal "register" strategy is
145 * compiler-dependent, and that "register"
146 * declarations do not necessarily lead to faster
147 * execution.
148 * -DNOSTRUCTASSIGN (default: Not defined)
149 * Define if the C compiler does not support
150 * assignment of structures.
151 * -DNOENUMS (default: Not defined)
152 * Define if the C compiler does not support
153 * enumeration types.
154 *
155 *************************************************************************
156 *
157 * Compilation model and measurement (IMPORTANT):
158 *
159 * This C version of Dhrystone consists of three files:
160 * - dhry.h (this file, containing global definitions and comments)
161 * - dhry_1.c (containing the code corresponding to Ada package Pack_1)
162 * - dhry_2.c (containing the code corresponding to Ada package Pack_2)
163 *
164 * The following "ground rules" apply for measurements:
165 * - Separate compilation
166 * - No procedure merging
167 * - Otherwise, compiler optimizations are allowed but should be
168 * indicated
169 * - Default results are those without register declarations
170 * See the companion paper "Rationale for Dhrystone Version 2" for a more
171 * detailed discussion of these ground rules.
172 *
173 * For 16-Bit processors (e.g. 80186, 80286), times for all compilation
174 * models ("small", "medium", "large" etc.) should be given if possible,
175 * together with a definition of these models for the compiler system
176 * used.
177 *
178 *************************************************************************
179 *
180 * Dhrystone (C version) statistics:
181 *
182 * [Comment from the first distribution, updated for version 2.
183 * Note that because of language differences, the numbers are slightly
184 * different from the Ada version.]
185 *
186 * The following program contains statements of a high level programming
187 * language (here: C) in a distribution considered representative:
188 *
189 * assignments 52 (51.0 %)
190 * control statements 33 (32.4 %)
191 * procedure, function calls 17 (16.7 %)
192 *
193 * 103 statements are dynamically executed. The program is balanced with
194 * respect to the three aspects:
195 *
196 * - statement type
197 * - operand type
198 * - operand locality
199 * operand global, local, parameter, or constant.
200 *
201 * The combination of these three aspects is balanced only approximately.
202 *
203 * 1. Statement Type:
204 * ----------------- number
205 *
206 * V1 = V2 9
207 * (incl. V1 = F(..)
208 * V = Constant 12
209 * Assignment, 7
210 * with array element
211 * Assignment, 6
212 * with record component
213 * --
214 * 34 34
215 *
216 * X = Y +|-|"&&"|"|" Z 5
217 * X = Y +|-|"==" Constant 6
218 * X = X +|- 1 3
219 * X = Y *|/ Z 2
220 * X = Expression, 1
221 * two operators
222 * X = Expression, 1
223 * three operators
224 * --
225 * 18 18
226 *
227 * if .... 14
228 * with "else" 7
229 * without "else" 7
230 * executed 3
231 * not executed 4
232 * for ... 7 | counted every time
233 * while ... 4 | the loop condition
234 * do ... while 1 | is evaluated
235 * switch ... 1
236 * break 1
237 * declaration with 1
238 * initialization
239 * --
240 * 34 34
241 *
242 * P (...) procedure call 11
243 * user procedure 10
244 * library procedure 1
245 * X = F (...)
246 * function call 6
247 * user function 5
248 * library function 1
249 * --
250 * 17 17
251 * ---
252 * 103
253 *
254 * The average number of parameters in procedure or function calls
255 * is 1.82 (not counting the function values as implicit parameters).
256 *
257 *
258 * 2. Operators
259 * ------------
260 * number approximate
261 * percentage
262 *
263 * Arithmetic 32 50.8
264 *
265 * + 21 33.3
266 * - 7 11.1
267 * * 3 4.8
268 * / (int div) 1 1.6
269 *
270 * Comparison 27 42.8
271 *
272 * == 9 14.3
273 * /= 4 6.3
274 * > 1 1.6
275 * < 3 4.8
276 * >= 1 1.6
277 * <= 9 14.3
278 *
279 * Logic 4 6.3
280 *
281 * && (AND-THEN) 1 1.6
282 * | (OR) 1 1.6
283 * ! (NOT) 2 3.2
284 *
285 * -- -----
286 * 63 100.1
287 *
288 *
289 * 3. Operand Type (counted once per operand reference):
290 * ---------------
291 * number approximate
292 * percentage
293 *
294 * Integer 175 72.3 %
295 * Character 45 18.6 %
296 * Pointer 12 5.0 %
297 * String30 6 2.5 %
298 * Array 2 0.8 %
299 * Record 2 0.8 %
300 * --- -------
301 * 242 100.0 %
302 *
303 * When there is an access path leading to the final operand (e.g. a
304 * record component), only the final data type on the access path is
305 * counted.
306 *
307 *
308 * 4. Operand Locality:
309 * -------------------
310 * number approximate
311 * percentage
312 *
313 * local variable 114 47.1 %
314 * global variable 22 9.1 %
315 * parameter 45 18.6 %
316 * value 23 9.5 %
317 * reference 22 9.1 %
318 * function result 6 2.5 %
319 * constant 55 22.7 %
320 * --- -------
321 * 242 100.0 %
322 *
323 *
324 * The program does not compute anything meaningful, but it is
325 * syntactically and semantically correct. All variables have a value
326 * assigned to them before they are used as a source operand.
327 *
328 * There has been no explicit effort to account for the effects of a
329 * cache, or to balance the use of long or short displacements for code
330 * or data.
331 *
332 *************************************************************************
333 */
334
335/* Compiler and system dependent definitions: */
336
337#define Mic_secs_Per_Second 1000000.0
338 /* Berkeley UNIX C returns process times in seconds/HZ */
339
340#ifdef NOSTRUCTASSIGN
341#define structassign(d, s) memcpy(&(d), &(s), sizeof(d))
342#else
343#define structassign(d, s) d = s
344#endif
345
346#ifdef NOENUM
347#define Ident_1 0
348#define Ident_2 1
349#define Ident_3 2
350#define Ident_4 3
351#define Ident_5 4
352 typedef int Enumeration;
353#else
354 typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
355 Enumeration;
356#endif
357 /* for boolean and enumeration types in Ada, Pascal */
358
359/* General definitions: */
360
361#include <stdio.h>
362 /* for strcpy, strcmp */
363
364#define Null 0
365 /* Value of a Null pointer */
366#define true 1
367#define false 0
368
369typedef int One_Thirty;
370typedef int One_Fifty;
371typedef char Capital_Letter;
372typedef int Boolean;
373typedef char Str_30 [31];
374typedef int Arr_1_Dim [50];
375typedef int Arr_2_Dim [50] [50];
376
377typedef struct record
378 {
379 struct record *Ptr_Comp;
380 Enumeration Discr;
381 union {
382 struct {
383 Enumeration Enum_Comp;
384 int Int_Comp;
385 char Str_Comp [31];
386 } var_1;
387 struct {
388 Enumeration E_Comp_2;
389 char Str_2_Comp [31];
390 } var_2;
391 struct {
392 char Ch_1_Comp;
393 char Ch_2_Comp;
394 } var_3;
395 } variant;
396 } Rec_Type, *Rec_Pointer;
397
diff --git a/noncore/settings/sysinfo/fft.c b/noncore/settings/sysinfo/contrib/fft.c
index 01a1b26..01a1b26 100644
--- a/noncore/settings/sysinfo/fft.c
+++ b/noncore/settings/sysinfo/contrib/fft.c
diff --git a/noncore/settings/sysinfo/sysinfo.pro b/noncore/settings/sysinfo/sysinfo.pro
index 4baae12..d50f5ed 100644
--- a/noncore/settings/sysinfo/sysinfo.pro
+++ b/noncore/settings/sysinfo/sysinfo.pro
@@ -1,3 +1,4 @@
1CONFIG = qt warn_on release quick-app 1CONFIG = qt warn_on release quick-app
2HEADERS = memory.h \ 2HEADERS = \
3 memory.h \
3 graph.h \ 4 graph.h \
@@ -8,2 +9,3 @@ HEADERS = memory.h \
8 detail.h \ 9 detail.h \
10 contrib/dhry.h \
9 benchmarkinfo.h \ 11 benchmarkinfo.h \
@@ -19,3 +21,4 @@ SOURCES = main.cpp \
19 detail.cpp \ 21 detail.cpp \
20 benchmarkinfo.cpp fft.c \ 22 contrib/dhry.c contrib/fft.c \
23 benchmarkinfo.cpp \
21 versioninfo.cpp \ 24 versioninfo.cpp \
@@ -26,3 +29,3 @@ DEPENDPATH += $(OPIEDIR)/include
26LIBS += -lqpe -lopiecore2 -lopieui2 29LIBS += -lqpe -lopiecore2 -lopieui2
27 30DEFINES += UNIX
28TARGET = sysinfo 31TARGET = sysinfo