home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 28 / amigaformatcd28.iso / -seriously_amiga- / misc / posbb / src / generic / posbb_tests.c < prev    next >
C/C++ Source or Header  |  1998-05-09  |  9KB  |  442 lines
  1. /* This is the include file containing the code
  2.    for the tests of the generic version.
  3.  
  4.    Most of autodoc's text among functions is that of some old Amiga version,
  5.    so something could be wrong.
  6. */
  7.  
  8. /****** posbb_tests.c/--background-- ***************************************
  9. *
  10. *     These are the functions wich really do tests. All them returns
  11. *     the time taken in seconds.
  12. *
  13. ****************************************************************************
  14. */
  15.  
  16.  
  17. #include <time.h>
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <math.h>
  21. /* #include "posbb_tests.h"  // this would be needed by Test_qsort,not finished,yet
  22. */
  23. #define TRUE -1
  24. #define FALSE 0
  25.  
  26.  
  27.  
  28. /****** posbb_tests.c/Test_CopyMem ******************************************
  29. *
  30. *   NAME
  31. *     Test_CopyMem -- Tests speed of memcpy()
  32. *
  33. *   SYNOPSIS
  34. *     time = Test_CopyMem( void )
  35. *
  36. *     int Test_CopyMem( void );
  37. *
  38. *   FUNCTION
  39. *     Does 100,000 CopyMem() of a 1024 bytes memory block and returns the
  40. *     time it has spent.
  41. *
  42. *   RESULT
  43. *     time - number of seconds it took to do all memory copies.
  44. *            TRUE if something went wrong (usually lack of memory).
  45. *
  46. *   EXAMPLE
  47. *     Examine posbb.c/Perform_Tests().
  48. *
  49. ****************************************************************************
  50. */
  51.  
  52. int Test_CopyMem( precision )
  53. int precision;
  54. {
  55.    time_t time1,time2;
  56.    long *mem1,*mem2;
  57.    long ret=-1,c;
  58.  
  59.    if (mem1=(long *) malloc(1024))
  60.    {
  61.      if (mem2=(long *) malloc(1024))
  62.      {
  63.     
  64.     time1 = time(NULL);
  65.     for ( c = 0; c<(100000 * precision); c++ )
  66.     {
  67.       memcpy(mem2,mem1,1024);
  68.     }
  69.     time2 = time(NULL);
  70.     free(mem1);
  71.     free(mem2);
  72.     return (time2-time1);
  73.      }
  74.      else return TRUE;
  75.    }
  76.    else return TRUE;
  77. }
  78.  
  79. /****** posbb_tests.c/Test_printf ******************************************
  80. *
  81. *   NAME
  82. *     Test_printf -- Tests the speed of the ANSI function printf().
  83. *
  84. *   SYNOPSIS
  85. *     time = Test_printf( void )
  86. *     int Test_printf( void );
  87. *
  88. *   FUNCTION
  89. *     Writes 1,000 times the string "printf test in progress...\n" to stdout
  90. *     and returns the time taken.
  91. *
  92. *   RESULT
  93. *     time - number of seconds taken. No error possible.
  94. *
  95. *   EXAMPLE
  96. *     See posbb.c/Perform_Tests().
  97. *
  98. *   BUGS
  99. *     It hasn't bugs,but since it can't turn off multitasking,the result
  100. *     could change if the user runs some program or move windows.
  101. *
  102. ****************************************************************************
  103. */
  104. int Test_printf( precision )
  105. int precision;
  106. {
  107.   int c;
  108.   time_t time1,time2;
  109.  
  110.   time1 = time(NULL);
  111.   for ( c = 0; c<1000*precision; c++ )
  112.   {
  113.     printf("printf test in progress...\n");
  114.   }
  115.  
  116.   time2 = time(NULL);
  117.   return (time2-time1);
  118. }
  119.  
  120. /****** posbb_tests.c/Test_IMath ********************************************
  121. *
  122. *   NAME
  123. *     Test_IMath -- Tests the speed of some int Math operations.
  124. *
  125. *   SYNOPSIS
  126. *     time = Test_IMath( void )
  127. *     BYTE Test_IMath( void );
  128. *
  129. *   FUNCTION
  130. *     Does 1 million of additions,differences,multiplications and divisions
  131. *     and returns the time it took.
  132. *
  133. *   RESULT
  134. *     time - number of seconds taken. No error can be returned.
  135. *
  136. *   EXAMPLE
  137. *     See posbb.c/Perform_Tests()
  138. **
  139. ****************************************************************************
  140. */
  141.  
  142. int Test_IMath( precision )
  143. int precision;
  144. {
  145.   int c,i=0;
  146.   long *a=0,*b=0,*d=0;
  147.   time_t time1,time2;
  148.  
  149.   a = calloc(sizeof(long),100*precision);
  150.   b = calloc(sizeof(long),100*precision);
  151.   d = calloc(sizeof(long),100*precision);
  152.   /* Initializing b and d table with random values */
  153.   for(i =0;i<(100*precision);i++)
  154.   {
  155.     b[i] = rand();
  156.     d[i] = rand();
  157.   }
  158.   time1 = time(NULL);
  159.   for (c = 0;c<10000;c++)
  160.   {
  161.     for ( i = 0; i<(100 * precision)-3; i+=3 )
  162.     {
  163.       a[i] /= b[i] + d[i];
  164.       a[i+1] *= b[i+1] - d[i+1];
  165.       a[i+2] += b[i+2] * d[i+2];
  166.       a[i+3] -= b[i+3] / d[i+3];
  167.     }
  168.   }
  169.   time2 = time(NULL);
  170.  
  171.   free(a);
  172.   free(b);
  173.   free(d);
  174.   return (time2-time1);
  175. }
  176.  
  177.  
  178. int Test_FPMath( precision )
  179. int precision;
  180. {
  181.     int c,i=0;
  182.     double *a=0,*b,*d;
  183.     time_t time1,time2;
  184.  
  185.     a = calloc(sizeof(double),100*precision);
  186.     b = calloc(sizeof(double),100*precision);
  187.     d = calloc(sizeof(double),100*precision);
  188.     /* Initializing b and d table with random values; */
  189.     for(c =0;c<(100*precision);c++) {
  190.       b[c] = (double) rand();
  191.       d[c] = (double) rand();
  192.     }
  193.   time1 = time(NULL);
  194.   for (c = 0;c<10000;c++)
  195.   {
  196.     for ( i = 0; i<(100 * precision)-3; i+=3 )
  197.     {
  198.       a[i] /= b[i] + d[i];
  199.       a[i+1] *= b[i+1] - d[i+1];
  200.       a[i+2] += b[i+2] * d[i+2];
  201.       a[i+3] -= b[i+3] / d[i+3];
  202.     }
  203.   }
  204.   time2 = time(NULL);
  205.   free(a);
  206.   free(b);
  207.   free(d);
  208.   return (time2-time1);
  209.  
  210. }
  211.  
  212. /****** posbb_tests.c/Test_Write ********************************************
  213. *
  214. *   NAME
  215. *     Test_Write -- Tests disk writing speed.
  216. *
  217. *   SYNOPSIS
  218. *     time = Test_Write( void )
  219. *     int Test_Write( void );
  220. *
  221. *   FUNCTION
  222. *     Writes a block of data to a file,with dos.library/Write() (in the Amiga
  223. *     version).
  224. *
  225. *   INPUT
  226. *     Now void,in future versions a STRPTR,the name of the file to write to.
  227. *
  228. *   RESULT
  229. *     time - Number of seconds taken.
  230. *            Returns TRUE if something went wrong ( memory or disk space usually).
  231. *            In future may return differents error codes.
  232. *
  233. *   EXAMPLE
  234. *     See posbb.c/Perform_Tests.
  235. *
  236. *   BUGS
  237. *     No known bugs.
  238. *
  239. ****************************************************************************
  240. */
  241. /*
  242. int Test_Write( void )
  243. {
  244.   int clk;
  245.   int c;
  246.   long buf;
  247.   BPTR file;
  248.  
  249.   if ( buf=AllocMem(262144,NULL))
  250.   {
  251.     Forbid();
  252.     ( int ) time1 = time(NULL);
  253.     if (( BPTR ) file = Open("RAM:POSBB_TestFile",( ULONG ) MODE_NEWFILE))
  254.     {
  255.       Write(file,buf,262144);
  256.       Close(file);
  257.       ( int ) time1 = time(NULL);
  258.       Permit();
  259.       FreeMem(buf,262144);
  260.     }
  261.   }
  262.   if (file = NULL) return TRUE;
  263.   else return (clk);
  264. }
  265. */
  266.  
  267.  
  268. /****** posbb_tests.c/Test_Read ********************************************
  269. *
  270. * This section of the autodoc isn't finished. See Test_Write().
  271. * The function doesn't works in the generic version,yet.
  272. *
  273. *******
  274. */
  275. /*  This is the Amiga one
  276. int Test_Read( void )
  277. {
  278.   int clk;
  279.   long buf;
  280.   BPTR file = NULL;
  281.  
  282.   if ( buf = AllocMem((262144),0))
  283.   {
  284.     Forbid();
  285.     ( int ) time1 = time(NULL);
  286.     if ( ( BPTR ) file = Open("RAM:POSBB_TestFile",MODE_OLDFILE) )
  287.     {
  288.       Read(file,buf,262144);
  289.       ( int ) l2= clock();
  290.       Permit();
  291.       Close(file);
  292.     }
  293.     FreeMem(buf,262144);
  294.   }
  295.   if (file = NULL) return TRUE;
  296.   else return (clk);
  297. }
  298. */
  299. /****** posbb_tests.c/Test_WritePixel **************************************
  300. *
  301. *   This function doesn't work.In the generic version.
  302. *
  303. ********
  304. */
  305.  
  306. /*
  307. int strsrt(s1,s2)   // this function is needed by Test_qsort,but I'll change them
  308. char *s1,*s2;
  309. {
  310.   return (s1[1]-s2[1]);
  311. }
  312.  
  313.  
  314.  
  315.  
  316. int Test_qsort(precision)   //  This test isn't finished,yet. It doesn't work but I should change it.
  317. int precision;
  318. {
  319.   int c;
  320.   time_t time1,time2;
  321.  
  322.   time1 = time(NULL);
  323.   qsort(StrList,15,sizeof(char *),strsrt);
  324.   time2 = time(NULL);
  325.  
  326.   for (c = 0;c<15;c++)
  327.   {
  328.     printf("%d %s\n",c,StrList[c]);
  329.   }
  330.   return (time2-time1);
  331. }
  332.  
  333. */
  334.  
  335.  
  336. int Test_TMath(precision)
  337. int precision;
  338. {
  339.   time_t time1,time2;
  340.   int c=0;
  341.   double *cosine=0,*sine=0,*tangent=0,angle = 0;
  342.  
  343.   cosine = calloc(sizeof(double),360*precision);
  344.   sine = calloc(sizeof(double),360*precision);
  345.   tangent = calloc(sizeof(double),360*precision);
  346.  
  347.   time1 = time(NULL);
  348.   for(c=0;c<100;c++)
  349.   {
  350.     for(angle=0;angle<360*precision;angle++)
  351.     {
  352.       sine[(int)angle] = sin(angle);
  353.       cosine[(int)angle] = cos(angle);
  354.       tangent[(int)angle] = tan(angle);
  355.     }
  356.   }
  357.   time2 = time(NULL);
  358.   free(sine);
  359.   free(cosine);
  360.   free(tangent);
  361.   return (time2-time1);
  362. }
  363.  
  364. /****** posbb_tests.c/Test_CopyMem_1MB ******************************************
  365. *
  366. *   NAME
  367. *     Test_CopyMem -- Tests speed of memcpy()
  368. *
  369. *   SYNOPSIS
  370. *     time = Test_CopyMem( void )
  371. *
  372. *     int Test_CopyMem( void );
  373. *
  374. *   FUNCTION
  375. *     Does 100 CopyMem() of a 1024 kbytes memory block and returns the
  376. *     time it has spent.
  377. *
  378. *   RESULT
  379. *     time - number of seconds it took to do all memory copies.
  380. *            TRUE if something went wrong (usually lack of memory).
  381. *
  382. *   EXAMPLE
  383. *     Examine posbb.c/Perform_Tests().
  384. *
  385. ****************************************************************************
  386. */
  387.  
  388. int Test_CopyMem_1Mb( precision )
  389. int precision;
  390. {
  391.    time_t time1,time2;
  392.    long *mem1,*mem2;
  393.    long ret=-1,c;
  394.  
  395.    if (mem1=(long *) malloc(1024*1024))
  396.    {
  397.      if (mem2=(long *) malloc(1024*1024))
  398.      {
  399.  
  400.     time1 = time(NULL);
  401.     for ( c = 0; c<(100 * precision); c++ )
  402.     {
  403.       memcpy(mem2,mem1,1024*1024);
  404.     }
  405.     time2 = time(NULL);
  406.     free(mem1);
  407.     free(mem2);
  408.     return (time2-time1);
  409.      }
  410.      else return TRUE;
  411.    }
  412.    else return TRUE;
  413. }
  414. int Test_CopyMem_512kb( precision )
  415. int precision;
  416. {
  417.    time_t time1,time2;
  418.    long *mem1,*mem2;
  419.    long ret=-1,c;
  420.  
  421.    if (mem1=(long *) malloc(512*1024))
  422.    {
  423.      if (mem2=(long *) malloc(512*1024))
  424.      {
  425.  
  426.     time1 = time(NULL);
  427.     for ( c = 0; c<(200 * precision); c++ )
  428.     {
  429.       memcpy(mem2,mem1,512*1024);
  430.     }
  431.     time2 = time(NULL);
  432.     free(mem1);
  433.     free(mem2);
  434.     return (time2-time1);
  435.      }
  436.      else return TRUE;
  437.    }
  438.    else return TRUE;
  439. }
  440.  
  441.  
  442.