home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 28 / amigaformatcd28.iso / -seriously_amiga- / misc / posbb / src / amigaos / mem.c < prev    next >
C/C++ Source or Header  |  1998-05-09  |  6KB  |  220 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <dos/dos.h>
  4. #include <exec/types.h>
  5. #include <exec/memory.h>
  6. #include <devices/timer.h>
  7. #include <math.h>
  8. #include "compiler.h"
  9.  
  10.  
  11. /****** posbb_tests.c/Test_POSBB_CopyMem ******************************************
  12. *
  13. *   NAME
  14. *     Test_POSBB_CopyMem -- Tests speed of exec.library/POSBB_CopyMem().
  15. *
  16. *   SYNOPSIS
  17. *     time = Test_CopyMem( int precision )
  18. *
  19. *     ULONG Test_CopyMem( int );
  20. *
  21. *   FUNCTION
  22. *     Does 100,000 CopyMem() of a 1024 bytes memory block and returns the
  23. *     time it has spent.
  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. *     BOOL freeze       if it's TRUE before starting the tests it will Forbid()
  31. *                       (only if NOFORBID isn't defined)
  32. *     BOOL mt           if it's TRUE it ask for a return from the user before starting
  33. *                       and DisplayBeep()s after finishing,so the user can measure
  34. *                       the time. It useful on UAE and emulators in general,'cause on that
  35. *                       systems the time measured by posbb (and any other program) isn't
  36. *                       correct.
  37. *
  38. *
  39. *   RESULT
  40. *     time - Time spent,in micorseconds.
  41. *            TRUE if something went wrong (usually lack of memory,but is very strange
  42. *            that the user hasn't 2048  bytes free).
  43. *
  44. *   EXAMPLE
  45. *     Examine posbb.c/Perform_Tests().
  46. *
  47. *   BUGS
  48. *     It has no known bugs.
  49. *
  50. ****************************************************************************
  51. */
  52. ULONG Test_CopyMem( precision, freeze,mt )
  53. int precision;
  54. BOOL freeze,mt;
  55. {
  56.    struct timeval *time1,*time2;
  57.    int c;
  58.    ULONG mem1,mem2,time,secs;
  59.    char tmpstr[20];
  60.    time1 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),MEMF_FAST);
  61.    time2 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),MEMF_FAST);
  62.  
  63.    if (mem1=POSBB_AllocMem(1024,0))
  64.    {
  65.      if (mem2=POSBB_AllocMem(1024,0))
  66.      {
  67. #ifndef NOFORBID
  68.     if (freeze == TRUE) Forbid(); /* This turns off multitasking */
  69. #endif
  70.     if (mt)
  71.     {
  72.       printf("Press RETURN to start");
  73.       getchar();
  74.     }
  75.     else  GetSysTime(time1);   /* This gets the system time using timer.device. It is opened by posbb.c */
  76.     for ( c = 0; c<100000*precision; c++ )
  77.     {
  78.       POSBB_CopyMem(mem1,mem2,1024);
  79.     }
  80.  
  81.     if (mt)
  82.     {
  83.       DisplayBeep();
  84.       printf("Test finished. Type in the number of seconds taken:");
  85.       secs = atoi(gets(tmpstr));
  86.     }
  87.     else GetSysTime(time2);
  88. #ifndef NOFORBID
  89.     if (freeze == TRUE) Permit(); /* This turns on multitasking again   */
  90. #endif
  91.     POSBB_FreeMem(mem1,1024);
  92.     POSBB_FreeMem(mem2,1024);
  93.      }
  94.      else return TRUE;   /* return true for error */
  95.    }
  96.    else return TRUE;
  97.  
  98.   if (mt) time = secs * 1000;
  99.   else
  100.   {
  101.     SubTime(time2,time1);
  102.     time = (time2->tv_secs)*1000+(time2->tv_micro)/1000;
  103.   }
  104.   POSBB_FreeMem(time1,sizeof(struct timeval));
  105.   POSBB_FreeMem(time2,sizeof(struct timeval));
  106.   return time;
  107. }
  108. ULONG Test_CopyMem_512kb( precision, freeze,mt )
  109. int precision;
  110. BOOL freeze,mt;
  111. {
  112.    struct timeval *time1,*time2;
  113.    int c;
  114.    ULONG mem1,mem2,time,secs;
  115.    char tmpstr[20];
  116.    time1 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),MEMF_FAST);
  117.    time2 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),MEMF_FAST);
  118.  
  119.    if (mem1=POSBB_AllocMem(512*1024,0))
  120.    {
  121.      if (mem2=POSBB_AllocMem(512*1024,0))
  122.      {
  123. #ifndef NOFORBID
  124.     if (freeze == TRUE) Forbid(); /* This turns off multitasking */
  125. #endif
  126.     if (mt)
  127.     {
  128.       printf("Press RETURN to start");
  129.       getchar();
  130.     }
  131.     else  GetSysTime(time1);   /* This gets the system time using timer.device. It is opened by posbb.c */
  132.     for ( c = 0; c<200*precision; c++ )
  133.     {
  134.       POSBB_CopyMem(mem1,mem2,512*1024);
  135.     }
  136.  
  137.     if (mt)
  138.     {
  139.       DisplayBeep();
  140.       printf("Test finished. Type in the number of seconds taken:");
  141.       secs = atoi(gets(tmpstr));
  142.     }
  143.     else GetSysTime(time2);
  144. #ifndef NOFORBID
  145.     if (freeze == TRUE) Permit(); /* This turns on multitasking again   */
  146. #endif
  147.     POSBB_FreeMem(mem1,512*1024);
  148.     POSBB_FreeMem(mem2,512*1024);
  149.      }
  150.      else return TRUE;   /* return true for error */
  151.    }
  152.    else return TRUE;
  153.  
  154.   if (mt) time = secs * 1000;
  155.   else
  156.   {
  157.     SubTime(time2,time1);
  158.     time = (time2->tv_secs)*1000+(time2->tv_micro)/1000;
  159.   }
  160.   POSBB_FreeMem(time1,sizeof(struct timeval));
  161.   POSBB_FreeMem(time2,sizeof(struct timeval));
  162.   return time;
  163. }
  164. ULONG Test_CopyMem_1Mb( precision, freeze,mt )
  165. int precision;
  166. BOOL freeze,mt;
  167. {
  168.    struct timeval *time1,*time2;
  169.    int c;
  170.    ULONG mem1,mem2,time,secs;
  171.    char tmpstr[20];
  172.    time1 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),MEMF_FAST);
  173.    time2 = (struct timeval *) POSBB_AllocMem(sizeof(struct timeval),MEMF_FAST);
  174.  
  175.    if (mem1=POSBB_AllocMem(1024*1024,0))
  176.    {
  177.      if (mem2=POSBB_AllocMem(1024*1024,0))
  178.      {
  179. #ifndef NOFORBID
  180.     if (freeze == TRUE) Forbid(); /* This turns off multitasking */
  181. #endif
  182.     if (mt)
  183.     {
  184.       printf("Press RETURN to start");
  185.       getchar();
  186.     }
  187.     else  GetSysTime(time1);   /* This gets the system time using timer.device. It is opened by posbb.c */
  188.     for ( c = 0; c<100*precision; c++ )
  189.     {
  190.       POSBB_CopyMem(mem1,mem2,1024*1024);
  191.     }
  192.  
  193.     if (mt)
  194.     {
  195.       DisplayBeep();
  196.       printf("Test finished. Type in the number of seconds taken:");
  197.       secs = atoi(gets(tmpstr));
  198.     }
  199.     else GetSysTime(time2);
  200. #ifndef NOFORBID
  201.     if (freeze == TRUE) Permit(); /* This turns on multitasking again   */
  202. #endif
  203.     POSBB_FreeMem(mem1,1024*1024);
  204.     POSBB_FreeMem(mem2,1024*1024);
  205.      }
  206.      else return TRUE;   /* return true for error */
  207.    }
  208.    else return TRUE;
  209.  
  210.   if (mt) time = secs * 1000;
  211.   else
  212.   {
  213.     SubTime(time2,time1);
  214.     time = (time2->tv_secs)*1000+(time2->tv_micro)/1000;
  215.   }
  216.   POSBB_FreeMem(time1,sizeof(struct timeval));
  217.   POSBB_FreeMem(time2,sizeof(struct timeval));
  218.   return time;
  219. }
  220.