home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 28 / amigaformatcd28.iso / -seriously_amiga- / misc / posbb / src / amigaos / io.c < prev    next >
C/C++ Source or Header  |  1998-05-09  |  8KB  |  299 lines
  1. /* this is the sources of IO tests (Test_printf,Test_Write,Test_Read)  */
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <dos/dos.h>
  6. #include <exec/types.h>
  7. #include <exec/memory.h>
  8. #include <devices/timer.h>
  9. #include <math.h>
  10. #include "compiler.h"
  11.  
  12. /****** posbb_tests.c/Test_printf ******************************************
  13. *
  14. *   NAME
  15. *     Test_printf -- Tests the speed of the ANSI function printf().
  16. *
  17. *   SYNOPSIS
  18. *     time = Test_printf( int precision )
  19. *     ULONG Test_printf( int );
  20. *
  21. *   FUNCTION
  22. *     Writes 1,000 times the string "printf test in progress...\n" to stdout
  23. *     and returns the time taken.
  24. *
  25. *   INPUT
  26. *     int precision     the precision of the results. Can be any of
  27. *                       POSBB_PREECISION#?. The higher is the precision wanted,
  28. *                       the higher the time taken. precision is useful on faster
  29. *                       machines,on wich the times will be too low.
  30. *
  31. *
  32. *   RESULT
  33. *     time - number of 1/1000 seconds spent.
  34. *
  35. *   EXAMPLE
  36. *     See posbb.c/Perform_Tests().
  37. *
  38. *   NOTE
  39. *     In future versions it will return a float.
  40. *
  41. *   BUGS
  42. *     It hasn't bugs,but since it can't turn off multitasking,the result
  43. *     could change if the user runs some program or move windows.
  44. *
  45. ****************************************************************************
  46. */
  47. ULONG Test_printf( precision , freeze, mt)
  48. int precision;
  49. BOOL freeze,mt;
  50. {
  51.   ULONG time,secs;
  52.   int c;
  53.   char tmpstr[20];
  54.   struct timeval *time1,*time2;
  55.   time1 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),0);
  56.   time2 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),0);
  57. #ifndef NOFORBID
  58.   if (freeze == TRUE) Forbid();
  59. #endif
  60.   if (mt)
  61.   {
  62.      printf("Press RETURN to start");
  63.      getchar();
  64.   }
  65.   else  GetSysTime(time1);   /* This gets the system time using timer.device. It is opened by posbb.c */
  66.  
  67.   for ( c = 0; c<1000*precision; c++ )
  68.   {
  69.     printf("printf test in progress...\n");
  70.   }
  71.   if (mt)
  72.     {
  73.       DisplayBeep();
  74.       printf("Test finished. Type in the number of seconds taken:");
  75.       secs = atoi(gets(tmpstr));
  76.     }
  77.     else GetSysTime(time2);
  78. #ifndef NOFORBID
  79.   if (freeze == TRUE) Permit();
  80. #endif
  81.   if (mt) time = secs * 1000;
  82.   else
  83.   {
  84.     SubTime(time2,time1);
  85.     time = (time2->tv_secs)*1000+(time2->tv_micro)/1000;
  86.   }
  87.   POSBB_FreeMem(time1,sizeof(struct timeval));
  88.   POSBB_FreeMem(time2,sizeof(struct timeval));
  89.   return time;
  90.  
  91. }
  92. /****** posbb_tests.c/Test_Write ********************************************
  93. *
  94. *   NAME
  95. *     Test_Write -- Tests disk writing speed.
  96. *
  97. *   SYNOPSIS
  98. *     time = Test_Write( STRPTR filename,int precision )
  99. *     double Test_Write( STRPTR ,int );
  100. *
  101. *   FUNCTION
  102. *     Writes a block of data to a file,with dos.library/Write() (in the Amiga
  103. *     version).
  104. *
  105. *   INPUT
  106. *     STRPTR filename   the name of the file to write to.
  107. *
  108. *     int precision     the precision of the results. Can be any of
  109. *                       POSBB_PREECISION#?. The higher is the precision wanted,
  110. *                       the higher the time taken. precision is useful on faster
  111. *                       machines,on wich the times will be too low.
  112. *
  113. *   RESULT
  114. *     time - Time spent ins econds.
  115. *            Returns TRUE if something went wrong ( memory or disk space usually).
  116. *            In future may return differents error codes.
  117. *
  118. *   EXAMPLE
  119. *     See posbb.c/Perform_Tests.
  120. *
  121. *   BUGS
  122. *     No known bugs.
  123. *
  124. ****************************************************************************
  125. */
  126. ULONG Test_Write(STRPTR filename,int precision,BOOL freeze,BOOL mt)
  127. {
  128.   struct timeval *time1,*time2;
  129.   ULONG buf;
  130.   int c;
  131.   ULONG secs,time;
  132.   BPTR file;
  133.   char tmpstr[20];
  134.  
  135.   time1 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),0);
  136.   time2 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),0);
  137.  
  138.   if ( buf=POSBB_AllocMem(262144,0))
  139.   {
  140.     if (file = (BPTR) Open(filename,MODE_NEWFILE))
  141.     {
  142. #ifndef NOFORBID
  143.       if (freeze == TRUE) Forbid();
  144. #endif
  145.     if (mt)
  146.       {
  147.     printf("Press RETURN to start");
  148.     getchar();
  149.       }
  150.       else  GetSysTime(time1);   /* This gets the system time using timer.device. It is opened by posbb.c */
  151.  
  152.       for (c = 0;c<20*precision;c++ )
  153.       {
  154.       Write(file,buf,262144);
  155.       }
  156. if (mt)
  157.     {
  158.       DisplayBeep();
  159.       printf("Test finished. Type in the number of seconds taken:");
  160.       secs = atoi(gets(tmpstr));
  161.     }
  162.     else GetSysTime(time2);
  163. #ifndef NOFORBID
  164.       if (freeze == TRUE) Permit();
  165. #endif
  166.       POSBB_FreeMem(buf,262144);
  167.       Close(file);
  168.     }
  169.   }
  170.   else return TRUE;
  171.   if (mt) time = secs * 1000;
  172.   else
  173.   {
  174.     SubTime(time2,time1);
  175.     time = (time2->tv_secs)*1000+(time2->tv_micro)/1000;
  176.   }
  177.   POSBB_FreeMem(time1,sizeof(struct timeval));
  178.   POSBB_FreeMem(time2,sizeof(struct timeval));
  179.  
  180.   if (file=(BPTR) 0) return TRUE;
  181.   else return time;
  182. }
  183. /****** posbb_tests.c/Test_Read ********************************************
  184. *
  185. *   NAME
  186. *     Test_Read -- Tests disk reading speed.
  187. *
  188. *   SYNOPSIS
  189. *     time = Test_Read( STRPTR filename,int precision )
  190. *     ULONG Test_Read( STRPTR, int );
  191. *
  192. *   FUNCTION
  193. *     Reades a block of data from a file,with dos.library/Read() (in the
  194. *     Amiga version).
  195. *
  196. *   INPUT
  197. *     STRPTR filename   the name of the file to read from
  198. *     int precision     the precision of the results. Can be any of
  199. *                       POSBB_PREECISION#?. The higher is the precision wanted,
  200. *                       the higher the time taken. precision is useful on faster
  201. *                       machines,on wich the times will be too low.
  202. *
  203. *   RESULT
  204. *     time - Time spent in seconds.
  205. *            Returns TRUE if something went wrong ( memory or disk space
  206. *            usually). In future may return differents error codes.
  207. *
  208. *   EXAMPLE
  209. *     See posbb.c/Perform_Tests.
  210. *
  211. *   NOTES
  212. *     In future versions it will use different functions depending on dos.library version.
  213. *     With dos.library V 36+ it will use buffered routines,unbuffered on previous versions.
  214. *     The results given by Test_Read() and Test_Write() depend not only on the disk/filesystem
  215. *     speed, but also on disk fragmentation. For a more reliable test of your HD use
  216. *     other programs.
  217. *.
  218. *   BUGS
  219. *     No known bugs.
  220. *
  221. ****************************************************************************
  222. */
  223. ULONG Test_Read(STRPTR filename,int precision,BOOL freeze,BOOL mt)
  224. {
  225.   struct timeval *time1,*time2;
  226.   ULONG buf;
  227.   int c;
  228.   ULONG secs,time;
  229.   BPTR file=(BPTR) 0;
  230.   char tmpstr[20];
  231.  
  232.   time1 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),0);
  233.   time2 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),0);
  234.  
  235.   if ( buf = POSBB_AllocMem(262144,0))
  236.   {
  237.     if (file = (BPTR) Open(filename,MODE_OLDFILE))
  238.     {
  239. #ifndef NOFORBID
  240.       if (freeze == TRUE) Forbid();
  241. #endif
  242.     if (mt)
  243.       {
  244.     printf("Press RETURN to start");
  245.     getchar();
  246.       }
  247.       else  GetSysTime(time1);   /* This gets the system time using timer.device. It is opened by posbb.c */
  248.  
  249.       for (c=0;c<20*precision;c++)
  250.       {
  251.       Read(file,buf,262144);
  252.       }
  253. if (mt)
  254.     {
  255.       DisplayBeep();
  256.       printf("Test finished. Type in the number of seconds taken:");
  257.       secs = atoi(gets(tmpstr));
  258.     }
  259.     else GetSysTime(time2);
  260. #ifndef NOFORBID
  261.       if (freeze == TRUE) Permit();
  262. #endif
  263.       Close(file);
  264.     }
  265.     POSBB_FreeMem(buf,262144);
  266.   }
  267.   else return TRUE;
  268.   if (mt) time = secs * 1000;
  269.   else
  270.   {
  271.     SubTime(time2,time1);
  272.     time = (time2->tv_secs)*1000+(time2->tv_micro)/1000;
  273.   }
  274.   POSBB_FreeMem(time1,sizeof(struct timeval));
  275.   POSBB_FreeMem(time2,sizeof(struct timeval));
  276.   if (file = (BPTR) 0) return TRUE;
  277.   else return time;
  278. } 
  279. /* qsort isn't finished,yet
  280. int my_comp(s1,s2)
  281. char **s1,**s2;
  282. {
  283.    return(strcmp(*s1, *s2));
  284. }
  285. ULONG Test_qsort(precision)
  286. int precision;
  287. {
  288. ULONG time,secs; int c;
  289.   struct timeval *time1,*time2;
  290.   if (freeze == TRUE) Forbid();
  291.   GetSysTime(time1);
  292.   for(c = 0;c<100*precision;c++){
  293.   qsort(StrList,1000,sizeof(char *),my_comp);
  294.   }
  295.   GetSysTime(time2);
  296.   if (freeze == TRUE) Permit();
  297.   return (time2->tv_secs);
  298. } */
  299.