?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
some format fixes in order to get it compile for m68k, tested with i386 as well.
[AROS-Contrib.git] / DiskSpeed / diskspeed / DiskSpeed.c
blob0c7c1b85b0b76ed79ae6aff7e1a2e578ef27f636
1 /*
2 Copyright © 1995-2016, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Disk subsystem Benchmarking Utility..
6 Lang: English.
7
8 Based on DiskSpeed v4.2 by Michael Sinz
9 */
10
11 /*********************************************************************************************/
12
13 #ifndef PROTO_ALIB_H
14 # include <proto/alib.h>
15 #endif
16
17 #ifndef PROTO_ICON_H
18 # include <proto/icon.h>
19 #endif
20
21 #ifndef PROTO_EXEC_H
22 # include <proto/exec.h>
23 #endif
24
25 #ifndef PROTO_DOS_H
26 # include <proto/dos.h>
27 #endif
28
29 #ifndef PROTO_TIMER_H
30 # include <proto/timer.h>
31 #endif
32
33 #ifndef PROTO_UTILITY_H
34 # include <proto/utility.h>
35 #endif
36
37 #ifndef PROTO_INTUITION_H
38 # include <proto/intuition.h>
39 #endif
40
41 #ifndef PROTO_GRAPHICS_H
42 # include <proto/graphics.h>
43 #endif
44
45 #ifndef PROTO_MUIMASTER_H
46 # include <proto/muimaster.h>
47 #endif
48
49 #ifndef PROTO_LAYERS_H
50 # include <proto/layers.h>
51 #endif
52
53 /*********************************************************************************************/
54
55 #include <exec/resident.h>
56 #include <exec/execbase.h>
57
58 #include <libraries/coolimages.h>
59 #include <libraries/mui.h>
60
61 #include <zune/customclasses.h>
62 #include <zune/aboutwindow.h>
63
64 #include <aros/locale.h>
65
66 #include <exec/io.h>
67 #include <exec/ports.h>
68 #include <devices/timer.h>
69 #include <dos/dos.h>
70 #include <dos/dosextens.h>
71 #include <devices/trackdisk.h>
72 #include <intuition/intuition.h>
73 #include <intuition/gadgetclass.h>
74 #include <intuition/screens.h>
75 #include <workbench/workbench.h>
76 #include <workbench/startup.h>
77
78 #include <clib/exec_protos.h>
79 #include <clib/dos_protos.h>
80 #include <clib/timer_protos.h>
81 #include <clib/intuition_protos.h>
82 #include <clib/icon_protos.h>
83
84 /*********************************************************************************************/
85
86 struct DiskSpeedMUI_Intern {
87 BOOL app_ret_val;
88 Object *disk_app; /* our application itself.. */
89 Object *disk_main_win; /* The Main Benchmark Window */
90 Object *disk_config_win; /* The Configuration Window */
91 Object *disk_about_win; /* The Main Benchmark Window */
92
93 Object *about_item;
94 Object *quit_item;
95
96 Object *welctext;
97
98 Object *devicestr;
99 Object *commentstr;
100
101 Object *resultlv;
102
103 Object *configobj; /* Open Config Window gadget */
104 Object *beginobj;
105 Object *stopobj;
106 Object *saveobj;
107
108 Object *conokobj; /* Configuration Windows OK gadget */
109 Object *consaveobj; /* Configuration Windows Save gadget */
110 Object *conuseobj; /* Configuration Windows Use gadget */
111 Object *concancelobj; /* Configuration Windows Cancel gadget */
112 };
113
114 struct DiskSpeedConfig_Intern {
115 #ifndef SCSI_SPEED
116 Object *dir_checkmark; /* Benchmark Configuration Option Objects */
117 #endif
118 Object *seek_checkmark;
119 Object *nocpu_checkmark;
120 Object *mintime;
121
122 Object *buffer1;
123 Object *buffer2;
124 Object *buffer3;
125 Object *buffer4;
126
127 Object *long_checkmark;
128 Object *word_checkmark;
129 Object *byte_checkmark;
130
131 Object *fast_checkmark;
132 Object *chip_checkmark;
133 };
134
135 struct DiskSpeedMUI_Intern diskspeedmui_intern;
136 struct DiskSpeedConfig_Intern diskspeedmui_config;
137
138 enum
139 {
140 RETURNID_BEGIN = 1,
141 RETURNID_STOP,
142 RETURNID_SAVE,
143 RETURNID_SAVECONFIG,
144 RETURNID_USECONFIG,
145 };
146
147 /*********************************************************************************************/
148
149 #include <limits.h>
150 #include <string.h>
151 #include <stdio.h>
152
153 #undef DEBUG
154 #define DEBUG 1
155 # include <aros/debug.h>
156
157 /*********************************************************************************************/
158
159 #ifdef SCSI_SPEED
160 # include "ScsiSpeed_rev.h"
161 #else
162 # include "DiskSpeed_rev.h"
163 #endif /* SCSI_SPEED */
164
165 /*********************************************************************************************/
166
167 #define VERS APPNAME " 4.10"
168 #define VSTRING APPNAME " 4.10 (" DATE ")\n\r"
169 #define VERSTAG "\0$VER: " APPNAME " 4.10 (" DATE ")"
170 #define CXVERSION VERS " (" DATE ")"
171 #define STR_SEPERATOR "------------------------------------------------------------------"
172
173 const char COPYRIGHT[] = "Aros " VERS " Copyright © 2004-2016 The AROS Development Team" VERSTAG;
174
175 #ifdef SCSI_SPEED
176 # define MSG_BYTES_READ MSG_BYTES_READ_S
177 const char RESULTS_FILE[] = APPNAME ".Results";
178 #else
179 # define MSG_BYTES_READ MSG_BYTES_READ_N
180 const char FILE_STRING[] = "%04lx " APPNAME " Test File ";
181 const char TEST_DIR[] = " " APPNAME " Test Directory ";
182 const char RESULTS_FILE[] = APPNAME ".Results";
183 #endif /* SCSI_SPEED */
184
185 /*********************************************************************************************/
186 /*
187 Timer related stuff...
188 */
189
190 struct SpeedTimer
191 {
192 struct MsgPort *tmPort;
193 struct timerequest *tmReq;
194 struct timeval tmVal;
195
196 LONG Open;
197 };
198
199 /*********************************************************************************************/
200 /*
201 Our Disk/ScsiSpeed global structure...
202 */
203
204 struct DiskSpeed
205 {
206 struct Window *Window; /* The DiskSpeed window... */
207 struct RenderInfo *ri; /* MKSoft Render Info */
208
209 #ifdef SCSI_SPEED
210
211 struct IOExtTD DiskIO; /* Disk IO request */
212
213 #endif /* SCSI_SPEED */
214
215 BPTR Output; /* The output file handle! */
216 struct Process *Me; /* Pointer to my process... */
217 struct SpeedTimer *timer; /* Pointer to a timer structure */
218
219 #ifndef SCSI_SPEED
220
221 struct FileInfoBlock *fib; /* Pointer to a FileInfoBlock */
222
223 #endif /* !SCSI_SPEED */
224
225 /* */
226 struct MinList TextList; /* The list the results test is linked to... */
227 struct DisplayList *List; /* The "List" gadget */
228 /* */
229 ULONG Min_Time; /* Minimum tmVal in seconds for a test */
230 ULONG Base_CPU; /* Base CPU available... */
231 ULONG CPU_Total; /* Sum of CPU availability */
232 ULONG CPU_Count; /* Count of CPU availability */
233
234 /* Testing parameters */
235 unsigned short HighDMA; /* Set to TRUE for high video DMA... */
236 unsigned short Test_DIR; /* Set to test directory stuff */
237 unsigned short Test_SEEK; /* Set to test SEEK/READ */
238 unsigned short pad;
239
240 ULONG Align_Types; /* Set bits of alignment types... */
241 ULONG Mem_TYPES; /* Set memory type flags to test... */
242 ULONG Test_Size[4]; /* The four test sizes... */
243
244 short StringVectors[5*2*4];
245 short ActionVectors[5*2*2];
246
247 /* */
248 char Device[256]; /* Device name under test... */
249 char Comments[256]; /* Comments string gadget... */
250 char Undo[256]; /* Our one UNDO buffer... */
251
252 /* */
253 char CPU_Type[22]; /* Processor name in this string (plus NULL) */
254 char Exec_Ver[14]; /* Version of Exec */
255
256 /* */
257 char tmp1[128]; /* Temporary buffer space... */
258 char tmp2[128]; /* Temporary buffer space... */
259 };
260
261 struct DiskSpeed *global;
262
263 /*********************************************************************************************/
264
265 #define DEVICE_GADGET 1
266 #define COMMENT_GADGET 2
267 #define TEST_GADGET 3
268 #define SAVE_GADGET 4
269 #define STOP_GADGET 5
270
271 /*********************************************************************************************/
272 /*
273 This is the minimum timeval for test that can be extended/shorted automatically
274 This number should not be set too low otherwise the test results will be
275 inaccurate due to timer granularity. (in seconds)
276 */
277
278 #ifdef SCSI_SPEED
279
280 #define MIN_TEST_TIME 20
281
282 #else /* SCSI_SPEED */
283
284 #define MIN_TEST_TIME 8
285 #define NUM_FILES 200
286
287 #endif /* SCSI_SPEED */
288
289 /*********************************************************************************************/
290 /*
291 This section of code is used to test CPU availability.
292 */
293
294 struct CPU_AVAIL
295 {
296 ULONG _CPU_Use_Base; /* Set to TRUE in order to use CPU... */
297 ULONG _CPU_State_Flag; /* Used to control this routine... */
298 ULONG _CPU_Count_Low; /* The low-order word for CPU count */
299 ULONG _CPU_Count_High; /* The high-order word for CPU count */
300 ULONG CPU_Task; /* The task pointer... */
301 };
302
303 struct Task *Init_CPU_Available( struct CPU_AVAIL *CPU_AVAIL_struct );
304 void Free_CPU_Available( struct CPU_AVAIL *CPU_AVAIL_struct );
305 void CPU_Calibrate( struct CPU_AVAIL *CPU_AVAIL_struct );
306
307 /*********************************************************************************************/
308 unsigned short BusyPointer[36] =
309 {
310 0x0000, 0x0000, 0x0400, 0x07C0, 0x0000, 0x07C0, 0x0100, 0x0380, 0x0000,
311 0x07E0, 0x07C0, 0x1FF8, 0x1FF0, 0x3FEC, 0x3FF8, 0x7FDE, 0x3FF8, 0x7FBE,
312 0x7FFC, 0xFF7F, 0x7EFC, 0xFFFF, 0x7FFC, 0xFFFF, 0x3FF8, 0x7FFE, 0x3FF8,
313 0x7FFE, 0x1FF0, 0x3FFC, 0x07C0, 0x1FF8, 0x0000, 0x07E0, 0x0000, 0x0000
314 };
315
316 /*
317 These two defines set up and clear the BusyPointer...
318 */
319
320 #define SetWait(x) SetPointer(x,BusyPointer,16L,16L,-6L,0L)
321 #define ClearWait(x) ClearPointer(x)
322
323 #if !defined(__AROS__)
324 /*********************************************************************************************/
325 static struct Catalog *MyCatalog;
326
327 static char *GetString(LONG num)
328 {
329 const struct CatCompArrayType *x = CatCompArray;
330 STRPTR s;
331
332 for (;;)
333 {
334 if (x->cca_ID == num)
335 {
336 s = x->cca_Str;
337 break;
338 }
339 x++;
340 }
341 s = GetCatalogStr(MyCatalog, num, s);
342 return s;
343 }
344 #endif
345
346 static IPTR getv(APTR obj, ULONG tag)
347 {
348 IPTR x;
349 GetAttr(tag, obj, &x);
350 return x;
351 }
352
353 /*********************************************************************************************/
354 /*********************************************************************************************/
355 /*********************************************************************************************/
356 /*
357 This routine returns the amount of timeval in the timer...
358 The number returned is in Seconds...
359 */
360
361 static ULONG Read_Timer(struct SpeedTimer *spt)
362 {
363 struct Library *TimerBase = (struct Library *)(spt->tmReq->tr_node.io_Device);
364
365 /* Get the current timeval... */
366 spt->tmReq->tr_node.io_Command = TR_GETSYSTIME;
367 spt->tmReq->tr_node.io_Flags = IOF_QUICK;
368 DoIO((struct IORequest *)(spt->tmReq));
369
370 /* Subtract last timer result and store as the timer result */
371 SubTime(&(spt->tmReq->tr_time),&(spt->tmVal));
372 return(spt->tmReq->tr_time.tv_secs);
373 }
374
375 /*
376 Start the timer...
377 */
378
379 static void Start_Timer(struct SpeedTimer *spt)
380 {
381 /* Get the current timeval... */
382 spt->tmReq->tr_node.io_Command = TR_GETSYSTIME;
383 spt->tmReq->tr_node.io_Flags = IOF_QUICK;
384 DoIO((struct IORequest *)(spt->tmReq));
385
386 /* Store current timeval as the timer result */
387 spt->tmVal = spt->tmReq->tr_time;
388
389 /*
390 This here is a nasty trick... Since the timer device
391 has a low resolution, we wait until we get to the exact
392 cross-over from one TICK to the next. We know that the
393 tick value is larger than 10 so if the difference
394 between two calls to the timer is > 10 then it must
395 have been a TICK that just went through. This is
396 not "friendly" code but since we are testing the system
397 and it is not "application" code, it is not a problem.
398 */
399
400 while ((spt->tmReq->tr_time.tv_micro-spt->tmVal.tv_micro) < 10)
401 {
402 /* Store current timeval as the timer result */
403 spt->tmVal = spt->tmReq->tr_time;
404
405 /* Get the current timeval... */
406 spt->tmReq->tr_node.io_Command = TR_GETSYSTIME;
407 spt->tmReq->tr_node.io_Flags = IOF_QUICK;
408 DoIO((struct IORequest *)(spt->tmReq));
409 }
410
411 /* Store current timeval as the timer result */
412 spt->tmVal = spt->tmReq->tr_time;
413 }
414
415 /*
416 Stop the timer...
417 */
418
419 static void Stop_Timer(struct SpeedTimer *spt)
420 {
421 struct Library *TimerBase = (struct Library *)(spt->tmReq->tr_node.io_Device);
422
423 /* Get the current timeval. */
424 spt->tmReq->tr_node.io_Command = TR_GETSYSTIME;
425 spt->tmReq->tr_node.io_Flags = IOF_QUICK;
426
427 DoIO((struct IORequest *)(spt->tmReq));
428
429 /* Subtract last timer result and store as the timer result */
430 SubTime(&(spt->tmReq->tr_time),&(spt->tmVal));
431 spt->tmVal=spt->tmReq->tr_time;
432 }
433
434 /*
435 Free a SpeedTimer structure as best as possible. Do all of the error checks
436 here since this will also be called for partial timer initializations.
437 */
438
439 static void Free_Timer(struct SpeedTimer *spt)
440 {
441 if (spt)
442 {
443 if (spt->tmPort)
444 {
445 if (spt->tmReq)
446 {
447 if (spt->Open) CloseDevice((struct IORequest *)(spt->tmReq));
448 DeleteIORequest((struct IORequest *)(spt->tmReq));
449 }
450 DeleteMsgPort(spt->tmPort);
451 }
452 FreeMem(spt,sizeof(struct SpeedTimer));
453 }
454 }
455
456 /*
457 Initialize a SpeedTimer structure. It will return NULL if it did not work.
458 */
459
460 static struct SpeedTimer *Init_Timer(void)
461 {
462 struct SpeedTimer *spt;
463
464 if ((spt = AllocMem(sizeof(struct SpeedTimer),MEMF_PUBLIC|MEMF_CLEAR)))
465 {
466 spt->Open = FALSE;
467 if ((spt->tmPort = CreateMsgPort()))
468 {
469 if ((spt->tmReq = (struct timerequest *)CreateIORequest(spt->tmPort,sizeof(struct timerequest))))
470 {
471 if (!OpenDevice(TIMERNAME,UNIT_MICROHZ,(struct IORequest *)(spt->tmReq),0L)) spt->Open = TRUE;
472 }
473 }
474 if (!(spt->Open))
475 {
476 Free_Timer(spt);
477 spt = NULL;
478 }
479 }
480 return(spt);
481 }
482
483 /*
484 Now, for the routines that will pull in the lines and display them as
485 needed in the display...
486 */
487
488 static void AddDisplayLine(struct DiskSpeed *global,const char *line)
489 {
490 ULONG size = strlen(line);
491
492 if (diskspeedmui_intern.disk_main_win) /* add the line to the zune listview */
493 {
494 DoMethod(diskspeedmui_intern.resultlv, MUIM_List_InsertSingle, (IPTR)line, MUIV_List_Insert_Bottom);
495 DoMethod(diskspeedmui_intern.resultlv, MUIM_List_Jump, 0x7fffffff);
496 DoMethod(diskspeedmui_intern.disk_app, MUIM_Application_CheckRefresh);
497 }
498 else if (global->Output)
499 {
500 Write(global->Output,(APTR)line,size);
501 Write(global->Output,"\n",1);
502 }
503 }
504
505 /*...*/
506
507 static LONG Check_Quit(struct DiskSpeed *global)
508 {
509 LONG worked = TRUE;
510
511 if (SetSignal(0,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C) worked = FALSE;
512
513 if (!worked) AddDisplayLine(global,GetString(MSG_USERINT));
514
515 return(worked);
516 }
517
518 /*
519 It knows that the Y value is fixed point by n-digits...
520 */
521
522 static ULONG MaxDivide(ULONG x,ULONG y,ULONG digits)
523 {
524 ULONG result;
525 ULONG num = 0; /* Number of 10 units adjusted for so far */
526
527 while ((x<399999999) && (num<digits))
528 {
529 x *= 10;
530 num++;
531 }
532
533 while (num<digits)
534 {
535 num++;
536 if (num == digits) y+=5; /* Round it if last digit... */
537 y = y/10;
538 }
539
540 if (y) result = x/y;
541 else result = -1; /* MAX INT if y=0 */
542
543 return(result);
544 }
545
546 /*
547 Build a string and add it to the display of results.
548 This routine knows how to take the timer results and the CPU
549 results and format them into a string with the given header
550 and the given unit of measure.
551 */
552
553 static VOID Display_Result(struct DiskSpeed *global,const char *Header,ULONG number,const char *Units, struct CPU_AVAIL *CPU_AVAIL_struct)
554 {
555 char *st_string = global->tmp1;
556 char format[48];
557 ULONG clicks = 0; /* To figure out the number of clicks/second */
558 ULONG tmVal;
559 ULONG tmp_time;
560
561 /* First, make sure (as best as possible) that the CPU values are right */
562 CPU_AVAIL_struct->_CPU_State_Flag = TRUE;
563 Delay(1); /* Let it run into the TRUE _CPU_State_Flag */
564
565 /* 1,000,000 micro = 1 second... */
566 tmVal = (global->timer->tmVal.tv_secs * 1000000) + global->timer->tmVal.tv_micro;
567 /* tmVal is now in micro seconds... */
568
569 number=MaxDivide(number,tmVal,6);
570
571 strcpy(format,"%s %9ld %s");
572 if (!number)
573 {
574 strcpy(format,"%s < %ld %s");
575 number = 1;
576 }
577
578 if (global->Base_CPU)
579 {
580 tmp_time = tmVal; /* For below... */
581
582 while (CPU_AVAIL_struct->_CPU_Count_High)
583 {
584 /* Adjust the tmVal and the CPU count as needed */
585 tmp_time = tmp_time >> 1;
586 CPU_AVAIL_struct->_CPU_Count_Low = CPU_AVAIL_struct->_CPU_Count_Low >> 1;
587 if (CPU_AVAIL_struct->_CPU_Count_High & 1) CPU_AVAIL_struct->_CPU_Count_Low += 0x80000000;
588 CPU_AVAIL_struct->_CPU_Count_High = CPU_AVAIL_struct->_CPU_Count_High >> 1;
589 }
590
591 clicks = MaxDivide(CPU_AVAIL_struct->_CPU_Count_Low,tmp_time,6);
592 clicks = (MaxDivide(clicks,global->Base_CPU,3)+5)/10;
593 global->CPU_Total += clicks;
594 global->CPU_Count++;
595
596 strcat(format,GetString(MSG_CPUAVAIL));
597 }
598
599 sprintf(st_string,format,Header,number,Units,clicks);
600
601 AddDisplayLine(global,st_string);
602 }
603
604 static VOID Display_Error(struct DiskSpeed *global,const char *test)
605 {
606 sprintf(global->tmp1,GetString(MSG_ERR_FAIL),test);
607 AddDisplayLine(global,global->tmp1);
608 }
609
610 #ifdef SCSI_SPEED
611
612 static BOOL SpeedTest(struct DiskSpeed *global,ULONG size,ULONG offset,ULONG mem_type, struct CPU_AVAIL *CPU_AVAIL_struct)
613 {
614 BOOL worked=TRUE;
615 char *buffer;
616 char *mem; /* What we really allocated */
617 char *type;
618 char *type2;
619 ULONG count;
620
621 AddDisplayLine(global,"");
622
623 type = "FAST";
624 if (mem_type & MEMF_CHIP) type = "CHIP";
625
626 type2 = "LONG";
627 if (offset & 2) type2 = "WORD";
628 if (offset & 1) type2 = "BYTE";
629
630 /* Round to block sizes */
631 size = (size+511) & (~511);
632
633 if ((mem = AllocMem(size+offset,mem_type|MEMF_PUBLIC)))
634 {
635 /* Set up memory... */
636 buffer = &(mem[offset]);
637
638 sprintf(global->tmp1,GetString(MSG_TSTBUFF),size,type,type2);
639 AddDisplayLine(global,global->tmp1);
640
641 count = 0;
642
643 Start_Timer(global->timer);
644 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
645 while ((worked &= Check_Quit(global)) && (Read_Timer(global->timer) < global->Min_Time))
646 {
647 global->DiskIO.iotd_Req.io_Command = CMD_READ;
648 global->DiskIO.iotd_Req.io_Flags = 0;
649 global->DiskIO.iotd_Req.io_Length = size;
650 global->DiskIO.iotd_Req.io_Data = buffer;
651 global->DiskIO.iotd_Req.io_Offset = count;
652
653 DoIO((struct IORequest *)&global->DiskIO);
654 count += global->DiskIO.iotd_Req.io_Actual;
655
656 if (global->DiskIO.iotd_Req.io_Error)
657 {
658 worked = FALSE;
659 Display_Error(global,GetString(MSG_ERR_RDEV));
660 }
661 }
662 Stop_Timer(global->timer);
663
664 if (worked) Display_Result(global,GetString(MSG_BYTES_READ),count,GetString(MSG_BYTE_UNITS), CPU_AVAIL_struct);
665
666 Free_CPU_Available(CPU_AVAIL_struct);
667 FreeMem(mem,size+offset);
668 }
669 else
670 {
671 sprintf(global->tmp1,GetString(MSG_SKIPMEM),size,type);
672 AddDisplayLine(global,global->tmp1);
673 }
674
675 return(worked);
676 }
677
678 #else /* SCSI_SPEED */
679
680 /*
681 In order to keep the file create test fair, it must always do
682 the same number of files. The way filing systems work, many times
683 the get slower as the number of files in a directory grow
684 */
685
686 static LONG CreateFileTest(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
687 {
688 BPTR file;
689 ULONG count;
690 LONG worked = TRUE;
691 STRPTR st_string = global->tmp1; /* For speed reasons */
692
693 Start_Timer(global->timer);
694 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
695
696 for (count=0;(count<NUM_FILES) && (worked &= Check_Quit(global));count++)
697 {
698 sprintf(st_string,FILE_STRING,(unsigned long)count);
699 if (file = Open(st_string,MODE_NEWFILE)) Close(file);
700 else
701 {
702 Display_Error(global,GetString(MSG_ERR_CFILE));
703 worked = FALSE;
704 }
705 }
706
707 Stop_Timer(global->timer);
708
709 if (worked) Display_Result(global,GetString(MSG_FILE_CREATE),NUM_FILES,GetString(MSG_FILE_UNITS), CPU_AVAIL_struct);
710
711 Free_CPU_Available(CPU_AVAIL_struct);
712
713 return(worked);
714 }
715
716 static LONG OpenFileTest(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
717 {
718 BPTR file;
719 ULONG count = 0;
720 LONG worked = TRUE;
721 STRPTR st_string = global->tmp1;
722
723 Start_Timer(global->timer);
724 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
725 while ((worked &= Check_Quit(global)) && (Read_Timer(global->timer) < global->Min_Time))
726 {
727 sprintf(st_string,FILE_STRING,(unsigned long)(count % NUM_FILES));
728 count++;
729 if (file=Open(st_string,MODE_OLDFILE)) Close(file);
730 else
731 {
732 Display_Error(global,GetString(MSG_ERR_OFILE));
733 worked = FALSE;
734 }
735 }
736 Stop_Timer(global->timer);
737
738 if (worked) Display_Result(global,GetString(MSG_FILE_OPEN),count,GetString(MSG_FILE_UNITS), CPU_AVAIL_struct);
739
740 Free_CPU_Available(CPU_AVAIL_struct);
741 return(worked);
742 }
743
744 static LONG ScanDirectoryTest(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
745 {
746 BPTR lock = BNULL;
747 ULONG count = 0;
748 LONG worked = TRUE;
749
750 Start_Timer(global->timer);
751 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
752 while ((worked &= Check_Quit(global)) && (Read_Timer(global->timer) < global->Min_Time))
753 {
754 if (lock)
755 {
756 if (!ExNext(lock,global->fib)) lock = BNULL;
757 else count++;
758 }
759 else
760 {
761 CurrentDir(lock = CurrentDir(NULL));
762 if (Examine(lock,global->fib)) count++;
763 else
764 {
765 Display_Error(global,GetString(MSG_ERR_DIRSCAN));
766 worked = FALSE;
767 }
768 }
769 }
770 Stop_Timer(global->timer);
771
772 if (worked) Display_Result(global,GetString(MSG_FILE_SCAN),count,GetString(MSG_FILE_UNITS), CPU_AVAIL_struct);
773
774 Free_CPU_Available(CPU_AVAIL_struct);
775 return(worked);
776 }
777
778 /*
779 In order to keep the file delete test fair, it must always do
780 the same number of files. The way filing systems work, many times
781 the get slower as the number of files in a directory grow
782 */
783
784 static LONG DeleteFileTest(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
785 {
786 ULONG count;
787 LONG worked = TRUE;
788 STRPTR st_string = global->tmp1;
789
790 Start_Timer(global->timer);
791 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
792
793 for (count = 0;(count<NUM_FILES) && (worked &= Check_Quit(global));count++)
794 {
795 sprintf(st_string,FILE_STRING,(unsigned long)count);
796 if (!DeleteFile(st_string))
797 {
798 Display_Error(global,GetString(MSG_ERR_DFILE));
799 worked=FALSE;
800 }
801 }
802
803 Stop_Timer(global->timer);
804
805 if (worked) Display_Result(global,GetString(MSG_FILE_DELETE),NUM_FILES,GetString(MSG_FILE_UNITS), CPU_AVAIL_struct);
806
807 Free_CPU_Available(CPU_AVAIL_struct);
808
809 return(worked);
810 }
811
812 static LONG SeekReadTest(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
813 {
814 BPTR file;
815 ULONG size;
816 ULONG count;
817 LONG pos = 0;
818 LONG buffer[16];
819 LONG worked = FALSE;
820 void *buf;
821
822 /* First we build a file by writing the ROM to disk... */
823 if (file = Open(FILE_STRING,MODE_NEWFILE))
824 {
825 size = 0x40000; /* Start by asking for 256K */
826 while (size && (!(buf = AllocMem(size,MEMF_PUBLIC)))) size = size>>1;
827
828 if (buf)
829 {
830 worked = TRUE;
831 /* Write a 256K file... */
832 count = 0x40000/size;
833 while ((count>0) && (worked&=Check_Quit(global)))
834 {
835 count--;
836 if (size != Write(file,buf,size))
837 {
838 worked=FALSE;
839 Display_Error(global,GetString(MSG_ERR_SEEK));
840 }
841 }
842 FreeMem(buf,size);
843 }
844 else Display_Error(global,GetString(MSG_ERR_SEEK));
845
846 Start_Timer(global->timer);
847 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
848 while ((worked &= Check_Quit(global)) && (Read_Timer(global->timer) < global->Min_Time))
849 {
850 Seek(file,pos,OFFSET_BEGINNING);
851 Read(file,buffer,64);
852 count++;
853
854 Seek(file,-(pos+64),OFFSET_END);
855 Read(file,buffer,64);
856 count++;
857
858 Seek(file,-(pos+(size/3)),OFFSET_CURRENT);
859 Read(file,buffer,64);
860 count++;
861
862 /* Come up with another position... */
863 pos=(pos+(size/11)) % (size/3);
864 }
865 Stop_Timer(global->timer);
866
867 if (worked) Display_Result(global,GetString(MSG_SEEK_READ),count,GetString(MSG_SEEK_UNITS), CPU_AVAIL_struct);
868
869 Free_CPU_Available(CPU_AVAIL_struct);
870
871 Close(file);
872 DeleteFile(FILE_STRING);
873 }
874 else Display_Error(global,GetString(MSG_ERR_SEEK));
875
876 return(worked);
877 }
878
879 static BOOL SpeedTest(struct DiskSpeed *global,ULONG size,ULONG offset,ULONG mem_type, struct CPU_AVAIL *CPU_AVAIL_struct)
880 {
881 BOOL worked = TRUE;
882 char *buffer;
883 char *mem; /* What we really allocated */
884 char *type;
885 char *type2;
886 ULONG loop;
887 ULONG count;
888 LONG times;
889 BPTR file = BNULL;
890
891 AddDisplayLine(global,"");
892
893 type = "FAST";
894 if (mem_type & MEMF_CHIP) type = "CHIP";
895
896 type2="LONG";
897 if (offset & 2) type2 = "WORD";
898 if (offset & 1) type2 = "BYTE";
899
900 if ((mem=AllocMem(size+offset,mem_type|MEMF_PUBLIC)))
901 {
902 /* Set up memory... */
903 buffer=&(mem[offset]);
904
905 for (loop=0;loop<size;loop++) buffer[loop]=(unsigned short )loop;
906
907 sprintf(global->tmp1,GetString(MSG_TSTBUFF),size,type,type2);
908 AddDisplayLine(global,global->tmp1);
909
910 count = 0;
911 times = 0;
912
913 Start_Timer(global->timer);
914 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
915 while ((worked &= Check_Quit(global)) && (Read_Timer(global->timer) < global->Min_Time))
916 {
917 if (times<1)
918 {
919 if (file) Close(file);
920 DeleteFile(FILE_STRING);
921 if (!(file = Open(FILE_STRING,MODE_NEWFILE)))
922 {
923 Display_Error(global,GetString(MSG_ERR_CFILE));
924 worked = FALSE;
925 }
926 times = 0x40000/size; /* Try to make file at least 256K size */
927 }
928 if (file)
929 {
930 if (size != Write(file,buffer,size))
931 {
932 Display_Error(global,GetString(MSG_ERR_CFILE));
933 worked = FALSE;
934 }
935 else count += size;
936 times--;
937 }
938 }
939 Stop_Timer(global->timer);
940
941 if (worked) Display_Result(global,GetString(MSG_BYTES_CREATE),count,GetString(MSG_BYTE_UNITS), CPU_AVAIL_struct);
942
943 /* Fill out the file... */
944 if (file) while ((worked &= Check_Quit(global)) && (times>0))
945 {
946 Write(file,buffer,size);
947 times--;
948 }
949
950 if (file) Close(file);
951 file = BNULL;
952
953 if (worked) if (!(file=Open(FILE_STRING,MODE_OLDFILE)))
954 {
955 Display_Error(global,GetString(MSG_ERR_WFILE));
956 worked=FALSE;
957 }
958
959 count = 0;
960 times = 0;
961
962 Start_Timer(global->timer);
963 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
964 while ((worked &= Check_Quit(global)) && (Read_Timer(global->timer) < global->Min_Time))
965 {
966 if (times < 1)
967 {
968 Seek(file,0,OFFSET_BEGINNING);
969 times = 0x40000/size; /* Try to make file at least 256K size */
970 }
971 if (size != Write(file,buffer,size))
972 {
973 Display_Error(global,GetString(MSG_ERR_WFILE));
974 worked = FALSE;
975 }
976 else count += size;
977 times--;
978 }
979 Stop_Timer(global->timer);
980
981 if (worked) Display_Result(global,GetString(MSG_BYTES_WRITE),count,GetString(MSG_BYTE_UNITS), CPU_AVAIL_struct);
982
983 if (file) Close(file);
984 file = BNULL;
985
986 if (worked) if (!(file = Open(FILE_STRING,MODE_OLDFILE)))
987 {
988 Display_Error(global,GetString(MSG_ERR_RFILE));
989 worked = FALSE;
990 }
991
992 count = 0;
993 times = 0;
994
995 Start_Timer(global->timer);
996 Init_CPU_Available(CPU_AVAIL_struct); /* Start counting free CPU cycles... */
997 while ((worked &= Check_Quit(global)) && (Read_Timer(global->timer) < global->Min_Time))
998 {
999 if (times < 1)
1000 {
1001 Seek(file,0,OFFSET_BEGINNING);
1002 times = 0x40000/size; /* Try to make file at least 256K size */
1003 }
1004 if (size != Read(file,buffer,size))
1005 {
1006 Display_Error(global,GetString(MSG_ERR_RFILE));
1007 worked = FALSE;
1008 }
1009 else count += size;
1010 times--;
1011 }
1012 Stop_Timer(global->timer);
1013
1014 if (worked)
1015 {
1016 for (loop=0;loop<size;loop++) worked &= (buffer[loop] == (char)loop);
1017 if (!worked) AddDisplayLine(global,GetString(MSG_ERR_DATA));
1018 }
1019
1020 if (worked) Display_Result(global,GetString(MSG_BYTES_READ),count,GetString(MSG_BYTE_UNITS),CPU_AVAIL_struct);
1021
1022 if (file) Close(file);
1023
1024 Free_CPU_Available(CPU_AVAIL_struct);
1025 FreeMem(mem,size+offset);
1026 DeleteFile(FILE_STRING);
1027 }
1028 else
1029 {
1030 sprintf(global->tmp1,GetString(MSG_SKIPMEM),size,type);
1031 AddDisplayLine(global,global->tmp1);
1032 }
1033
1034 return(worked);
1035 }
1036
1037 /*
1038 Clean up (remove) all of the files in the current directory...
1039 */
1040
1041 static void CleanUpFiles(struct DiskSpeed *global)
1042 {
1043 BPTR lock;
1044
1045 CurrentDir(lock = CurrentDir(NULL)); /* Get current directory lock */
1046
1047 while (lock)
1048 {
1049 if (Examine(lock,global->fib))
1050 {
1051 if (ExNext(lock,global->fib)) DeleteFile(global->fib->fib_FileName);
1052 else lock = BNULL;
1053 }
1054 else lock = BNULL;
1055 }
1056 }
1057
1058 #endif /* SCSI_SPEED */
1059
1060 static void DoTests(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
1061 {
1062 char *st_string=global->tmp1;
1063 BOOL working;
1064 ULONG memtype;
1065 ULONG offset;
1066 short size;
1067
1068 #ifndef SCSI_SPEED
1069 char *fstring;
1070 LONG buffers = 0;
1071 #endif /* !SCSI_SPEED */
1072
1073 /*
1074 Ok, so now we are ready to run... Display the
1075 test conditions...
1076 */
1077
1078 strcpy(st_string,GetString(MSG_PROCESSOR));
1079 strcat(st_string,global->CPU_Type);
1080 #if defined(__AROS__)
1081 strcat(st_string,GetString(MSG_BLDAROS));
1082 #else
1083 strcat(st_string,GetString(MSG_BLDMOS));
1084 #endif
1085 strcat(st_string,global->Exec_Ver);
1086 if (global->HighDMA) strcat(st_string,GetString(MSG_DMAHIGH));
1087 else strcat(st_string,GetString(MSG_DMANORM));
1088 strcat(st_string,GetString(MSG_VIDDMA));
1089 AddDisplayLine(global,st_string);
1090
1091 /*
1092 Now, if we are in 2.0 OS, we can also find out the number of buffers
1093 (maybe) on that device. This is important.
1094 */
1095 #ifdef SCSI_SPEED
1096
1097 sprintf(st_string,"Device: %s",global->Device);
1098
1099 #else
1100
1101 fstring = "Device: %s Buffers: <information unavailable>";
1102 #ifndef __MORPHOS__
1103 if (DOSBase->dl_lib.lib_Version > 36L)
1104 #endif
1105 {
1106 /*
1107 Ok, so we can now try to get a reading of the buffers
1108 for the place we are about to test...
1109
1110 Note: Since we are in the "CURRENTDIR" of the test disk,
1111 we are using "" as the "device" to which to call AddBuffers()
1112 */
1113 if ((buffers = AddBuffers("",0)) > 0) fstring="Device: %s Buffers: %ld";
1114 }
1115
1116 sprintf(st_string,fstring,global->Device,buffers);
1117
1118 #endif /* SCSI_SPEED */
1119
1120 AddDisplayLine(global,st_string);
1121
1122 if (global->Comments[0])
1123 {
1124 strcpy(st_string,GetString(MSG_CMMNTS));
1125 strcat(st_string,global->Comments);
1126 AddDisplayLine(global,st_string);
1127 }
1128
1129 AddDisplayLine(global,"");
1130
1131 if (CPU_AVAIL_struct->_CPU_Use_Base) Delay(60); /* Make sure filesystem has flushed... */
1132
1133 Init_CPU_Available(CPU_AVAIL_struct);
1134 if (CPU_AVAIL_struct->_CPU_Use_Base) Delay(225); /* Get a quick reading (~4.5 seconds) */
1135
1136 Free_CPU_Available(CPU_AVAIL_struct);
1137
1138 if (CPU_AVAIL_struct->_CPU_Use_Base)
1139 {
1140 /*
1141 Now, generate a countdown value that is aprox 3 times 4.5 second...
1142 */
1143 CPU_AVAIL_struct->_CPU_Use_Base = (CPU_AVAIL_struct->_CPU_Count_Low * 3) + 1;
1144 CPU_AVAIL_struct->_CPU_Count_Low = CPU_AVAIL_struct->_CPU_Use_Base;
1145
1146 Forbid();
1147 Start_Timer(global->timer);
1148 CPU_Calibrate(CPU_AVAIL_struct);
1149 Stop_Timer(global->timer);
1150 Permit();
1151
1152 /*
1153 If it looks like we did not get a good reading,
1154 set up _CPU_Use_Base to 0 in order to turn off
1155 CPU readings...
1156 */
1157
1158 if (global->timer->tmVal.tv_secs < 4)
1159 {
1160 AddDisplayLine(global,GetString(MSG_ERR_CALIB1));
1161 AddDisplayLine(global,GetString(MSG_ERR_CALIB2));
1162 CPU_AVAIL_struct->_CPU_Use_Base = 0;
1163 }
1164 else CPU_AVAIL_struct->_CPU_Use_Base = MaxDivide(CPU_AVAIL_struct->_CPU_Use_Base,(global->timer->tmVal.tv_secs * 1000000) + global->timer->tmVal.tv_micro,6);
1165 }
1166
1167 global->Base_CPU = CPU_AVAIL_struct->_CPU_Use_Base;
1168
1169 if (CPU_AVAIL_struct->_CPU_Use_Base) sprintf(st_string,GetString(MSG_CPUSPD),(((CPU_AVAIL_struct->_CPU_Use_Base/500)+1) >> 1 ));
1170 else strcpy(st_string,GetString(MSG_NOCPU));
1171 AddDisplayLine(global,st_string);
1172 AddDisplayLine(global,"");
1173
1174 global->CPU_Total = 0L;
1175 global->CPU_Count = 0L;
1176
1177 working = Check_Quit(global);
1178
1179 #ifndef SCSI_SPEED
1180
1181 if (working && global->Test_DIR)
1182 {
1183 AddDisplayLine(global,GetString(MSG_TSTMANP));
1184 if (working) working = CreateFileTest(global, CPU_AVAIL_struct);
1185 if (working) working = OpenFileTest(global, CPU_AVAIL_struct);
1186 if (working) working = ScanDirectoryTest(global, CPU_AVAIL_struct);
1187 if (working) working = DeleteFileTest(global, CPU_AVAIL_struct);
1188 }
1189
1190 if (working && global->Test_SEEK)
1191 {
1192 AddDisplayLine(global,"");
1193 if (working) working = SeekReadTest(global, CPU_AVAIL_struct);
1194 }
1195
1196 #endif /* !SCSI_SPEED */
1197
1198 /* Now for some of the more complex tests */
1199 /* result=SpeedTest(global,Buffer,offset,mem_type); */
1200
1201 memtype = MEMF_FAST;
1202 while (memtype)
1203 {
1204 if (memtype & global->Mem_TYPES) for (offset = 4;offset>0;offset=offset >> 1) if (offset & global->Align_Types)
1205 {
1206 for (size = 0;size<4;size++) if (global->Test_Size[size])
1207 {
1208 if (working) working = SpeedTest(global,global->Test_Size[size],offset&3,memtype, CPU_AVAIL_struct);
1209 }
1210 }
1211
1212 if (memtype & MEMF_CHIP) memtype = 0;
1213 else memtype = MEMF_CHIP;
1214 }
1215
1216 #ifndef SCSI_SPEED
1217
1218 CleanUpFiles(global);
1219
1220 #endif /* !SCSI_SPEED */
1221
1222 if ((working) && (global->CPU_Count))
1223 {
1224 AddDisplayLine(global,"");
1225 global->CPU_Total = (((global->CPU_Total << 1) / global->CPU_Count)+1) >> 1;
1226 global->CPU_Count = (((global->Base_CPU * global->CPU_Total) / 50000)+1) >> 1;
1227 sprintf(st_string,GetString(MSG_AVGCPU),global->CPU_Total,global->CPU_Count);
1228 AddDisplayLine(global,st_string);
1229 }
1230 }
1231
1232 #ifdef SCSI_SPEED
1233
1234 static void StartTest(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
1235 {
1236 APTR oldwindow;
1237 char *st_string;
1238 char *unit = NULL;
1239 ULONG scsi_unit;
1240
1241 oldwindow = global->Me->pr_WindowPtr;
1242 global->Me->pr_WindowPtr = (APTR)(-1L);
1243
1244 if (diskspeedmui_intern.resultlv)
1245 DoMethod(diskspeedmui_intern.resultlv, MUIM_List_Clear);
1246
1247 AddDisplayLine(global,COPYRIGHT);
1248 AddDisplayLine(global,STR_SEPERATOR);
1249
1250 st_string = global->Device;
1251 while (*st_string)
1252 {
1253 if (*st_string == ':') unit = st_string;
1254 st_string++;
1255 }
1256
1257 st_string = unit;
1258
1259 if (unit)
1260 {
1261 *unit = '\0';
1262 unit++;
1263 scsi_unit = 0;
1264 while ((unit) && (*unit))
1265 {
1266 if ((*unit < '0') || (*unit >'9')) unit = NULL;
1267 else
1268 {
1269 scsi_unit *= 10;
1270 scsi_unit += *unit-'0';
1271 unit++;
1272 }
1273 }
1274 }
1275
1276 if (unit)
1277 {
1278 memset(&(global->DiskIO),0,sizeof(struct IOExtTD));
1279 if ((global->DiskIO.iotd_Req.io_Message.mn_ReplyPort = CreateMsgPort()))
1280 {
1281 if (!OpenDevice(global->Device,scsi_unit, (struct IORequest *)&global->DiskIO, 0))
1282 {
1283 unit = NULL;
1284 *st_string = ':';
1285 DoTests(global, CPU_AVAIL_struct);
1286 CloseDevice((struct IORequest *)&global->DiskIO);
1287 }
1288 DeleteMsgPort(global->DiskIO.iotd_Req.io_Message.mn_ReplyPort);
1289 }
1290 if (unit) AddDisplayLine(global,GetString(MSG_ERR_NODEV));
1291 }
1292 else AddDisplayLine(global,GetString(MSG_ERR_BADSPEC));
1293
1294 if (st_string) *st_string = ':';
1295
1296 global->Me->pr_WindowPtr = oldwindow;
1297 }
1298
1299 #else /* SCSI_SPEED */
1300
1301 static void StartTest(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
1302 {
1303 BPTR lock;
1304 BPTR newlock;
1305 APTR oldwindow;
1306
1307 oldwindow = global->Me->pr_WindowPtr;
1308 global->Me->pr_WindowPtr = (APTR)(-1L);
1309
1310 AddDisplayLine(global,COPYRIGHT);
1311 AddDisplayLine(global,STR_SEPERATOR);
1312
1313 if (lock = Lock(global->Device,ACCESS_READ))
1314 {
1315 lock = CurrentDir(lock);
1316 if (newlock = CreateDir(TEST_DIR))
1317 {
1318 UnLock(newlock);
1319 if (newlock = Lock(TEST_DIR,ACCESS_READ))
1320 {
1321 newlock = CurrentDir(newlock);
1322
1323 /*
1324 Now do all of the tests...
1325 */
1326
1327 DoTests(global, CPU_AVAIL_struct);
1328
1329 newlock = CurrentDir(newlock);
1330 UnLock(newlock);
1331 }
1332 else AddDisplayLine(global,GetString(MSG_ERR_BADDIR));
1333 DeleteFile(TEST_DIR);
1334 }
1335 else AddDisplayLine(global,GetString(MSG_ERR_NODIR));
1336 lock = CurrentDir(lock);
1337 UnLock(lock);
1338 }
1339 else AddDisplayLine(global,GetString(MSG_ERR_NOLOCK));
1340
1341 global->Me->pr_WindowPtr = oldwindow;
1342 }
1343
1344 #endif /* SCSI_SPEED */
1345
1346 static VOID SetVersionStrings(struct DiskSpeed *global)
1347 {
1348 // UWORD flags = ((struct ExecBase *)(SysBase))->AttnFlags;
1349 ULONG sysVer = ((struct ExecBase *)(SysBase))->LibNode.lib_Version;
1350 ULONG sofVer = ((struct ExecBase *)(SysBase))->SoftVer;
1351 // char *st_string;
1352
1353 #if defined(__PPC__)
1354 strcpy( global->CPU_Type,"PPC" );
1355 #elseif defined(__m68k__)
1356 strcpy( global->CPU_Type,"m68k" );
1357 #else
1358 strcpy( global->CPU_Type,"i386" );
1359 #endif
1360 // st_string = &( global->CPU_Type[1] );
1361
1362 sprintf(global->Exec_Ver,"%ld.%ld",(long) sysVer,(long) sofVer);
1363 }
1364
1365 /*
1366 A simple string check that also works with '=' at the end of the string
1367 */
1368
1369 static char *Check_String(char *arg,char *match)
1370 {
1371 char *st_string;
1372 char *next = NULL;
1373
1374 D(bug("ParseArg() in Check_String()\n"));
1375
1376 st_string = arg;
1377 while (*st_string)
1378 {
1379 if (*st_string == '=')
1380 {
1381 *st_string = '\0';
1382 next = st_string;
1383 }
1384 else st_string++;
1385 }
1386
1387 if (stricmp(arg,match))
1388 {
1389 if (next) *next = '=';
1390 next = NULL;
1391 }
1392 else
1393 {
1394 if (next) next++;
1395 else next = st_string;
1396 }
1397
1398 return(next);
1399 }
1400
1401 /*
1402 This routine closes down the GUI
1403 */
1404
1405 static void Close_GUI(struct DiskSpeed *global)
1406 {
1407 if (MUIMasterBase)
1408 {
1409 MUI_DisposeObject(diskspeedmui_intern.disk_app);
1410 CloseLibrary(MUIMasterBase);
1411 }
1412 }
1413
1414 static Object *MakeCheck (CONST_STRPTR label, ULONG id, ULONG checked)
1415 {
1416 Object *obj = MUI_MakeObject(MUIO_Checkmark, (IPTR)label);
1417
1418 if (obj)
1419 SetAttrs(obj, MUIA_CycleChain, 1, MUIA_ObjectID, id, MUIA_Selected, checked, TAG_DONE);
1420
1421 return obj;
1422 }
1423
1424 static APTR MakeButton(const char *string)
1425 {
1426 APTR obj;
1427 if (obj = MUI_MakeObject(MUIO_Button, (IPTR)string))
1428 SetAttrs(obj, MUIA_CycleChain, 1, TAG_DONE);
1429
1430 return obj;
1431 }
1432
1433
1434 /*
1435 This routine is used to open the GUI...
1436 */
1437
1438 static APTR Open_GUI(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct, struct DiskObject *dobj, int load_config)
1439 {
1440 // BOOL worked = FALSE;
1441
1442 D(bug("Open_GUI()\n"));
1443
1444 if ((MUIMasterBase)&&(!diskspeedmui_intern.disk_app))
1445 {
1446 sprintf(global->tmp1,GetString(MSG_MAIN_WINTITLE),APPNAME);
1447 sprintf(global->tmp2,GetString(MSG_Welcome),
1448 #ifdef SCSI_SPEED
1449 GetString(MSG_W_DEVICE));
1450 #else
1451 GetString(MSG_W_FILESYS));
1452 #endif /* SCSI_SPEED */
1453
1454 diskspeedmui_intern.disk_app = ApplicationObject,
1455 MUIA_Application_DiskObject, (IPTR)dobj,
1456 MUIA_Application_Title, (IPTR)APPNAME,
1457 MUIA_Application_Version, (IPTR)CXVERSION,
1458 MUIA_Application_Copyright, (IPTR)"Copyright © 1995-2016, The AROS Development Team",
1459 MUIA_Application_Author, (IPTR)"The AROS Development Team",
1460 MUIA_Application_Description, (IPTR)GetString(MSG_DESCRIPTION),
1461 MUIA_Application_Base, (IPTR)APPNAME,
1462 MUIA_Application_Menustrip, (IPTR)(MenustripObject,
1463 MUIA_Family_Child, (IPTR)(MenuObject,
1464 MUIA_Menuitem_Title, (IPTR)GetString(WORD_MENU_Project),
1465 MUIA_Family_Child, (IPTR)(diskspeedmui_intern.about_item = MenuitemObject,
1466 MUIA_Menuitem_Title, (IPTR)GetString(WORD_MENU_About),
1467 End),
1468 MUIA_Family_Child, (IPTR)(diskspeedmui_intern.quit_item = MenuitemObject,
1469 MUIA_Menuitem_Title, (IPTR)GetString(WORD_MENU_Quit),
1470 End),
1471 End),
1472 End),
1473 SubWindow, (IPTR)(diskspeedmui_intern.disk_main_win = WindowObject,
1474 MUIA_Window_Title, global->tmp1,
1475 MUIA_Window_ID, MAKE_ID('D','W','I','N'),
1476 MUIA_Window_Activate, TRUE,
1477 MUIA_Window_Height, MUIV_Window_Height_Visible(50),
1478 MUIA_Window_Width, MUIV_Window_Width_Visible(60),
1479 WindowContents, VGroup,
1480 Child, VGroup, /* Main Panel */
1481 GroupFrame,
1482 MUIA_Background, MUII_GroupBack,
1483 Child, (IPTR)(diskspeedmui_intern.welctext = TextObject,
1484 TextFrame,
1485 MUIA_Text_Contents, global->tmp2,
1486 End),
1487 Child, HGroup,
1488 Child, ColGroup(2),
1489 MUIA_HorizWeight,100,
1490 Child, Label(GetString(MSG_DEVICE)),
1491 Child, (IPTR)(diskspeedmui_intern.devicestr = StringObject,
1492 StringFrame,
1493 MUIA_CycleChain, TRUE,
1494 MUIA_String_MaxLen, 255,
1495 MUIA_String_Contents, global->Device,
1496 End),
1497 Child, Label(GetString(MSG_CMMNTS)),
1498 Child, (IPTR)(diskspeedmui_intern.commentstr = StringObject,
1499 StringFrame,
1500 MUIA_CycleChain, TRUE,
1501 MUIA_String_MaxLen, 255,
1502 End),
1503 End,
1504 Child, (IPTR)(diskspeedmui_intern.configobj = CoolImageIDButton(NULL, COOL_INFOIMAGE_ID)),
1505 End,
1506 Child, ListviewObject, /* Our results view */
1507 MUIA_Listview_List, diskspeedmui_intern.resultlv = ListObject,
1508 ReadListFrame,
1509 MUIA_Listview_Input, FALSE,
1510 /*MUIA_List_Title, TRUE,*/
1511 MUIA_List_ConstructHook, MUIV_List_ConstructHook_String,
1512 MUIA_List_DestructHook, MUIV_List_DestructHook_String,
1513 End,
1514 End,
1515 End,
1516 Child, HGroup, /* save/use/cancel button row */
1517 MUIA_FixHeight, 1,
1518 MUIA_Group_SameWidth, TRUE,
1519 Child, (IPTR)(diskspeedmui_intern.beginobj = CoolImageIDButton(GetString(MSG_START_TEST), COOL_DOTIMAGE_ID)),
1520 Child, HSpace(0),
1521 /*Child, diskspeedmui_intern.stopobj = CoolImageIDButton(GetString(MSG_STOP_TEST), COOL_CANCELIMAGE_ID),*/
1522 Child, (IPTR)(diskspeedmui_intern.saveobj = CoolImageIDButton(GetString(MSG_SAVE_RESULTS), COOL_SAVEIMAGE_ID)),
1523 End,
1524 End,
1525 End),
1526 //NEXT WINDOW.. ABOUT
1527 SubWindow, (IPTR)(diskspeedmui_intern.disk_about_win = AboutWindowObject,
1528 MUIA_AboutWindow_Authors, (IPTR) TAGLIST
1529 (
1530 SECTION
1531 (
1532 SID_PROGRAMMING,
1533 NAME("Nic Andrews")
1534 ),
1535 SECTION
1536 (
1537 SID_TRANSLATING,
1538 NAME("Adam Chodorowski"),
1539 NAME("Fabio Alemagna")
1540 )
1541 ),
1542 End),
1543 //NEXT WINDOW.. CONFIG
1544 SubWindow, (IPTR)(diskspeedmui_intern.disk_config_win = WindowObject,
1545 MUIA_Window_Title, (IPTR)GetString(MSG_CONFIG_WINTITLE),
1546 MUIA_Window_ID, MAKE_ID('C','W','I','N'),
1547 WindowContents, VGroup,
1548 Child, VGroup,
1549 MUIA_Group_VertSpacing, 0,
1550 Child, VSpace(0),
1551 Child, HGroup,
1552 MUIA_Group_VertSpacing, 2,
1553 MUIA_Background, MUII_GroupBack,
1554 GroupFrame,
1555 Child, HSpace(0),
1556 Child, ColGroup(2),
1557 #ifndef SCSI_SPEED
1558 Child, (IPTR)(diskspeedmui_config.dir_checkmark = MakeCheck(NULL, MAKE_ID('C','D','I','R'), TRUE)),
1559 Child, (IPTR) LLabel("DIR"),
1560 #endif
1561 Child, (IPTR)(diskspeedmui_config.seek_checkmark = MakeCheck(NULL, MAKE_ID('S','E','E','K'), TRUE)),
1562 Child, (IPTR) LLabel("SEEK"),
1563 Child, (IPTR)(diskspeedmui_config.nocpu_checkmark = MakeCheck(NULL, MAKE_ID('N','C','P','U'), TRUE)),
1564 Child, (IPTR) LLabel("NOCPU"),
1565 End,
1566 Child, HSpace(0),
1567 Child, VGroup,
1568 /*MUIA_Background, MUII_GroupBack,*/
1569 Child, (IPTR) CLabel("MINTIME"),
1570 Child,(IPTR)(diskspeedmui_config.mintime = StringObject,
1571 StringFrame,
1572 MUIA_CycleChain, 1,
1573 MUIA_ObjectID, MAKE_ID('M','I','N','T'),
1574 MUIA_String_Accept, (IPTR)"0123456789",
1575 End),
1576 End,
1577 Child, HSpace(0),
1578 End,
1579 Child, VSpace(0),
1580 End, /* Misc Options */
1581 Child, HSpace(0),
1582 Child, VGroup,
1583 GroupFrameT(GetString(MSG_RWBUFS)),
1584 MUIA_Group_VertSpacing, 0,
1585 Child, VSpace(0),
1586 Child, ColGroup(3),
1587 MUIA_Group_VertSpacing, 2,
1588 Child, LLabel(GetString(MSG_BUF1TXT)),
1589 Child, HSpace(0),
1590 Child,(IPTR)(diskspeedmui_config.buffer1 = StringObject,
1591 StringFrame,
1592 MUIA_CycleChain, 1,
1593 MUIA_ObjectID, MAKE_ID('B','U','F','1'),
1594 MUIA_String_Accept, (IPTR)"0123456789",
1595 MUIA_String_Format, MUIV_String_Format_Right,
1596 End),
1597 Child, LLabel(GetString(MSG_BUF2TXT)),
1598 Child, HSpace(0),
1599 Child,(IPTR)(diskspeedmui_config.buffer2 = StringObject,
1600 StringFrame,
1601 MUIA_CycleChain, 1,
1602 MUIA_ObjectID, MAKE_ID('B','U','F','2'),
1603 MUIA_String_Accept, (IPTR)"0123456789",
1604 MUIA_String_Format, MUIV_String_Format_Right,
1605 End),
1606 Child, LLabel(GetString(MSG_BUF3TXT)),
1607 Child, HSpace(0),
1608 Child,(IPTR)(diskspeedmui_config.buffer3 = StringObject,
1609 StringFrame,
1610 MUIA_CycleChain, 1,
1611 MUIA_ObjectID, MAKE_ID('B','U','F','3'),
1612 MUIA_String_Accept, (IPTR)"0123456789",
1613 MUIA_String_Format, MUIV_String_Format_Right,
1614 End),
1615 Child, LLabel(GetString(MSG_BUF4TXT)),
1616 Child, HSpace(0),
1617 Child,(IPTR)(diskspeedmui_config.buffer4 = StringObject,
1618 StringFrame,
1619 MUIA_CycleChain, 1,
1620 MUIA_ObjectID, MAKE_ID('B','U','F','4'),
1621 MUIA_String_Accept, (IPTR)"0123456789",
1622 MUIA_String_Format, MUIV_String_Format_Right,
1623 End),
1624 End,
1625 Child, VSpace(0),
1626 End, /* Buffer Sizes */
1627 Child, VGroup,
1628 GroupFrameT(GetString(MSG_RWBUFS)),
1629 MUIA_Group_VertSpacing, 0,
1630 Child, VSpace(0),
1631 Child, ColGroup(5),
1632 Child, HSpace(0),
1633 Child, ColGroup(2),
1634 MUIA_Group_VertSpacing, 2,
1635 Child, (IPTR)(diskspeedmui_config.long_checkmark = MakeCheck(NULL, MAKE_ID('L','O','N','G'), TRUE)),
1636 Child, (IPTR) LLabel("LONG"),
1637 Child, (IPTR)(diskspeedmui_config.word_checkmark = MakeCheck(NULL, MAKE_ID('W','O','R','D'), TRUE)),
1638 Child, (IPTR) LLabel("WORD"),
1639 Child, (IPTR)(diskspeedmui_config.byte_checkmark = MakeCheck(NULL, MAKE_ID('B','Y','T','E'), TRUE)),
1640 Child, (IPTR) LLabel("BYTE"),
1641 End,
1642 Child, HSpace(0),
1643 Child, ColGroup(2),
1644 MUIA_Group_VertSpacing, 2,
1645 Child, (IPTR)(diskspeedmui_config.fast_checkmark = MakeCheck(NULL, MAKE_ID('F','A','S','T'), TRUE)),
1646 Child, (IPTR) LLabel("FAST"),
1647 Child, (IPTR)(diskspeedmui_config.chip_checkmark = MakeCheck(NULL, MAKE_ID('C','H','I','P'), TRUE)),
1648 Child, (IPTR) LLabel("CHIP"),
1649 End,
1650 Child, HSpace(0),
1651 End,
1652 Child, VSpace(0),
1653 End, /* Buffer Types */
1654 // Child, diskspeedmui_intern.conokobj = CoolImageIDButton(GetString(MSG_OK), COOL_DOTIMAGE_ID),
1655 Child, HGroup,
1656 Child, (IPTR)(diskspeedmui_intern.consaveobj = MakeButton(GetString(MSG_GAD_SAVE))),
1657 Child, HSpace(30),
1658 Child, (IPTR)(diskspeedmui_intern.conuseobj = MakeButton(GetString(MSG_GAD_USE))),
1659 Child, HSpace(30),
1660 Child, (IPTR)(diskspeedmui_intern.concancelobj = MakeButton(GetString(MSG_GAD_CANCEL))),
1661 End,
1662 End,
1663 End),
1664 End;
1665
1666 if (diskspeedmui_intern.disk_app)
1667 {
1668 if (load_config)
1669 {
1670 /* Load Settings
1671 **
1672 ** Ditched config items stored to icon tooltypes. However DRIVE and COMMENT
1673 ** options are recognized still.
1674 */
1675
1676 DoMethod(diskspeedmui_intern.disk_app, MUIM_Application_Load, MUIV_Application_Load_ENV);
1677
1678 if (dobj)
1679 {
1680 STRPTR s;
1681
1682 if ((s = FindToolType(dobj->do_ToolTypes, "DRIVE")))
1683 {
1684 strcpy(global->Device, s);
1685 }
1686
1687 if ((s = FindToolType(dobj->do_ToolTypes, "COMMENT")))
1688 {
1689 strcpy(global->Comments, s);
1690 }
1691 }
1692 }
1693 /*********/
1694 DoMethod(diskspeedmui_intern.disk_main_win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1695
1696 DoMethod(diskspeedmui_intern.configobj, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)diskspeedmui_intern.disk_config_win, 3, MUIM_Set, MUIA_Window_Open, TRUE);
1697
1698 // DoMethod(diskspeedmui_intern.stopobj, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, RETURNID_STOP);
1699 DoMethod(diskspeedmui_intern.saveobj, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, RETURNID_SAVE);
1700 DoMethod(diskspeedmui_intern.beginobj, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, RETURNID_BEGIN);
1701 /**/
1702 DoMethod(diskspeedmui_intern.disk_config_win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)diskspeedmui_intern.disk_config_win, 3, MUIM_Set, MUIA_Window_Open, FALSE);
1703 DoMethod(diskspeedmui_intern.consaveobj, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, RETURNID_SAVECONFIG);
1704 DoMethod(diskspeedmui_intern.conuseobj, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, RETURNID_USECONFIG);
1705 DoMethod(diskspeedmui_intern.concancelobj, MUIM_Notify, MUIA_Pressed, FALSE, MUIV_Notify_Window, 3, MUIM_Set, MUIA_Window_Open, FALSE);
1706 /**/
1707 DoMethod(diskspeedmui_intern.disk_about_win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIV_Notify_Window, 3, MUIM_Set, MUIA_Window_Open, FALSE);
1708 /**/
1709 DoMethod(diskspeedmui_intern.quit_item, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1710 DoMethod(diskspeedmui_intern.about_item, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime, (IPTR)diskspeedmui_intern.disk_about_win, 3, MUIM_Set, MUIA_Window_Open, TRUE);
1711
1712 /**********/
1713 set(diskspeedmui_intern.configobj, MUIA_HorizWeight, 0); /* Set up the weight for the image ( so it takes up least space..) */
1714 /*********/
1715 set(diskspeedmui_intern.commentstr, MUIA_String_Contents, global->Comments);
1716 set(diskspeedmui_intern.devicestr, MUIA_String_Contents, global->Device);
1717
1718 /* Set some reasonable values if saved values are rubbish */
1719 if (!getv(diskspeedmui_config.mintime, MUIA_String_Integer))
1720 set(diskspeedmui_config.mintime, MUIA_String_Integer, global->Min_Time);
1721
1722 if (!getv(diskspeedmui_config.buffer1, MUIA_String_Integer))
1723 set(diskspeedmui_config.buffer1, MUIA_String_Integer, global->Test_Size[0]);
1724
1725 if (!getv(diskspeedmui_config.buffer2, MUIA_String_Integer))
1726 set(diskspeedmui_config.buffer2, MUIA_String_Integer, global->Test_Size[1]);
1727
1728 if (!getv(diskspeedmui_config.buffer3, MUIA_String_Integer))
1729 set(diskspeedmui_config.buffer3, MUIA_String_Integer, global->Test_Size[2]);
1730
1731 if (!getv(diskspeedmui_config.buffer4, MUIA_String_Integer))
1732 set(diskspeedmui_config.buffer4, MUIA_String_Integer, global->Test_Size[3]);
1733
1734 #if 0
1735 #ifdef SCSI_SPEED
1736 set( diskspeedmui_config.dir_checkmark, MUIA_Disabled, TRUE);
1737 set( diskspeedmui_config.seek_checkmark, MUIA_Disabled, TRUE);
1738 set( diskspeedmui_config.long_checkmark, MUIA_Selected, TRUE);
1739 set( diskspeedmui_config.long_checkmark, MUIA_Disabled, TRUE);
1740 set( diskspeedmui_config.word_checkmark, MUIA_Disabled, TRUE);
1741 set( diskspeedmui_config.byte_checkmark, MUIA_Disabled, TRUE);
1742 #else /* SCSI_SPEED */
1743 if (global->Test_DIR) set( diskspeedmui_config.dir_checkmark, MUIA_Selected,TRUE);
1744 if (global->Test_SEEK) set( diskspeedmui_config.seek_checkmark, MUIA_Selected,TRUE);
1745 if (global->Align_Types & 4) set( diskspeedmui_config.long_checkmark, MUIA_Selected, TRUE);
1746 if (global->Align_Types & 2) set( diskspeedmui_config.word_checkmark, MUIA_Selected, TRUE);
1747 if (global->Align_Types & 1) set( diskspeedmui_config.byte_checkmark, MUIA_Selected, TRUE);
1748 #endif /* SCSI_SPEED */
1749 if (CPU_AVAIL_struct->_CPU_Use_Base==0) set( diskspeedmui_config.nocpu_checkmark, MUIA_Selected,TRUE);
1750
1751 if (global->Mem_TYPES & MEMF_FAST) set( diskspeedmui_config.fast_checkmark,MUIA_Selected,TRUE);
1752 if (global->Mem_TYPES & MEMF_CHIP) set( diskspeedmui_config.chip_checkmark,MUIA_Selected,TRUE);
1753 #endif
1754 if (SysBase->MaxLocMem == 0)
1755 set( diskspeedmui_config.chip_checkmark, MUIA_Disabled, TRUE);
1756 }
1757 }
1758
1759 return(diskspeedmui_intern.disk_app);
1760 }
1761
1762 /*
1763 This routine will append to the end of a file the results currently in memory...
1764 */
1765 static void Save_Results(struct DiskSpeed *global)
1766 {
1767 BPTR fh;
1768 struct Node *node;
1769
1770 if ((fh = Open(RESULTS_FILE,MODE_OLDFILE)))
1771 {
1772 Seek(fh,0,OFFSET_END);
1773 Write(fh,"\n\n\n",2);
1774 }
1775 else fh = Open(RESULTS_FILE,MODE_NEWFILE);
1776
1777 if (fh)
1778 {
1779 node = (struct Node *)(global->TextList.mlh_Head);
1780 while (node->ln_Succ)
1781 {
1782 Write(fh,node->ln_Name,strlen(node->ln_Name));
1783 Write(fh,"\n",1);
1784 node = node->ln_Succ;
1785 }
1786
1787 Close(fh);
1788 }
1789 }
1790
1791 /*
1792 This routine will retrieve the config settings from the MUI_Objects
1793 */
1794 static void GET_Config(struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
1795 {
1796 //BOOL error = TRUE;
1797 ULONG tmp;
1798
1799 /*
1800 Ok, now get the information back out...
1801 */
1802
1803 get(diskspeedmui_config.mintime, MUIA_String_Integer, &global->Min_Time);
1804
1805 get(diskspeedmui_config.buffer1, MUIA_String_Integer, &global->Test_Size[0]);
1806 get(diskspeedmui_config.buffer2, MUIA_String_Integer, &global->Test_Size[1]);
1807 get(diskspeedmui_config.buffer3, MUIA_String_Integer, &global->Test_Size[2]);
1808 get(diskspeedmui_config.buffer4, MUIA_String_Integer, &global->Test_Size[3]);
1809
1810 #ifndef SCSI_SPEED
1811 global->Test_DIR=0;
1812 get( diskspeedmui_config.dir_checkmark, MUIA_Selected, &tmp);
1813 if (tmp) global->Test_DIR=1;
1814 #endif
1815
1816 global->Test_SEEK=0;
1817 get( diskspeedmui_config.seek_checkmark, MUIA_Selected, &tmp);
1818 if (tmp) global->Test_SEEK=1;
1819
1820 CPU_AVAIL_struct->_CPU_Use_Base=1;
1821 get( diskspeedmui_config.nocpu_checkmark, MUIA_Selected, &tmp);
1822 if (tmp) CPU_AVAIL_struct->_CPU_Use_Base=0;
1823
1824 global->Align_Types &= (~4);
1825 get( diskspeedmui_config.long_checkmark, MUIA_Selected,&tmp);
1826 if (tmp) global->Align_Types |= 1<<2;
1827
1828 global->Align_Types &= (~2);
1829 get( diskspeedmui_config.word_checkmark, MUIA_Selected,&tmp);
1830 if (tmp) global->Align_Types |= 1<<1;
1831
1832 global->Align_Types &= (~1);
1833 get( diskspeedmui_config.byte_checkmark, MUIA_Selected,&tmp);
1834 if (tmp) global->Align_Types |= 1;
1835
1836 global->Mem_TYPES &= (~MEMF_FAST);
1837 get( diskspeedmui_config.fast_checkmark,MUIA_Selected,&tmp);
1838 if (tmp) global->Mem_TYPES |= (1 * MEMF_FAST);
1839
1840 global->Mem_TYPES &= (~MEMF_CHIP);
1841 if (SysBase->MaxLocMem)
1842 {
1843 get( diskspeedmui_config.chip_checkmark,MUIA_Selected,&tmp);
1844 if (tmp) global->Mem_TYPES |= (1 * MEMF_CHIP);
1845 }
1846
1847 set (diskspeedmui_intern.disk_config_win, MUIA_Window_Open, FALSE);
1848 }
1849
1850 /*
1851 DRIVE/K - select drive (Default is current directory or scsi.device:6)
1852 COMMENT/K - set comment string
1853 ALL/S - select all tests
1854 DIR/S - setect DIR tests
1855 SEEK/S - select SEEK tests
1856 CHIP/S - select CHIP memory buffer tests
1857 FAST/S - select FAST memory buffer tests
1858 LONG/S - select LONG aligned tests
1859 WORD/S - select WORD aligned tests
1860 BYTE/S - select BYTE aligned tests
1861 NOCPU/S - turn off CPU availability tests
1862 BUF1/K/N - select buffer size 1
1863 BUF2/K/N - select buffer size 2
1864 BUF3/K/N - select buffer size 3
1865 BUF4/K/N - select buffer size 4
1866 MINTIME/K/N - select the minimum test tmVal (default=8) in seconds
1867 WINDOW/S - use the GUI even though started from the CLI
1868 */
1869
1870 /*
1871 do the command line parsing here...
1872 */
1873 static LONG ParseArg(struct DiskSpeed *global,int argc,char *argv[],int start,struct CPU_AVAIL *CPU_AVAIL_struct)
1874 {
1875 int loop;
1876 char *arg;
1877 char *next;
1878 LONG working = TRUE;
1879 LONG window = FALSE;
1880
1881 D(bug("ParseArg()\n"));
1882
1883 #ifdef SCSI_SPEED
1884 global->Align_Types = 4;
1885 #endif /* SCSI_SPEED */
1886
1887 for (loop = start;loop<argc;loop++)
1888 {
1889 if (loop >= 10) break;
1890 D(bug("ParseArg() in loop(argv=%ld,argc=%ld,start=%ld,loop=%ld))\n",argv,argc,start,loop));
1891 arg = argv[loop];
1892 if (*arg == '?')
1893 {
1894 D(bug("ParseArg() Arg = ?\n"));
1895 loop = argc;
1896 working = FALSE;
1897 }
1898 else if ((next=Check_String(arg,"DRIVE")))
1899 {
1900 D(bug("ParseArg() Arg = DRIVE\n"));
1901 if (!(*next))
1902 {
1903 loop++;
1904 if (loop<argc) next = argv[loop];
1905 }
1906 if (strlen(next)>255) *next = '\0';
1907 if (*next) strcpy(global->Device,next);
1908 else working = FALSE;
1909 }
1910 else if ((next=Check_String(arg,"COMMENT")))
1911 {
1912 D(bug("ParseArg() Arg = COMMENT\n"));
1913 if (!(*next))
1914 {
1915 loop++;
1916 if (loop<argc) next = argv[loop];
1917 }
1918 if (strlen(next)>255) *next = '\0';
1919 if (*next) strcpy(global->Comments,next);
1920 else working = FALSE;
1921 }
1922 else if (Check_String(arg,"ALL"))
1923 {
1924 D(bug("ParseArg() Arg = ALL\n"));
1925 /* All tests */
1926
1927 #ifndef SCSI_SPEED
1928
1929 global->Test_DIR = TRUE;
1930 global->Test_SEEK = TRUE;
1931 global->Align_Types = 4|2|1;
1932
1933 #endif /* !SCSI_SPEED */
1934
1935 global->Mem_TYPES = (SysBase->MaxLocMem ? MEMF_CHIP : 0) | MEMF_FAST;
1936 }
1937 else if ((next = Check_String(arg,"BUF1")))
1938 {
1939 D(bug("ParseArg() Arg = BUF1\n"));
1940 if (!(*next))
1941 {
1942 loop++;
1943 if (loop<argc) next = argv[loop];
1944 }
1945 if (*next) stcd_l(next,(long *)&(global->Test_Size[0]));
1946 else working=FALSE;
1947 }
1948 else if ((next = Check_String(arg,"BUF2")))
1949 {
1950 D(bug("ParseArg() Arg = BUF2\n"));
1951 if (!(*next))
1952 {
1953 loop++;
1954 if (loop<argc) next = argv[loop];
1955 }
1956 if (*next) stcd_l(next,(long *)&(global->Test_Size[1]));
1957 else working = FALSE;
1958 }
1959 else if ((next = Check_String(arg,"BUF3")))
1960 {
1961 D(bug("ParseArg() Arg = BUF3\n"));
1962 if (!(*next))
1963 {
1964 loop++;
1965 if (loop<argc) next = argv[loop];
1966 }
1967 if (*next) stcd_l(next,(long *)&(global->Test_Size[2]));
1968 else working = FALSE;
1969 }
1970 else if ((next = Check_String(arg,"BUF4")))
1971 {
1972 D(bug("ParseArg() Arg = BUF4\n"));
1973 if (!(*next))
1974 {
1975 loop++;
1976 if (loop<argc) next=argv[loop];
1977 }
1978 if (*next) stcd_l(next,(long *)&(global->Test_Size[3]));
1979 else working = FALSE;
1980 }
1981 else if ((next = Check_String(arg,"MINTIME")))
1982 {
1983 D(bug("ParseArg() Arg = MINTIME\n"));
1984 if (!(*next))
1985 {
1986 loop++;
1987 if (loop<argc) next = argv[loop];
1988 }
1989 if (*next) stcd_l(next,(long *)&(global->Min_Time));
1990 else working = FALSE;
1991 }
1992 #ifndef SCSI_SPEED
1993
1994 else if (Check_String(arg,"DIR")) global->Test_DIR = TRUE;
1995 else if (Check_String(arg,"SEEK")) global->Test_SEEK = TRUE;
1996 else if (Check_String(arg,"LONG")) global->Align_Types |= 4;
1997 else if (Check_String(arg,"WORD")) global->Align_Types |= 2;
1998 else if (Check_String(arg,"BYTE")) global->Align_Types |= 1;
1999
2000 #endif /* !SCSI_SPEED */
2001
2002 else if (Check_String(arg,"CHIP")) global->Mem_TYPES |=MEMF_CHIP;
2003 else if (Check_String(arg,"FAST")) global->Mem_TYPES |= MEMF_FAST;
2004 else if (Check_String(arg,"NOCPU")) CPU_AVAIL_struct->_CPU_Use_Base = FALSE;
2005 else if (Check_String(arg,"WINDOW")) window = TRUE;
2006 else
2007 { /* Did not match, so error */
2008 D(bug("ParseArg() NO ARG MATCHES\n"));
2009 working = FALSE;
2010 }
2011 }
2012
2013
2014 D(bug("ParseArg() loop().. FINISHED\n"));
2015
2016 if (global->Min_Time < 1) global->Min_Time = 1;
2017
2018 D(bug("ParseArg() - preparing to open MUI window\n"));
2019
2020 if (working && window) working = Open_GUI(global,CPU_AVAIL_struct, NULL, 0) != NULL;
2021
2022 return(working);
2023 }
2024
2025 void GrabComment (char *theString)
2026 {
2027 strcpy(global->Comments, theString);
2028 }
2029
2030 void GrabDevice (char *theString)
2031 {
2032 strcpy(global->Device, theString);
2033 }
2034
2035 static void HandleAll (struct DiskSpeed *global, struct CPU_AVAIL *CPU_AVAIL_struct)
2036 {
2037 ULONG sigs = 0;
2038 LONG returnid;
2039 diskspeedmui_intern.app_ret_val = FALSE;
2040
2041 set (diskspeedmui_intern.disk_main_win, MUIA_Window_Open, TRUE);
2042
2043 for(;;)
2044 {
2045 returnid = (LONG) DoMethod(diskspeedmui_intern.disk_app, MUIM_Application_NewInput, (IPTR) &sigs);
2046
2047 if (returnid == MUIV_Application_ReturnID_Quit)
2048 {
2049 diskspeedmui_intern.app_ret_val = TRUE;
2050 break;
2051 }
2052
2053 if ((returnid == RETURNID_SAVECONFIG) || (returnid == RETURNID_USECONFIG) || (returnid == RETURNID_BEGIN) || (returnid == RETURNID_STOP) || (returnid == RETURNID_SAVE)) break;
2054
2055 if (sigs)
2056 {
2057 sigs = Wait(sigs | SIGBREAKF_CTRL_C);
2058 if (sigs & SIGBREAKF_CTRL_C) break;
2059 }
2060 }
2061
2062 switch(returnid)
2063 {
2064 case RETURNID_BEGIN:
2065 {
2066 IPTR str1, str2;
2067
2068 GET_Config(global, CPU_AVAIL_struct);
2069
2070 GetAttr(MUIA_String_Contents, diskspeedmui_intern.commentstr, &str1);
2071 GetAttr(MUIA_String_Contents, diskspeedmui_intern.devicestr, &str2);
2072
2073 strcpy(global->Comments, (char *)str1);
2074 strcpy(global->Device, (char *)str2);
2075
2076 set(diskspeedmui_intern.disk_app, MUIA_Application_Sleep, TRUE);
2077 StartTest(global, CPU_AVAIL_struct);
2078 set(diskspeedmui_intern.disk_app, MUIA_Application_Sleep, FALSE);
2079 break;
2080 }
2081 case RETURNID_STOP:
2082 {
2083 /* In order to support this the GUI would need to be threaded */
2084 break;
2085 }
2086 case RETURNID_SAVE:
2087 {
2088 Save_Results(global);
2089 break;
2090 }
2091 case RETURNID_SAVECONFIG:
2092 DoMethod(diskspeedmui_intern.disk_app, MUIM_Application_Save, MUIV_Application_Save_ENVARC); /* fall through to USECONFIG */
2093 case RETURNID_USECONFIG:
2094 DoMethod(diskspeedmui_intern.disk_app, MUIM_Application_Save, MUIV_Application_Save_ENV);
2095 set(diskspeedmui_intern.disk_config_win, MUIA_Window_Open, FALSE);
2096 break;
2097 break;
2098
2099 }
2100 }
2101
2102 /*
2103 This routine is called when we want to run from a GUI
2104 Normally, it is only called when started from Workbench
2105 or when the CLI WINDOW option is given...
2106 */
2107 static void FromWanderer(struct DiskSpeed *global,int argc,char *argv[], struct CPU_AVAIL *CPU_AVAIL_struct)
2108 {
2109 struct WBStartup *startup;
2110 struct WBArg *wbarg;
2111
2112 startup = (struct WBStartup *) argv;
2113
2114 // D(bug("FromWanderer()\n"));
2115
2116 if ((wbarg = startup->sm_ArgList) && (startup->sm_NumArgs))
2117 {
2118 BPTR lock;
2119 struct DiskObject *icon;
2120 /*
2121 Check if we were started as a project and
2122 use that icon insted...
2123 */
2124 if ((startup->sm_NumArgs) > 1) wbarg++;
2125
2126 lock = CurrentDir(wbarg->wa_Lock);
2127 icon = GetDiskObject(wbarg->wa_Name);
2128
2129 #if 0
2130 if (!argc)
2131 {
2132 /* All tests */
2133 global->Test_DIR = TRUE;
2134 global->Test_SEEK = TRUE;
2135 global->Align_Types = 4|2|1;
2136 global->Mem_TYPES = MEMF_CHIP | MEMF_FAST;
2137 }
2138 #endif
2139
2140 D(bug("FromWanderer() - launching GUI\n"));
2141
2142 if (Open_GUI(global,CPU_AVAIL_struct, icon, 1))
2143 {
2144 for(;;)
2145 {
2146 HandleAll(global,CPU_AVAIL_struct);
2147 if (diskspeedmui_intern.app_ret_val == TRUE)
2148 { Close_GUI(global);
2149 break;
2150 }
2151 }
2152 }
2153
2154 if (icon)
2155 FreeDiskObject(icon);
2156
2157 CurrentDir(lock);
2158 }
2159 D(bug("FromWanderer() Finished..\n"));
2160 }
2161
2162 /*
2163 This is the CLI starting point. We do the command line parsing here...
2164 */
2165 static void FromCLI(struct DiskSpeed *global,int argc,char *argv[], struct CPU_AVAIL *CPU_AVAIL_struct)
2166 {
2167 if (ParseArg(global,argc,argv,1,CPU_AVAIL_struct))
2168 {
2169 if ( diskspeedmui_intern.disk_app )
2170 {
2171 for(;;)
2172 {
2173 HandleAll(global,CPU_AVAIL_struct);
2174 if (diskspeedmui_intern.app_ret_val == TRUE)
2175 { Close_GUI(global);
2176 break;
2177 }
2178 }
2179 }
2180 else StartTest(global, CPU_AVAIL_struct);
2181 }
2182 else
2183 {
2184 #ifdef SCSI_SPEED
2185 AddDisplayLine(global,"DRIVE/K,ALL/S,CHIP/S,FAST/S,NOCPU/S,BUF1/K/N,BUF2/K/N,BUF3/K/N,BUF4/K/N,MINTIME/K/N,WINDOW/S");
2186
2187 #else /* SCSI_SPEED */
2188 AddDisplayLine(global,"DRIVE/K,ALL/S,DIR/S,SEEK/S,CHIP/S,FAST/S,LONG/S,WORD/S,BYTE/S,NOCPU/S,BUF1/K/N,BUF2/K/N,BUF3/K/N,BUF4/K/N,MINTIME/K/N,WINDOW/S");
2189
2190 #endif /* SCSI_SPEED */
2191 }
2192 }
2193
2194 int main(int argc, char *argv[])
2195 {
2196 struct DiskSpeed *global;
2197 struct CPU_AVAIL *CPU_AVAIL_struct;
2198
2199 if ((CPU_AVAIL_struct = AllocMem(sizeof(struct CPU_AVAIL),MEMF_PUBLIC|MEMF_CLEAR)))
2200 {
2201 CPU_AVAIL_struct->_CPU_Use_Base = TRUE; /* We want to test with CPU */
2202
2203 if ((global = AllocMem(sizeof(struct DiskSpeed),MEMF_PUBLIC|MEMF_CLEAR)))
2204 {
2205 #if !defined(__AROS__)
2206 MyCatalog = OpenCatalog(NULL, "DiskSpeed.catalog", OC_BuiltInLanguage, "english", TAG_DONE);
2207 #endif
2208 NEWLIST((struct List *)&(global->TextList));
2209 SetVersionStrings(global);
2210 global->Me = (struct Process *)FindTask(NULL);
2211
2212 /* Standard MinTime */
2213 global->Min_Time=MIN_TEST_TIME;
2214
2215 /* Standard sizes */
2216 global->Test_Size[0] = 0x200;
2217 global->Test_Size[1] = 0x1000;
2218 global->Test_Size[2] = 0x8000;
2219 global->Test_Size[3] = 0x40000;
2220 #ifdef SCSI_SPEED
2221 if ((global->timer = Init_Timer()))
2222 {
2223 #if defined (__MORPHOS__)
2224 strcpy(global->Device, SysBase->MaxLocMem ? "scsi.device:0" : "ide.device:0");
2225 #else
2226 strcpy(global->Device, "ata.device:0");
2227 #endif
2228 /*
2229 Now either set up Window or Output
2230 depending on where we were started...
2231
2232 If we can not get Output, we set up the window...
2233 */
2234 if ((argc) && (global->Output=Output())) FromCLI(global,argc,argv,CPU_AVAIL_struct);
2235 else FromWanderer(global,argc,argv,CPU_AVAIL_struct);
2236
2237 Free_Timer(global->timer);
2238 }
2239 #else
2240 if ((global->fib = AllocMem(sizeof(struct FileInfoBlock),MEMF_PUBLIC)))
2241 {
2242 if ((global->timer = Init_Timer()))
2243 {
2244 BPTR lock;
2245 if((lock = Lock("",ACCESS_READ)))
2246 {
2247 char *p;
2248 NameFromLock(lock, global->Device, sizeof(global->Device));
2249 UnLock(lock);
2250
2251 if ((p = strchr(global->Device, ':')))
2252 {
2253 p[1] = '\0';
2254 }
2255 }
2256 /*
2257 Now either set up Window or Output
2258 depending on where we were started...
2259
2260 If we can not get Output, we set up the window...
2261 */
2262 if ((argc) && ((global->Output = Output()))) FromCLI(global,argc,argv,CPU_AVAIL_struct);
2263 else FromWanderer( global,argc,argv,CPU_AVAIL_struct );
2264
2265 Free_Timer(global->timer);
2266 }
2267 FreeMem(global->fib,sizeof(struct FileInfoBlock));
2268 }
2269
2270 #endif /* SCSI_SPEED */
2271 #if !defined(__AROS__)
2272 CloseCatalog(MyCatalog);
2273 #endif
2274 FreeMem(global,sizeof(struct DiskSpeed));
2275 }
2276 FreeMem(CPU_AVAIL_struct,sizeof(struct CPU_AVAIL));
2277 }
2278 return 0;
2279 }
Mirror of AROS' Contrib svn.