home *** CD-ROM | disk | FTP | other *** search
/ Inside Multimedia 1995 July / IMM0795.ISO / share / os2 / sysbench / src / pmb_siev.ckr < prev    next >
Text File  |  1994-11-05  |  19KB  |  733 lines
  1. /****************** Start NSIEVE C Source Code ************************/
  2.  
  3. /****************************************************************/
  4. /*                          NSIEVE                              */
  5. /*                     C Program Source                         */
  6. /*          Sieve benchmark for variable sized arrays           */
  7. /*                Version 1.2b, 26 Sep 1992                     */
  8. /*             Al Aburto (aburto@marlin.nosc.mil)               */
  9. /*                      ('ala' on BIX)                          */
  10. /*                                                              */
  11. /*                                                              */
  12. /* This Sieve of Eratosthenes program works with variable size  */
  13. /* arrays. It is a straight forward extension of the original   */
  14. /* Gilbreath version ( Gilbreath, Jim. "A High-Level Language   */
  15. /* Benchmark." BYTE, September 1981, p. 180, and also Gilbreath,*/ 
  16. /* Jim and Gary. "Eratosthenes Revisited: Once More Through the */
  17. /* Sieve." BYTE January 1983, p. 283 ). Unlike the Sieve of     */
  18. /* Gilbreath, NSIEVE uses register long variables, pointers,and */ 
  19. /* large byte arrays via 'malloc()'.  Maximum array size is     */
  20. /* currently set at 2.56 MBytes but this can be increased or    */
  21. /* decreased by changing the program LIMIT constant.  NSIEVE    */
  22. /* provides error checking to ensure correct operation.  Timer  */
  23. /* routines are provided for several different systems. NSIEVE  */
  24. /* results won't generally agree with the Gilbreath Sieve       */
  25. /* results because NSIEVE specifically uses register long       */
  26. /* variables. NSIEVE, and Sieve, are programs designed          */
  27. /* specifically to generate and printout prime numbers (positive*/ 
  28. /* integers which have no other integral factor other than      */
  29. /* itself and unity, as 2,3,5,7,11, ... ). NSIEVE does not      */
  30. /* conduct the 'typical' instructions one might expect from the */
  31. /* mythical 'typical program'. NSIEVE results can be used to    */
  32. /* gain a perspective into the relative performance of different*/
  33. /* computer systems, but they can not be used in isolation to   */
  34. /* categorize the general performance capabilities of any       */
  35. /* computer system (no single benchmark program currently can do*/
  36. /* this).                                                       */
  37. /*                                                              */
  38. /* The program uses a maximum array size of 2.56 MBytes. You can*/
  39. /* increase or lower this value by changing the 'LIMIT' define  */
  40. /* from 9 to a higher or lower value.  Some systems (IBM PC's   */
  41. /* and clones) will be unable to work beyond 'LIMIT = 3' which  */
  42. /* corresponds to an array size of only 40,000 bytes. Be careful*/
  43. /* when specifying LIMIT > 3 for these systems as the system may*/ 
  44. /* crash or hang-up. Normally NSIEVE will stop program execution*/  
  45. /* when 'malloc()' fails.                                       */
  46. /*                                                              */
  47. /* The maximum array size is given by:                          */
  48. /*              size = 5000 * ( 2 ** LIMIT ).                   */
  49. /*                                                              */
  50. /* The array 'Number_Of_Primes[LIMIT]' is intended to hold the  */
  51. /* correct number of primes found for each array size up to     */
  52. /* LIMIT = 20, but the array is only currently defined up to    */
  53. /* LIMIT = 13.                                                  */
  54. /*                                                              */
  55. /* Program outputs to check for correct operation:              */
  56. /*    Array Size  LIMIT    Primes Found      Last Prime         */
  57. /*     (Bytes)                                                  */
  58. /*         8191       0            1899           16381         */
  59. /*        10000       1            2261           19997         */
  60. /*        20000       2            4202           39989         */
  61. /*        40000       3            7836           79999         */
  62. /*        80000       4           14683          160001         */
  63. /*       160000       5           27607          319993         */
  64. /*       320000       6           52073          639997         */
  65. /*       640000       7           98609         1279997         */
  66. /*      1280000       8          187133         2559989         */
  67. /*      2560000       9          356243         5119997         */
  68. /*      5120000      10          679460        10239989         */
  69. /*     10240000      11         1299068        20479999         */
  70. /*     20480000      12         2488465        40960001         */
  71. /*     40960000      13         4774994        81919993         */
  72. /*     81920000      14         -------       ---------         */
  73. /****************************************************************/
  74.  
  75. /****************************************************/
  76. /* Example Compilation:                             */
  77. /* (1) UNIX Systems:                                */
  78. /*     cc -O -DUNIX nsieve.c -o nsieve              */
  79. /*     cc -DUNIX nsieve.c -o nsieve                 */
  80. /****************************************************/
  81.  
  82. #include <stdio.h>
  83. #ifndef vax
  84. #include <stdlib.h>
  85. #endif
  86. #include <math.h>
  87.              /***********************************************/
  88. #define LIMIT 8      /* You may need to change this to '3' for PC's */
  89.              /* and Clones or you can experiment with higher*/
  90.              /* values, but '13' is currently the max.      */
  91.              /***********************************************/
  92.  
  93. /***************************************************************/
  94. /* Timer options. You MUST uncomment one of the options below  */
  95. /* or compile, for example, with the '-DUNIX' option.          */
  96. /***************************************************************/
  97. /* #define Amiga       */
  98. /* #define UNIX        */
  99. /* #define UNIX_Old    */
  100. /* #define VMS         */
  101. /* #define BORLAND_C   */
  102. /* #define MSC         */
  103. /* #define MAC         */
  104. /* #define IPSC        */
  105. /* #define FORTRAN_SEC */
  106. /* #define GTODay      */
  107. /* #define CTimer      */
  108. /* #define UXPM        */
  109.  
  110. #ifdef Amiga
  111. #include <exec/types.h>
  112. #include <ctype.h>
  113. #endif
  114.  
  115. #ifdef BORLAND_C
  116. #include <ctype.h>
  117. #include <dos.h>
  118. #endif
  119.  
  120. #ifdef MSC
  121. #include <ctype.h>
  122. #endif
  123.  
  124. #ifndef TRUE
  125. #define TRUE 1
  126. #define FALSE 0
  127. #endif
  128.  
  129. static double nulltime,runtime,TimeArray[4];
  130. static double reftime,adj_time,emips;
  131. static double hmips,lmips,smips[21];
  132.  
  133. static long L_Prime,N_Prime;      /* Last Prime and Number of Primes Found */
  134. static long ErrorFlag;
  135.  
  136. static long Number_Of_Primes[21]; /* List of Correct Number of Primes for */
  137.                /* each sieve array size.               */
  138.  
  139. static long NLoops[21];
  140.  
  141.  
  142. double pmb_sieve(void)
  143. {
  144.  
  145. long  i,j,k,p;
  146. double sumtime;
  147.  
  148. /*
  149. printf("\n   Sieve of Eratosthenes (Scaled to 10 Iterations)\n");
  150. printf("   Version 1.2b, 26 Sep 1992\n\n");
  151. printf("   Array Size   Number   Last Prime     Linear");       
  152. printf("    RunTime    MIPS\n");
  153. printf("    (Bytes)   of Primes               Time(sec)");      
  154. printf("    (Sec)\n");
  155. */
  156.     
  157.             /*******************************/
  158.             /* Number of        Array Size */
  159.             /* Primes Found      (Bytes)   */
  160. Number_Of_Primes[0] =     1899;      /*       8191 */
  161. Number_Of_Primes[1] =     2261;      /*      10000 */
  162. Number_Of_Primes[2] =     4202;      /*      20000 */
  163. Number_Of_Primes[3] =     7836;      /*      40000 */
  164. Number_Of_Primes[4] =    14683;      /*      80000 */
  165. Number_Of_Primes[5] =    27607;      /*     160000 */
  166. Number_Of_Primes[6] =    52073;      /*     320000 */
  167. Number_Of_Primes[7] =    98609;      /*     640000 */
  168. Number_Of_Primes[8] =   187133;      /*    1280000 */
  169. Number_Of_Primes[9] =   356243;      /*    2560000 */
  170. Number_Of_Primes[10]=   679460;      /*    5120000 */
  171. Number_Of_Primes[11]=  1299068;      /*   10240000 */
  172. Number_Of_Primes[12]=  2488465;      /*   20480000 */
  173. Number_Of_Primes[13]=  4774994;      /*   40960000 */
  174. Number_Of_Primes[14]=        0;      /*   81920000 */
  175. Number_Of_Primes[15]=        0;      /*  163840000 */
  176.  
  177. j = 8191;
  178. k = 256;
  179. p = 0;
  180. SIEVE(j,k,p);
  181.  
  182. for( i=1 ; i<= 20 ; i++)
  183. {
  184.  NLoops[i] = 1;
  185. }
  186.  
  187. p = 8;
  188. if ( runtime > 0.125 ) p = 1;
  189.  
  190. NLoops[0] = 256 * p; 
  191. NLoops[1] = 256 * p; 
  192. NLoops[2] = 128 * p;
  193. NLoops[3] =  64 * p;
  194. NLoops[4] =  32 * p;
  195. NLoops[5] =  16 * p;
  196. NLoops[6] =   8 * p;
  197. NLoops[7] =   4 * p;
  198. NLoops[8] =   2 * p;
  199. NLoops[9] =       p;
  200. NLoops[10] =  p / 2;
  201. NLoops[11] =  p / 4;
  202.  
  203. if ( p == 1 )
  204. {
  205. NLoops[10] = 1;
  206. NLoops[11] = 1;
  207. }
  208.  
  209. sumtime = 0.0;
  210. i = 0;
  211. j = 8191;
  212. k = NLoops[0];
  213. SIEVE(j,k,p);
  214. sumtime = sumtime + runtime;
  215. smips[i] = emips;
  216.  
  217. j = 5000;
  218. ErrorFlag = 0;
  219.  
  220. for( i=1 ; i<= LIMIT ; i++)
  221. {
  222.    j = 2 * j;
  223.  
  224.    k = NLoops[i];
  225.  
  226.    SIEVE(j,k,p);
  227.    smips[i] = emips;
  228.  
  229.    if( ErrorFlag == 0L )
  230.    {
  231.    if( N_Prime != Number_Of_Primes[i] )
  232.    {
  233.      err("Internal error 1 in sieve test");
  234. /*   printf("\n   Error --- Incorrect Number of Primes for Array: %ld\n",j);
  235.    printf("   Number of  Primes  Found is: %ld\n",N_Prime);
  236.    printf("   Correct Number of Primes is: %ld\n",Number_Of_Primes[i]);
  237.    ErrorFlag = 1L;
  238. */
  239.    }
  240.    }
  241.  
  242.    if( ErrorFlag > 0L ) break;
  243.  
  244.    sumtime = sumtime + runtime * ( 8191.0 / (double)j );
  245.  
  246. }
  247.  
  248. if( ErrorFlag == 2L )
  249. {
  250. err("Unable to allocate array for sieve test");
  251. //printf("\n   Could Not Allocate Memory for Array Size: %ld\n",j);
  252. }
  253.  
  254. sumtime = sumtime / (double)i;
  255.  
  256. hmips = 0.0;
  257. lmips = 1.0e+06;
  258. for( k=0 ; k < i ; k++)
  259. {
  260. if( smips[k] > hmips ) hmips = smips[k];
  261. if( smips[k] < lmips ) lmips = smips[k];
  262. }
  263.  
  264. /*printf("\n   Relative to 10 Iterations and the 8191 Array Size:\n");
  265. printf("   Average RunTime = %8.3f (sec)\n",sumtime);
  266. printf("   High  MIPS      = %8.1f\n",hmips);
  267. printf("   Low   MIPS      = %8.1f\n\n",lmips);*/
  268.  
  269.   return (hmips*7.0 + lmips*3.0)/10.0*1.0e6;
  270.  
  271. }
  272.  
  273.  
  274. /**************************************/
  275. /*  Sieve of Erathosthenes Program    */
  276. /**************************************/
  277.  
  278. static SIEVE(m,n,p)
  279. long m,n,p;
  280. {
  281.  
  282. register char *flags;
  283. register long i,prime,k,ci;
  284. register long count,size;
  285.  
  286. long  iter,j;
  287.  
  288. char *ptr;
  289.  
  290. #ifdef vax
  291. char *malloc();
  292. int   free(); 
  293. #endif
  294.  
  295. size  = m - 1;
  296. ptr   = malloc(m);
  297.  
  298.    ErrorFlag = 0L;
  299.    N_Prime   = 0L;
  300.    L_Prime   = 0L;
  301.  
  302.    if( !ptr )
  303.      {
  304.      ErrorFlag = 2L;
  305.      return 0;
  306.      }
  307.  
  308.    flags = ptr;
  309.  
  310.    sieve_time(TimeArray);
  311.    sieve_time(TimeArray);
  312.    nulltime = TimeArray[1];
  313.    if ( nulltime < 0.0 ) nulltime = 0.0;
  314.  
  315.    j = 0;
  316.                            /****************/
  317.                            /* Instructions */
  318.                            /*    *iter     */
  319.                            /****************/
  320.    sieve_time(TimeArray);
  321.    for(iter=1 ; iter<=n ; iter++)                    
  322.    {
  323.    count = 0;                                       
  324.  
  325.    for(i=0 ; i<=size ; i++)                      
  326.    {
  327.    *(flags+i) = TRUE;                                /* 1*size  */
  328.    }                                                 /* 3*size  */
  329.                             
  330.    ci = 0;                                         
  331.      for(i=0 ; i<=size ; i++)                       
  332.      {
  333.        if(*(flags+i))                                /* 2*size  */
  334.        {                                             /* 1*count */
  335.        count++;                                      /* 1*count */
  336.        prime = i + i + 3;                            /* 3*count */
  337.      for(k = i + prime ; k<=size ; k+=prime)     /* 3*count */
  338.      {
  339.      ci++;                                       /* 1*ci    */
  340.      *(flags+k)=FALSE;                           /* 1*ci    */
  341.      }                                           /* 3*ci    */
  342.                              /* 1*count */
  343.        }
  344.      }                                               /* 3*size  */
  345.                             
  346.    j = j + count;                                   
  347.    }                                               
  348.                             
  349.    sieve_time(TimeArray);
  350.  
  351.    free(ptr);
  352.  
  353.    runtime = (TimeArray[1] - nulltime) * 10.0 / (double)n;
  354.  
  355.    if ( m == 8191 ) reftime = runtime;
  356.  
  357.    adj_time = reftime * ( (double)m / 8191.0 );
  358.  
  359.    emips = 9.0*(double)size+9.0*(double)count;
  360.    emips = emips+5.0*(double)ci;
  361.    emips = 1.0e-05*(emips/runtime);
  362.  
  363.    N_Prime = j / n;
  364.    L_Prime = prime;
  365.  
  366.    if ( p != 0L )
  367.    {
  368.    printf("  %9ld   %8ld     %8ld  ",m,N_Prime,L_Prime);
  369.    printf("%9.3f  %9.3f  %6.1f\n",adj_time,runtime,emips);
  370.    }
  371.  
  372. return 0;
  373. }
  374.  
  375. /*****************************************************/
  376. /* Various timer routines.                           */
  377. /* Al Aburto, aburto@marlin.nosc.mil, 26 Sep 1992    */
  378. /*                                                   */
  379. /* sieve_time(p) outputs the elapsed time seconds in p[1] */
  380. /* from a call of sieve_time(p) to the next call of       */
  381. /* sieve_time(p).  Use CAUTION as some of these routines  */
  382. /* will mess up when timing across the hour mark!!!  */
  383. /*                                                   */
  384. /* For timing I use the 'user' time whenever         */
  385. /* possible. Using 'user+sys' time is a separate     */
  386. /* issue.                                            */
  387. /*                                                   */
  388. /*****************************************************/
  389.  
  390. /***********************************/
  391. /* Timer code.                     */
  392. /***********************************/
  393. /*******************/
  394. /*  Amiga sieve_time()  */
  395. /*******************/
  396. #ifdef Amiga
  397. #include <ctype.h>
  398. #define HZ 50
  399.  
  400. sieve_time(p)
  401. double p[];
  402. {
  403.    double q;
  404.  
  405.    struct   tt {
  406.       long  days;
  407.       long  minutes;
  408.       long  ticks;
  409.    } tt;
  410.  
  411.    q = p[2];
  412.  
  413.    DateStamp(&tt);
  414.  
  415.    p[2] = ( (double)(tt.ticks + (tt.minutes * 60L * 50L)) ) / (double)HZ;
  416.    p[1] = p[2] - q;
  417.    
  418.    return 0;
  419. }
  420. #endif
  421.  
  422. /*****************************************************/
  423. /*  UNIX sieve_time(). This is the preferred UNIX timer.  */
  424. /*  Provided by: Markku Kolkka, mk59200@cc.tut.fi    */
  425. /*  HP-UX Addition by: Bo Thide', bt@irfu.se         */
  426. /*****************************************************/
  427. #ifdef UNIX
  428. #include <sys/time.h>
  429. #include <sys/resource.h>
  430.  
  431. #ifdef __hpux
  432. #include <sys/syscall.h>
  433. #define getrusage(a,b) syscall(SYS_getrusage,a,b)
  434. #endif
  435.  
  436. struct rusage rusage;
  437.  
  438. sieve_time(p)
  439. double p[];
  440. {
  441.    double q;
  442.  
  443.    q = p[2];
  444.  
  445.    getrusage(RUSAGE_SELF,&rusage);
  446.  
  447.    p[2] = (double)(rusage.ru_utime.tv_sec);
  448.    p[2] = p[2] + (double)(rusage.ru_utime.tv_usec) * 1.0e-06;
  449.    p[1] = p[2] - q;
  450.    
  451.    return 0;
  452. }
  453. #endif
  454.  
  455. /***************************************************/
  456. /*  UNIX_Old sieve_time(). This is the old UNIX timer.  */
  457. /*  Use only if absolutely necessary as HZ may be  */
  458. /*  ill defined on your system.                    */
  459. /***************************************************/
  460. #ifdef UNIX_Old
  461. #include <sys/types.h>
  462. #include <sys/times.h>
  463. #include <sys/param.h>
  464.  
  465. #ifndef HZ
  466. #define HZ 60
  467. #endif
  468.  
  469. struct tms tms;
  470.  
  471. sieve_time(p)
  472. double p[];
  473. {
  474.    double q;
  475.  
  476.    q = p[2];
  477.  
  478.    times(&tms);
  479.  
  480.    p[2] = (double)(tms.tms_utime) / (double)HZ;
  481.    p[1] = p[2] - q;
  482.    
  483.    return 0;
  484. }
  485. #endif
  486.  
  487. /*********************************************************/
  488. /*  VMS sieve_time() for VMS systems.                         */
  489. /*  Provided by: RAMO@uvphys.phys.UVic.CA                */
  490. /*  Some people have run into problems with this timer.  */
  491. /*********************************************************/
  492. #ifdef VMS
  493. #include time
  494.  
  495. #ifndef HZ
  496. #define HZ 100
  497. #endif
  498.  
  499. struct tbuffer_t
  500.        {
  501.     int proc_user_time;
  502.     int proc_system_time;
  503.     int child_user_time;
  504.     int child_system_time;
  505.        };
  506. struct tbuffer_t tms;
  507.  
  508. sieve_time(p)
  509. double p[];
  510. {
  511.    double q;
  512.  
  513.    q = p[2];
  514.  
  515.    times(&tms);
  516.  
  517.    p[2] = (double)(tms.proc_user_time) / (double)HZ;
  518.    p[1] = p[2] - q;
  519.    
  520.    return 0;
  521. }
  522. #endif
  523.  
  524. /******************************/
  525. /*  BORLAND C sieve_time() for DOS */
  526. /******************************/
  527. #ifdef BORLAND_C
  528. #include <ctype.h>
  529. #include <dos.h>
  530. #include <time.h>
  531.  
  532. #define HZ 100
  533. struct time tnow;
  534.  
  535. sieve_time(p)
  536. double p[];
  537. {
  538.    double q;
  539.  
  540.    q = p[2];
  541.  
  542.    gettime(&tnow);
  543.  
  544.    p[2] = 60.0 * (double)(tnow.ti_min);
  545.    p[2] = p[2] + (double)(tnow.ti_sec);
  546.    p[2] = p[2] + (double)(tnow.ti_hund)/(double)HZ;
  547.    p[1] = p[2] - q;
  548.    
  549.    return 0;
  550. }
  551. #endif
  552.  
  553. /**************************************/
  554. /*  Microsoft C (MSC) sieve_time() for DOS */
  555. /**************************************/
  556. #ifdef MSC
  557. #include <time.h>
  558. #include <ctype.h>
  559.  
  560. #define HZ CLK_TCK
  561. clock_t tnow;
  562.  
  563. sieve_time(p)
  564. double p[];
  565. {
  566.    double q;
  567.  
  568.    q = p[2];
  569.  
  570.    tnow = clock();
  571.  
  572.    p[2] = (double)tnow / (double)HZ;
  573.    p[1] = p[2] - q;
  574.    
  575.    return 0;
  576. }
  577. #endif
  578.  
  579. /*************************************/
  580. /*  Macintosh (MAC) Think C sieve_time()  */
  581. /*************************************/
  582. #ifdef MAC
  583. #include <time.h>
  584.  
  585. #define HZ 60
  586.  
  587. sieve_time(p)
  588. double p[];
  589. {
  590.    double q;
  591.  
  592.    q = p[2];
  593.  
  594.    p[2] = (double)clock() / (double)HZ;
  595.    p[1] = p[2] - q;
  596.    
  597.    return 0;
  598. }
  599. #endif
  600.  
  601. /************************************************************/
  602. /*  iPSC/860 (IPSC) sieve_time() for i860.                       */
  603. /*  Provided by: Dan Yergeau, yergeau@gloworm.Stanford.EDU  */
  604. /************************************************************/
  605. #ifdef IPSC
  606. extern double dclock();
  607.  
  608. sieve_time(p)
  609. double p[];
  610. {
  611.    double q;
  612.  
  613.    q = p[2];
  614.  
  615.    p[2] = dclock();
  616.    p[1] = p[2] - q;
  617.    
  618.    return 0;
  619. }
  620. #endif
  621.  
  622. /**************************************************/
  623. /*  FORTRAN sieve_time() for Cray type systems.        */
  624. /*  This is the preferred timer for Cray systems. */
  625. /**************************************************/
  626. #ifdef FORTRAN_SEC
  627.  
  628. fortran double second();
  629.  
  630. sieve_time(p)
  631. double p[];
  632. {
  633.    double q,v;
  634.  
  635.    q = p[2];
  636.  
  637.    second(&v);
  638.    p[2] = v;
  639.    p[1] = p[2] - q;
  640.    
  641.    return 0;
  642. }
  643. #endif
  644.  
  645. /***********************************************************/
  646. /*  UNICOS C sieve_time() for Cray UNICOS systems.  Don't use   */
  647. /*  unless absolutely necessary as returned time includes  */
  648. /*  'user+system' time.  Provided by: R. Mike Dority,      */
  649. /*  dority@craysea.cray.com                                */
  650. /***********************************************************/
  651. #ifdef CTimer
  652. #include <time.h>
  653.  
  654. sieve_time(p)
  655. double p[];
  656. {
  657.    double    q;
  658.    clock_t   t;
  659.  
  660.        q = p[2];
  661.  
  662.        t = clock();
  663.  
  664.        p[2] = (double)t / (double)CLOCKS_PER_SEC;
  665.        p[1] = p[2] - q;
  666.  
  667.        return 0;
  668. }
  669. #endif
  670.  
  671. /********************************************/
  672. /* Another UNIX timer using gettimeofday(). */
  673. /* However, getrusage() is preferred.       */
  674. /********************************************/
  675. #ifdef GTODay
  676. #include <sys/time.h>
  677.  
  678. struct timeval tnow;
  679.  
  680. sieve_time(p)
  681. double p[];
  682. {
  683.    double q;
  684.  
  685.    q = p[2];
  686.  
  687.    gettimeofday(&tnow,NULL);
  688.    p[2] = (double)tnow.tv_sec + (double)tnow.tv_usec * 1.0e-6;
  689.    p[1] = p[2] - q;
  690.  
  691.    return 0;
  692. }
  693. #endif
  694.  
  695. /*****************************************************/
  696. /*  Fujitsu UXP/M timer.                             */
  697. /*  Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */
  698. /*****************************************************/
  699. #ifdef UXPM
  700. #include <sys/types.h>
  701. #include <sys/timesu.h>
  702. struct tmsu rusage;
  703.  
  704. double sieve_time()
  705. {
  706.    double q;
  707.  
  708.    timesu(&rusage);
  709.  
  710.    q = (double)(rusage.tms_utime) * 1.0e-06;
  711.    
  712.    return q;
  713. }
  714. #endif
  715.  
  716. /*---------------End of nsieve.c, say goodnight Liz! ----------------*/
  717.  
  718. #include <time.h>
  719.  
  720. sieve_time(p)
  721. double p[];
  722. {
  723.    double q;
  724.  
  725.    q = p[2];
  726.  
  727.    p[2] = ((double)clock())/CLOCKS_PER_SEC;
  728.    p[1] = p[2] - q;
  729.    
  730.    return 0;
  731. }
  732.  
  733.