home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / lib / mathlib / libconv / TRY / speed2d.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  21.1 KB  |  710 lines
  1. #include <stdio.h>
  2. #include <sys/time.h>
  3. #include <math.h>
  4. #include "conv.h"
  5.  
  6. /* --------- The following definitions change 
  7.         according to precision required -------- */
  8.  
  9.  
  10. #ifdef DOUBLE            /* real double precision    */
  11.  
  12. typedef double this_type;
  13.  
  14. #define OPS_PER_ITER    2
  15.  
  16. void dfir2d_(), simple_dfir2d_(), serial_dfir2d_(), ornl_dfir2d_();
  17. void diir2d_(), simple_diir2d_(), serial_diir2d_(), ornl_diir2d_();
  18. void dcor2d_(), simple_dcor2d_(), serial_dcor2d_(), ornl_dcor2d_();
  19. void dfirm1d_(), simple_dfirm1d_(), serial_dfirm1d_(), ornl_dfirm1d_();
  20. void diirm1d_(), simple_diirm1d_(), serial_diirm1d_(), ornl_diirm1d_();
  21. void dcorm1d_(), simple_dcorm1d_(), serial_dcorm1d_(), ornl_dcorm1d_();
  22. #define MY_FIR2D        dfir2d_
  23. #define MY_IIR2D        diir2d_
  24. #define MY_COR2D        dcor2d_
  25. #define ORNL_FIR2D        ornl_dfir2d_
  26. #define ORNL_IIR2D        ornl_diir2d_
  27. #define ORNL_COR2D        ornl_dcor2d_
  28. #define SIMPLE_FIR2D        simple_dfir2d_
  29. #define SIMPLE_IIR2D        simple_diir2d_
  30. #define SIMPLE_COR2D        simple_dcor2d_
  31. #define MY_FIRM1D        dfirm1d_
  32. #define MY_IIRM1D        diirm1d_
  33. #define MY_CORM1D        dcorm1d_
  34. #define ORNL_FIRM1D        dfirm1d_
  35. #define ORNL_IIRM1D        diirm1d_
  36. #define ORNL_CORM1D        dcorm1d_
  37. #define SIMPLE_FIRM1D        simple_dfirm1d_
  38. #define SIMPLE_IIRM1D        simple_diirm1d_
  39. #define SIMPLE_CORM1D        simple_dcorm1d_
  40.  
  41. #define MY_INIT            dinit_
  42. #define MY_ONE            done_
  43. #define THIS_REAL
  44.  
  45. #endif
  46. #ifdef SINGLE            /* real single precision    */
  47.  
  48. typedef float this_type;
  49.  
  50. #define OPS_PER_ITER    2
  51.  
  52. void sfir2d_(), simple_sfir2d_(), serial_sfir2d_(), ornl_sfir2d_();
  53. void siir2d_(), simple_siir2d_(), serial_siir2d_(), ornl_siir2d_();
  54. void scor2d_(), simple_scor2d_(), serial_scor2d_(), ornl_scor2d_();
  55. void sfirm1d_(), simple_sfirm1d_(), serial_sfirm1d_(), ornl_sfirm1d_();
  56. void siirm1d_(), simple_siirm1d_(), serial_siirm1d_(), ornl_siirm1d_();
  57. void scorm1d_(), simple_scorm1d_(), serial_scorm1d_(), ornl_scorm1d_();
  58. #define MY_FIR2D        sfir2d_
  59. #define MY_IIR2D        siir2d_
  60. #define MY_COR2D        scor2d_
  61. #define ORNL_FIR2D        ornl_sfir2d_
  62. #define ORNL_IIR2D        ornl_siir2d_
  63. #define ORNL_COR2D        ornl_scor2d_
  64. #define SIMPLE_FIR2D        simple_sfir2d_
  65. #define SIMPLE_IIR2D        simple_siir2d_
  66. #define SIMPLE_COR2D        simple_scor2d_
  67.  
  68. #define MY_FIRM1D        sfirm1d_
  69. #define MY_IIRM1D        siirm1d_
  70. #define MY_CORM1D        scorm1d_
  71. #define ORNL_FIRM1D        sfirm1d_
  72. #define ORNL_IIRM1D        siirm1d_
  73. #define ORNL_CORM1D        scorm1d_
  74. #define SIMPLE_FIRM1D        simple_sfirm1d_
  75. #define SIMPLE_IIRM1D        simple_siirm1d_
  76. #define SIMPLE_CORM1D        simple_scorm1d_
  77.  
  78. #define MY_INIT            sinit_
  79. #define MY_ONE            sone_
  80. #define THIS_REAL
  81. #endif
  82.  
  83. #ifdef ZOMPLEX            /* complex double precision    */
  84.  
  85. typedef struct {double real, imag;} this_type;
  86.  
  87. #define OPS_PER_ITER    8
  88.  
  89. void zfir2d_(), simple_zfir2d_(), serial_zfir2d_(), ornl_zfir2d_();
  90. void ziir2d_(), simple_ziir2d_(), serial_ziir2d_(), ornl_ziir2d_();
  91. void zcor2d_(), simple_zcor2d_(), serial_zcor2d_(), ornl_zcor2d_();
  92. void zfirm1d_(), simple_zfirm1d_(), serial_zfirm1d_(), ornl_zfirm1d_();
  93. void ziirm1d_(), simple_ziirm1d_(), serial_ziirm1d_(), ornl_ziirm1d_();
  94. void zcorm1d_(), simple_zcorm1d_(), serial_zcorm1d_(), ornl_zcorm1d_();
  95. #define MY_FIR2D        zfir2d_
  96. #define MY_IIR2D        ziir2d_
  97. #define MY_COR2D        zcor2d_
  98. #define ORNL_FIR2D        ornl_zfir2d_
  99. #define ORNL_IIR2D        ornl_ziir2d_
  100. #define ORNL_COR2D        ornl_zcor2d_
  101. #define SIMPLE_FIR2D        simple_zfir2d_
  102. #define SIMPLE_IIR2D        simple_ziir2d_
  103. #define SIMPLE_COR2D        simple_zcor2d_
  104. #define MY_FIRM1D        zfirm1d_
  105. #define MY_IIRM1D        ziirm1d_
  106. #define MY_CORM1D        zcorm1d_
  107. #define ORNL_FIRM1D        zfirm1d_
  108. #define ORNL_IIRM1D        ziirm1d_
  109. #define ORNL_CORM1D        zcorm1d_
  110. #define SIMPLE_FIRM1D        simple_zfirm1d_
  111. #define SIMPLE_IIRM1D        simple_ziirm1d_
  112. #define SIMPLE_CORM1D        simple_zcorm1d_
  113.  
  114. #define MY_INIT            zinit_
  115. #define MY_ONE            zone_
  116. #define THIS_COMPLEX
  117.  
  118. #endif
  119. #ifdef COMPLEX            /* complex single precision    */
  120.  
  121. typedef struct {float real, imag;} this_type;
  122.  
  123. #define OPS_PER_ITER    8
  124.  
  125. void cfir2d_(), simple_cfir2d_(), serial_cfir2d_(), ornl_cfir2d_();
  126. void ciir2d_(), simple_ciir2d_(), serial_ciir2d_(), ornl_ciir2d_();
  127. void ccor2d_(), simple_ccor2d_(), serial_ccor2d_(), ornl_ccor2d_();
  128. void cfirm1d_(), simple_cfirm1d_(), serial_cfirm1d_(), ornl_cfirm1d_();
  129. void ciirm1d_(), simple_ciirm1d_(), serial_ciirm1d_(), ornl_ciirm1d_();
  130. void ccorm1d_(), simple_ccorm1d_(), serial_ccorm1d_(), ornl_ccorm1d_();
  131. #define MY_FIR2D        cfir2d_
  132. #define MY_IIR2D        ciir2d_
  133. #define MY_COR2D        ccor2d_
  134. #define ORNL_FIR2D        ornl_cfir2d_
  135. #define ORNL_IIR2D        ornl_ciir2d_
  136. #define ORNL_COR2D        ornl_ccor2d_
  137. #define SIMPLE_FIR2D        simple_cfir2d_
  138. #define SIMPLE_IIR2D        simple_ciir2d_
  139. #define SIMPLE_COR2D        simple_ccor2d_
  140.  
  141. #define MY_FIRM1D        cfirm1d_
  142. #define MY_IIRM1D        ciirm1d_
  143. #define MY_CORM1D        ccorm1d_
  144. #define ORNL_FIRM1D        cfirm1d_
  145. #define ORNL_IIRM1D        ciirm1d_
  146. #define ORNL_CORM1D        ccorm1d_
  147. #define SIMPLE_FIRM1D        simple_cfirm1d_
  148. #define SIMPLE_IIRM1D        simple_ciirm1d_
  149. #define SIMPLE_CORM1D        simple_ccorm1d_
  150.  
  151. #define MY_INIT            cinit_
  152. #define MY_ONE            cone_
  153. #define THIS_COMPLEX
  154. #endif
  155.  
  156. /* ---------- The rest is the same    ---------------- */
  157.  
  158. #define MAX_SIZE        111
  159. #define MAX_STRIDE        5
  160. #define INC_STRIDE        2
  161. #define MAX_TIMES        3
  162. #define MIN_OPS            5.e+6
  163.  
  164. #define ABS(a) ( ((a)>0) ? (a) : -(a))
  165. #define MAX(a,b) (((a) < (b)) ? (b) : a)
  166.  
  167. void (*this_fir2d)(), (*my_fir2d)();
  168. void (*this_iir2d)(), (*my_iir2d)();
  169. void (*this_cor2d)(), (*my_cor2d)();
  170. void (*this_firm1d)(), (*my_firm1d)();
  171. void (*this_iirm1d)(), (*my_iirm1d)();
  172. void (*this_corm1d)(), (*my_corm1d)();
  173.  
  174. void GetArguments();
  175. double second();
  176.  
  177. #define PLAIN        0
  178. #define SERIAL        1
  179. #define PARALLEL    2
  180. #define PAR_SER        3
  181. #define    SER_SIM        4
  182. #define    PAR_SIM        5
  183. #define ORNL        6
  184.  
  185. int flag = -1;
  186. int is_speedup;
  187. int n_trials;
  188. int all_run;
  189. int len = 4;
  190.  
  191.     int ldf, size, ldg, ldh, n_times, nf, ng;
  192.     int min_size, max_size, inc_size, size_f, size_g, size_h;
  193.     this_type *vx, *vy, *vz;
  194.  
  195.     double t, x, y, z, zops;
  196.  
  197. main(argc,argv)
  198. int argc;
  199. char *argv[];
  200. {
  201.     int i, j, k;
  202.  
  203. /* ******************************************************* */
  204.     GetArguments( argc, argv);
  205. /* ******************************************************* */
  206.  
  207.     size_f = MAX(max_size, nf);
  208.     size_g = MAX(max_size, ng);
  209.     size_h = size_f + size_g - 1;
  210.  
  211.     vx = (this_type *)malloc( size_f * size_f * sizeof( this_type));
  212.     vy = (this_type *)malloc( size_g * size_g * sizeof( this_type));
  213.     vz = (this_type *)malloc( size_h * size_h * sizeof( this_type));
  214.  
  215.     if( (vx == (this_type *)0) || (vy == (this_type *)0))  {
  216.     fprintf( stderr, "Malloc problem ... Exiting");
  217.     exit( -2);
  218.     }
  219.     i = size_f*size_f;
  220.     j = size_g*size_g;
  221.     MY_INIT( (&i), vx);
  222.     MY_ONE ( (&j), vy);
  223.  
  224.   fprintf( stderr, "SIZE     FIR2D     FIRM1D    COR2D     CORM1D    IIR2D     IIRM1D\n\n");
  225.  
  226.   for( size = min_size; size <= max_size ; size += inc_size ) { 
  227.     size_g = (ng == 0) ? size : ng;
  228.     size_f = (nf == 0) ? size : nf;
  229.     size_h = size_f + size_g - 1;
  230.     zops = (double)size_f * (double)size_g;
  231.     zops = zops * zops * OPS_PER_ITER;
  232.     n_times = MIN_OPS / zops;
  233.     if( n_times < 1) 
  234.     n_times = 1;
  235.     printf("%4d ", size);
  236.     do_it();
  237.  
  238.     printf("\n", x);
  239.     fflush(stdout);
  240.   }
  241.  
  242.     free ( vx);
  243.     free ( vy);
  244.  
  245.     return(0);
  246. }
  247.  
  248.  
  249. do_it() 
  250. {
  251.     int ii, jj, inc, if1, if2, jf1, jf2, ig1, ig2, jg1, jg2, ih1, ih2, jh1, jh2;
  252.     int ione = 1;
  253.     int izero = 0;
  254.     
  255.     this_type alpha, beta;
  256. #ifdef THIS_REAL
  257.     alpha = 1.0; beta =0.0;
  258. #endif
  259. #ifdef THIS_COMPLEX
  260.     alpha.real = 1.0; beta.real =0.0;
  261.     alpha.imag = 0.0; beta.imag =0.2;
  262. #endif
  263.  
  264.     switch (flag) {
  265.     case PLAIN :
  266.         t = second();
  267.           for( ii = 0 ; ii < n_times ; ii++)
  268.         this_fir2d ( &size_f, &size_f, &size_g, &size_g, vx, vy, vz);
  269.         t = second() - t;
  270.         x = size_f * size_g; x *= x; x *= (double)n_times;
  271.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  272.  
  273.         t = second();
  274.           for( ii = 0 ; ii < n_times * size_g ; ii++)
  275.         this_firm1d( &size_f, &size_f, &size_g, vx, vy, vz);
  276.         t = second() - t;
  277.         x = size_f * size_g; x *= x; x *= (double)n_times;
  278.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  279.  
  280.         t = second();
  281.           for( ii = 0 ; ii < n_times ; ii++)
  282.         this_cor2d ( &size_f, &size_f, &size_g, &size_g, vx, vy, vz);
  283.         t = second() - t;
  284.         x = size_f * size_g; x *= x; x *= (double)n_times;
  285.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  286.  
  287.         t = second();
  288.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  289.         this_corm1d( &size_f, &size_f, &size_g, vx, vy, vz);
  290.         t = second() - t;
  291.         x = size_f * size_g; x *= x; x *= (double)n_times;
  292.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  293.  
  294.         t = second();
  295.           for( ii = 0 ; ii < n_times ; ii++)
  296.         this_iir2d ( &size_f, &size_f, &size_g, &size_g, vx, vy, vz);
  297.         t = second() - t;
  298.         x = size_f;  z = MAX((size_f-size_g),0); x = .5 * (x*x-z*z); x = x * x;
  299.         x *= 1.e-6; x *= (double)n_times; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  300.  
  301.         t = second();
  302.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  303.         this_iirm1d( &size_f, &size_f, &size_g, vx, vy, vz);
  304.         t = second() - t;
  305.         x = size_f;  z = MAX((size_f-size_g),0); x = .5 * (x*x-z*z) * size_f * size_g;
  306.         x *= 1.e-6; x *= (double)n_times; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  307.         break;
  308.  
  309.     case ORNL :
  310.     case SERIAL :
  311.     case PARALLEL :
  312.         t = second();
  313.           for( ii = 0 ; ii < n_times ; ii++)
  314.         this_fir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  315.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  316.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h,
  317.                 &alpha, &beta);
  318.         t = second() - t;
  319.         x = size_f * size_g; x *= x; x *= (double)n_times;
  320.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  321.  
  322.         t = second();
  323.           for( ii = 0 ; ii < n_times * size_g ; ii++)
  324.         this_firm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  325.                 vy, &ione,          &izero, &size_g,
  326.                 vz, &ione, &size_h, &izero, &size_h,
  327.                 &alpha, &beta);
  328.         t = second() - t;
  329.         x = size_f * size_g; x *= x; x *= (double)n_times;
  330.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  331.  
  332.         ig1 = -(size_g-1);
  333.         t = second();
  334.           for( ii = 0 ; ii < n_times ; ii++)
  335.         this_cor2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  336.                 vy, &ione, &size_g, &ig1  , &size_g, &ig1  , &size_g,
  337.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h);
  338.         t = second() - t;
  339.         x = size_f * size_g; x *= x; x *= (double)n_times;
  340.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  341.  
  342.         t = second();
  343.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  344.         this_corm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  345.                 vy, &ione,          &ig1  , &size_g,
  346.                 vz, &ione, &size_h, &izero, &size_h);
  347.         t = second() - t;
  348.         x = size_f * size_g; x *= x; x *= (double)n_times;
  349.         x *= 1.e-6; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  350.  
  351.         t = second();
  352.           for( ii = 0 ; ii < n_times ; ii++)
  353.         this_iir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  354.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  355.                 vz, &ione, &size_f, &izero, &size_f, &izero, &size_f);
  356.         t = second() - t;
  357.         x = .5 * size_f * size_f;
  358.         if( size_f > size_g) 
  359.         x = size_g * size_f - .5 * size_g * size_g;
  360.         x *= x; x *= 1.e-6; x *= (double)n_times; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  361.  
  362.         t = second();
  363.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  364.         this_iirm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  365.                 vy, &ione,          &izero, &size_g,
  366.                 vz, &ione, &size_f, &izero, &size_f);
  367.         t = second() - t;
  368.         x = size_f;  z = MAX((size_f-size_g),0); x = .5 * (x*x-z*z) * size_f * size_g;
  369.         x *= 1.e-6; x *= (double)n_times; x = OPS_PER_ITER * x / t;  printf(" %8.2f ", x);
  370.         break;
  371.  
  372.     case PAR_SIM :
  373.     case SER_SIM :
  374.         t = second();
  375.           for( ii = 0 ; ii < n_times ; ii++)
  376.           for( ii = 0 ; ii < n_times ; ii++)
  377.         this_fir2d ( &size_f, &size_f, &size_g, &size_g, vx, vy, vz);
  378.         t = second() - t;
  379.         x = second();
  380.           for( ii = 0 ; ii < n_times ; ii++)
  381.         my_fir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  382.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  383.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h,
  384.                 &alpha, &beta);
  385.         x = second() - x;
  386.         printf( " %8.2f ", t/x);
  387.  
  388.         t = second();
  389.           for( ii = 0 ; ii < n_times * size_g ; ii++)
  390.         this_firm1d( &size_f, &size_f, &size_g, vx, vy, vz);
  391.         t = second() - t;
  392.         x = second();
  393.           for( ii = 0 ; ii < n_times * size_g ; ii++)
  394.         my_firm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  395.                 vy, &ione,          &izero, &size_g,
  396.                 vz, &ione, &size_h, &izero, &size_h,
  397.                 &alpha, &beta);
  398.         x = second() - x;
  399.         printf( " %8.2f ", t/x);
  400.  
  401.         ig1 = -(size_g-1);
  402.         t = second();
  403.           for( ii = 0 ; ii < n_times ; ii++)
  404.         this_cor2d ( &size_f, &size_f, &size_g, &size_g, vx, vy, vz);
  405.         t = second() - t;
  406.         x = second();
  407.           for( ii = 0 ; ii < n_times ; ii++)
  408.         my_cor2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  409.                 vy, &ione, &size_g, &ig1  , &size_g, &ig1  , &size_g,
  410.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h);
  411.         x = second() - x;
  412.         printf( " %8.2f ", t/x);
  413.  
  414.         t = second();
  415.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  416.         this_corm1d( &size_f, &size_f, &size_g, vx, vy, vz);
  417.         t = second() - t;
  418.         x = second();
  419.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  420.         my_corm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  421.                 vy, &ione,          &ig1  , &size_g,
  422.                 vz, &ione, &size_h, &izero, &size_h);
  423.         x = second() - x;
  424.         printf( " %8.2f ", t/x);
  425.  
  426.         t = second();
  427.           for( ii = 0 ; ii < n_times ; ii++)
  428.         this_iir2d ( &size_f, &size_f, &size_g, &size_g, vx, vy, vz);
  429.         t = second() - t;
  430.         x = second();
  431.           for( ii = 0 ; ii < n_times ; ii++)
  432.         my_iir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  433.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  434.                 vz, &ione, &size_f, &izero, &size_f, &izero, &size_f);
  435.         x = second() - x;
  436.         printf( " %8.2f ", t/x);
  437.  
  438.         t = second();
  439.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  440.         this_iirm1d( &size_f, &size_f, &size_g, vx, vy, vz);
  441.         t = second() - t;
  442.         x = second();
  443.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  444.         my_iirm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  445.                 vy, &ione,          &izero, &size_g,
  446.                 vz, &ione, &size_f, &izero, &size_f);
  447.         x = second() - x;
  448.         printf( " %8.2f ", t/x);
  449.         break;
  450.  
  451.     case PAR_SER :
  452.         t = second();
  453.           for( ii = 0 ; ii < n_times ; ii++)
  454.         this_fir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  455.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  456.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h,
  457.                 &alpha, &beta);
  458.         t = second() - t;
  459.         x = second();
  460.           for( ii = 0 ; ii < n_times ; ii++)
  461.         my_fir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  462.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  463.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h,
  464.                 &alpha, &beta);
  465.         x = second() - x;
  466.         printf( " %8.2f ", t/x);
  467.  
  468.         t = second();
  469.           for( ii = 0 ; ii < n_times * size_g ; ii++)
  470.         this_firm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  471.                 vy, &ione,          &izero, &size_g,
  472.                 vz, &ione, &size_h, &izero, &size_h,
  473.                 &alpha, &beta);
  474.         t = second() - t;
  475.         x = second();
  476.           for( ii = 0 ; ii < n_times * size_g ; ii++)
  477.         my_firm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  478.                 vy, &ione,          &izero, &size_g,
  479.                 vz, &ione, &size_h, &izero, &size_h,
  480.                 &alpha, &beta);
  481.         x = second() - x;
  482.         printf( " %8.2f ", t/x);
  483.  
  484.         ig1 = -(size_g-1);
  485.         t = second();
  486.           for( ii = 0 ; ii < n_times ; ii++)
  487.         this_cor2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  488.                 vy, &ione, &size_g, &ig1  , &size_g, &ig1  , &size_g,
  489.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h);
  490.         t = second() - t;
  491.         x = second();
  492.           for( ii = 0 ; ii < n_times ; ii++)
  493.         my_cor2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  494.                 vy, &ione, &size_g, &ig1  , &size_g, &ig1  , &size_g,
  495.                 vz, &ione, &size_h, &izero, &size_h, &izero, &size_h);
  496.         x = second() - x;
  497.         printf( " %8.2f ", t/x);
  498.  
  499.         t = second();
  500.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  501.         this_corm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  502.                 vy, &ione,          &ig1  , &size_g,
  503.                 vz, &ione, &size_h, &izero, &size_h);
  504.         t = second() - t;
  505.         x = second();
  506.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  507.         my_corm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  508.                 vy, &ione,          &ig1  , &size_g,
  509.                 vz, &ione, &size_h, &izero, &size_h);
  510.         x = second() - x;
  511.         printf( " %8.2f ", t/x);
  512.  
  513.         t = second();
  514.           for( ii = 0 ; ii < n_times ; ii++)
  515.         this_iir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  516.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  517.                 vz, &ione, &size_f, &izero, &size_f, &izero, &size_f);
  518.         t = second() - t;
  519.         x = second();
  520.           for( ii = 0 ; ii < n_times ; ii++)
  521.         my_iir2d (    vx, &ione, &size_f, &izero, &size_f, &izero, &size_f,
  522.                 vy, &ione, &size_g, &izero, &size_g, &izero, &size_g,
  523.                 vz, &ione, &size_f, &izero, &size_f, &izero, &size_f);
  524.         x = second() - x;
  525.         printf( " %8.2f ", t/x);
  526.  
  527.         t = second();
  528.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  529.         this_iirm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  530.                 vy, &ione,          &izero, &size_g,
  531.                 vz, &ione, &size_f, &izero, &size_f);
  532.         t = second() - t;
  533.         x = second();
  534.           for( ii = 0 ; ii < n_times*size_g ; ii++)
  535.         my_iirm1d(    vx, &ione, &size_f, &izero, &size_f, &size_f,
  536.                 vy, &ione,          &izero, &size_g,
  537.                 vz, &ione, &size_f, &izero, &size_f);
  538.         x = second() - x;
  539.         printf( " %8.2f ", t/x);
  540.         break;
  541.  
  542.     default :
  543.         fflush( stdout);
  544.         fprintf( stderr, "Lost ... exiting\n");
  545.         exit(-1);
  546.     }
  547. }
  548.  
  549. void GetArguments( argc, argv)
  550. int argc;
  551. char *argv[];
  552. {
  553.     int i, j, k;
  554.     int nerror = 0;
  555.  
  556.     srandom( (123*getpid()) | 0x01);
  557.  
  558. #define ON    1
  559.  
  560.     is_speedup = 0;
  561.     ng = 0;
  562.     nf = 0;
  563.     all_run = 0;
  564.  
  565.     min_size = 16;
  566.     max_size = 1024;
  567.     inc_size = 8;
  568.  
  569.     flag = PLAIN;
  570.  
  571.                 this_fir2d = SIMPLE_FIR2D;
  572.                 this_iir2d = SIMPLE_IIR2D;
  573.                 this_cor2d = SIMPLE_COR2D;
  574.                 this_firm1d = SIMPLE_FIRM1D;
  575.                 this_iirm1d = SIMPLE_IIRM1D;
  576.                 this_corm1d = SIMPLE_CORM1D;
  577. /* ******************************************************* */
  578.     for ( i = 1 ; (i < argc) && (nerror != ON) ; i ++ ) {
  579.     if( argv[i][0] == '-') {
  580.         switch ( argv[i][1]) {
  581.  
  582.         case 'f' :
  583.         case 'F' :  
  584.                 nf = atoi( argv[++i]);
  585.                 break;
  586.         case 'g' :
  587.         case 'G' :  
  588.                 ng = atoi( argv[++i]);
  589.                 break;
  590.         case 'x' :
  591.         case 'X' :  
  592.             flag = PAR_SER;
  593.                 is_speedup = 1;
  594.                 this_fir2d = ORNL_FIR2D;
  595.                 my_fir2d   = MY_FIR2D;
  596.                 this_iir2d = ORNL_IIR2D;
  597.                 my_iir2d   = MY_IIR2D;
  598.                 this_cor2d = ORNL_COR2D;
  599.                 my_cor2d   = MY_COR2D;
  600.                 this_firm1d = ORNL_FIRM1D;
  601.                 my_firm1d   = MY_FIRM1D;
  602.                 this_iirm1d = ORNL_IIRM1D;
  603.                 my_iirm1d   = MY_IIRM1D;
  604.                 this_corm1d = ORNL_CORM1D;
  605.                 my_corm1d   = MY_CORM1D;
  606.                 break;
  607.         case 'y' :
  608.         case 'Y' :  
  609.             flag = SER_SIM;
  610.                 is_speedup = 1;
  611.                 this_fir2d = SIMPLE_FIR2D;
  612.                 my_fir2d   = ORNL_FIR2D;
  613.                 this_iir2d = SIMPLE_IIR2D;
  614.                 my_iir2d   = ORNL_IIR2D;
  615.                 this_cor2d = SIMPLE_COR2D;
  616.                 my_cor2d   = ORNL_COR2D;
  617.                 this_firm1d = SIMPLE_FIRM1D;
  618.                 my_firm1d   = ORNL_FIRM1D;
  619.                 this_iirm1d = SIMPLE_IIRM1D;
  620.                 my_iirm1d   = ORNL_IIRM1D;
  621.                 this_corm1d = SIMPLE_CORM1D;
  622.                 my_corm1d   = ORNL_CORM1D;
  623.                 break;
  624.         case 'z' :
  625.         case 'Z' :  
  626.             flag = PAR_SIM;
  627.                 is_speedup = 1;
  628.                 this_fir2d = SIMPLE_FIR2D;
  629.                 my_fir2d   = MY_FIR2D;
  630.                 this_iir2d = SIMPLE_IIR2D;
  631.                 my_iir2d   = MY_IIR2D;
  632.                 this_cor2d = SIMPLE_COR2D;
  633.                 my_cor2d   = MY_COR2D;
  634.                 this_firm1d = SIMPLE_FIRM1D;
  635.                 my_firm1d   = MY_FIRM1D;
  636.                 this_iirm1d = SIMPLE_IIRM1D;
  637.                 my_iirm1d   = MY_IIRM1D;
  638.                 this_corm1d = SIMPLE_CORM1D;
  639.                 my_corm1d   = MY_CORM1D;
  640.                 break;
  641.         case 'o' :
  642.         case 'O' :  
  643.             flag = ORNL;
  644.                 is_speedup = 0;
  645.                 this_fir2d = ORNL_FIR2D;
  646.                 this_iir2d = ORNL_IIR2D;
  647.                 this_cor2d = ORNL_COR2D;
  648.                 this_firm1d = ORNL_FIRM1D;
  649.                 this_iirm1d = ORNL_IIRM1D;
  650.                 this_corm1d = ORNL_CORM1D;
  651.                 break;
  652.         case 's' :
  653.         case 'S' :  
  654.         case 'p' :
  655.         case 'P' :  
  656.             flag = PARALLEL;
  657.                 this_fir2d = MY_FIR2D;
  658.                 this_iir2d = MY_IIR2D;
  659.                 this_cor2d = MY_COR2D;
  660.                 this_firm1d = MY_FIRM1D;
  661.                 this_iirm1d = MY_IIRM1D;
  662.                 this_corm1d = MY_CORM1D;
  663.                 break;
  664.         default  :  nerror = ON;
  665.         }
  666.     }
  667.     else {
  668.         if( i+1 > argc)
  669.         nerror = ON;
  670.         else { 
  671.         min_size = atoi( argv[i]);i++;
  672.         max_size = atoi( argv[i]);i++;
  673.         inc_size = atoi( argv[i]);
  674.         }
  675.     }
  676.     }
  677.     if( nerror == ON) {
  678.     fprintf( stderr, 
  679.         "Usage : %s [-s -p / -z] [-f nf] [-g ng] <min max inc>\n", argv[0]);
  680.     exit(-1);
  681.     }
  682. }
  683. /* **********************************************************************
  684.  
  685.    give the elapsed wall clock time
  686.  
  687. ********************************************************************** */
  688. double second()
  689. {
  690.         struct timeval s_val;
  691.     struct timezone s_z;
  692.  
  693.     static double zero_time = 0.0;
  694.     static long zero_sec = 0;
  695.     double time;
  696.     long n_sec, n_usec;
  697.  
  698.         gettimeofday(&s_val, &s_z);
  699.  
  700.     n_sec = s_val.tv_sec;
  701.     n_usec = s_val.tv_usec;
  702.     if( zero_time == 0.0 ) {
  703.         zero_sec = n_sec;
  704.         zero_time = 1.0e-6 * (double)n_usec;
  705.     }
  706.     time = (double)(n_sec-zero_sec) + (double)n_usec * 1.0E-6 - zero_time;
  707.     return( time );
  708. }
  709.  
  710.