home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 February / PCO2_97.ISO / filesbbs / os2 / sysb091c.arj / SYSBENCH / SRC / PMB_BENC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-04  |  19.7 KB  |  1,000 lines
  1.  
  2. /* Main benchmark file */
  3.  
  4. #define INCL_DOSMISC
  5. #define INCL_DOSPROCESS
  6. #include <os2.h>
  7.  
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <time.h>
  11. #include <math.h>
  12.  
  13. #include "types.h"
  14. #include "pmb_bench.h"
  15. #include "pmb_datatype.h"
  16.  
  17.  
  18. #define KB 1024
  19. #define MB (1204*1204)
  20. #define d1 (12345678.901*(((double)rand())/RAND_MAX+0.5))
  21. #define d2 (12.345678901*(((double)rand())/RAND_MAX+0.5))
  22. #define MIN_DHRY_TIME 10.0
  23. #define MIN_MEASURE 0.1
  24. #define MARGINAL 1.1
  25.  
  26. static bool mult;  // true -> runs multiple tests in one thread
  27. static void* p;
  28. double mh, mv, md, mm, mc;
  29.  
  30. extern void PostFin(int);
  31. double dtime(void);
  32. static void EndBench(void);
  33. extern double pmb_fft(void);
  34. extern double pmb_flops(void);
  35. extern double pmb_linpack(void);
  36. extern double pmb_dhry(int);
  37. extern double pmb_hanoi(void);
  38. extern double pmb_heaps(void);
  39. extern double pmb_sieve(void);
  40. extern double pmb_diskio_avseek(int);
  41. extern double pmb_buscache_xfer(int);
  42. extern double pmb_diskio_transfer(int);
  43. extern double pmb_diskio_cpupct(int);
  44. extern double pmb_dive_bw(void);
  45. extern double pmb_dive_rot(void);
  46. extern double pmb_dive_ms11(void);
  47. extern double pmb_gfx_bitblitss(void);
  48. extern double pmb_gfx_bitblitms(void);
  49. extern double pmb_gfx_dlines(void);
  50. extern double pmb_gfx_hlines(void);
  51. extern double pmb_gfx_patrect(void);
  52. extern double pmb_gfx_fillrect(void);
  53. extern double pmb_gfx_textrender(void);
  54. extern double pmb_gfx_vlines(void);
  55. extern double pmb_memspeed(s32);
  56. extern double pmb_memspeedr(s32);
  57. extern double pmb_memspeedw(s32);
  58. extern void _Optlink TimeThread(void*);
  59. extern double DoFileIO(ULONG, BOOL, BOOL, BOOL);
  60.  
  61. void DoFileIO4(void*);
  62. void DoFileIO8(void*);
  63. void DoFileIO16(void*);
  64. void DoFileIO32(void*);
  65. void DoFileIO64(void*);
  66. void DoFileIOBuf(ULONG);
  67. void DoFileIOAll(void*);
  68.  
  69. extern struct glob_data data;
  70. extern int gtWarp;
  71. extern ULONG swapfilegrown;
  72. extern ULONG maxswapfilesize;
  73. extern float startsize;
  74. extern volatile int Timeout;
  75. extern BOOL fileiodisabled;
  76.  
  77. double rt;
  78.  
  79. void DoAll(void* p)
  80. {
  81.   mult = true;
  82.   DoAllGraphics(p);
  83.   DoAllCPUInt(p);
  84.   DoAllCPUFloat(p);
  85.   DoAllDIVE(p);
  86.   DoAllDiskIO(p);
  87.   DoFileIOAll(p);
  88.   DoAllMem(p);
  89.   mult = false;
  90.   PostFin(false);
  91. }
  92.  
  93.  
  94. void DoAllCPUFloat(void* p)
  95. {
  96.   if (!mult)
  97.      {
  98.      mult = true;
  99.      DoCPUFloatLinpack(p);
  100.      DoCPUFloatFlops(p);
  101.      DoCPUFloatFFT(p);
  102.      mult = false;
  103.      PostFin(false);
  104.      }
  105.   else
  106.      {
  107.      DoCPUFloatLinpack(p);
  108.      DoCPUFloatFlops(p);
  109.      DoCPUFloatFFT(p);
  110.      }
  111. }
  112.  
  113.  
  114. void DoAllCPUInt(void* p)
  115. {
  116.   if (!mult)
  117.      {
  118.      mult = true;
  119.      DoCPUIntDhry(p);
  120.      DoCPUIntHanoi(p);
  121.      DoCPUIntHeaps(p);
  122.      DoCPUIntSieve(p);
  123.      mult = false;
  124.      PostFin(false);
  125.      }
  126.   else
  127.      {
  128.      DoCPUIntDhry(p);
  129.      DoCPUIntHanoi(p);
  130.      DoCPUIntHeaps(p);
  131.      DoCPUIntSieve(p);
  132.      }
  133. }
  134.  
  135.  
  136. void DoAllDIVE(void* p)
  137. {
  138.   if (!mult)
  139.      {
  140.      mult = true;
  141.      DoDiveVBW(p);
  142.      DoDiveRot(p);
  143.      DoDiveMS11(p);
  144.      mult = false;
  145.      PostFin(false);
  146.      }
  147.   else
  148.      {
  149.      DoDiveVBW(p);
  150.      DoDiveRot(p);
  151.      DoDiveMS11(p);
  152.      }
  153.   }
  154.  
  155.  
  156. void DoAllDiskIO(void* p)
  157. {
  158.   if (!mult)
  159.      {
  160.      mult = true;
  161.      DoDiskIOAvSeek(p);
  162.      DoDiskCacheXfer(p);
  163.      DoDiskIOTransSpeed(p);
  164.      DoDiskIOCPUUsage(p);
  165.      mult = false;
  166.      PostFin(false);
  167.      }
  168.   else
  169.      {
  170.      DoDiskIOAvSeek(p);
  171.      DoDiskCacheXfer(p);
  172.      DoDiskIOTransSpeed(p);
  173.      DoDiskIOCPUUsage(p);
  174.      }
  175. }
  176.  
  177.  
  178. void DoAllGraphics(void* p)
  179. {
  180.   if (!mult)
  181.      {
  182.      mult = true;
  183.      DoGfxBlitBlitSS(p);
  184.      DoGfxBlitBlitMS(p);
  185.      DoGfxFillRect(p);
  186.      DoGfxPatFil(p);
  187.      DoGfxVLines(p);
  188.      DoGfxHLines(p);
  189.      DoGfxDLines(p);
  190.      DoGfxTextRender(p);
  191.      mult = false;
  192.      PostFin(false);
  193.      }
  194.   else
  195.      {
  196.      DoGfxBlitBlitSS(p);
  197.      DoGfxBlitBlitMS(p);
  198.      DoGfxFillRect(p);
  199.      DoGfxPatFil(p);
  200.      DoGfxVLines(p);
  201.      DoGfxHLines(p);
  202.      DoGfxDLines(p);
  203.      DoGfxTextRender(p);
  204.      }
  205. }
  206.  
  207.  
  208. void DoAllMem(void* p)
  209. {
  210.   if (!mult)
  211.      {
  212.      mult = true;
  213.      DoMem5(p);
  214.      DoMem10(p);
  215.      DoMem20(p);
  216.      DoMem40(p);
  217.      DoMem80(p);
  218.      DoMem160(p);
  219.      DoMem320(p);
  220.      DoMem640(p);
  221.      DoMem1280(p);
  222.      DoMemR5(p);
  223.      DoMemR10(p);
  224.      DoMemR20(p);
  225.      DoMemR40(p);
  226.      DoMemR80(p);
  227.      DoMemR160(p);
  228.      DoMemR320(p);
  229.      DoMemR640(p);
  230.      DoMemR1280(p);
  231.      DoMemW5(p);
  232.      DoMemW10(p);
  233.      DoMemW20(p);
  234.      DoMemW40(p);
  235.      DoMemW80(p);
  236.      DoMemW160(p);
  237.      DoMemW320(p);
  238.      DoMemW640(p);
  239.      DoMemW1280(p);
  240.      mult = false;
  241.      PostFin(false);
  242.      }
  243.   else
  244.      {
  245.      DoMem5(p);
  246.      DoMem10(p);
  247.      DoMem20(p);
  248.      DoMem40(p);
  249.      DoMem80(p);
  250.      DoMem160(p);
  251.      DoMem320(p);
  252.      DoMem640(p);
  253.      DoMem1280(p);
  254.      DoMemR5(p);
  255.      DoMemR10(p);
  256.      DoMemR20(p);
  257.      DoMemR40(p);
  258.      DoMemR80(p);
  259.      DoMemR160(p);
  260.      DoMemR320(p);
  261.      DoMemR640(p);
  262.      DoMemR1280(p);
  263.      DoMemW5(p);
  264.      DoMemW10(p);
  265.      DoMemW20(p);
  266.      DoMemW40(p);
  267.      DoMemW80(p);
  268.      DoMemW160(p);
  269.      DoMemW320(p);
  270.      DoMemW640(p);
  271.      DoMemW1280(p);
  272.      }
  273. }
  274.  
  275.  
  276. void DoCPUFloatFFT(void* p)
  277. {
  278.   data.c[comp_cpufloat].datalines[cpufloat_fft].value = pmb_fft();
  279.   EndBench();
  280. }
  281.  
  282.  
  283. void DoCPUFloatFlops(void* p)
  284. {
  285.   data.c[comp_cpufloat].datalines[cpufloat_flops].value = pmb_flops();
  286.   EndBench();
  287. }
  288.  
  289.  
  290. void DoCPUFloatLinpack(void* p)
  291. {
  292.   data.c[comp_cpufloat].datalines[cpufloat_linpack].value = pmb_linpack();
  293.   EndBench();
  294. }
  295.  
  296.  
  297. void DoCPUIntDhry(void* p)
  298. {
  299.   double t1, t2, r, tot_time;
  300.   int loops;
  301.   int notstop = 1;
  302.   loops = 1000;
  303.  
  304.   while (notstop)
  305.      {
  306.      t1 = dtime();
  307.      r = pmb_dhry(loops);
  308.      t2 = dtime();
  309.      tot_time = (t2-t1);
  310.      if (((tot_time) < MIN_DHRY_TIME) || (r < 0))
  311.         {
  312.         if ((tot_time) < MIN_MEASURE)
  313.            {
  314.            loops = MIN_DHRY_TIME/MIN_MEASURE*loops;
  315.            }
  316.         else
  317.            {
  318.            loops = MIN_DHRY_TIME*MARGINAL/(tot_time)*loops;
  319.            }
  320.         }
  321.      else
  322.          {
  323.          break;
  324.          }
  325.      }
  326.   data.c[comp_cpuint].datalines[cpuint_dhrystone].value = r;
  327.   EndBench();
  328. }
  329.  
  330.  
  331. void DoCPUIntHanoi(void* p)
  332. {
  333.   data.c[comp_cpuint].datalines[cpuint_hanoi].value = pmb_hanoi();
  334.   EndBench();
  335. }
  336.  
  337.  
  338. void DoCPUIntHeaps(void* p)
  339. {
  340.   data.c[comp_cpuint].datalines[cpuint_heapsort].value = pmb_heaps();
  341.   EndBench();
  342. }
  343.  
  344.  
  345. void DoCPUIntSieve(void* p)
  346. {
  347.   data.c[comp_cpuint].datalines[cpuint_sieve].value = pmb_sieve();
  348.   EndBench();
  349. }
  350.  
  351.  
  352. void DoDiskIOAvSeek(void* p)
  353. {
  354.   data.c[comp_disk].datalines[disk_avseek].value = (pmb_diskio_avseek(data.selected_disk)/(10*1000));
  355.   EndBench();
  356. }
  357.  
  358.  
  359. void DoDiskCacheXfer(void* p)
  360. {
  361.   data.c[comp_disk].datalines[disk_busxfer].value = (pmb_buscache_xfer(data.selected_disk)*KB);
  362.   EndBench();
  363. }
  364.  
  365.  
  366. void DoDiskIOTransSpeed(void* p)
  367. {
  368.   data.c[comp_disk].datalines[disk_transf].value = (pmb_diskio_transfer(data.selected_disk)*KB);
  369.   EndBench();
  370. }
  371.  
  372.  
  373. void DoDiskIOCPUUsage(void* p)
  374. {
  375.   data.c[comp_disk].datalines[disk_cpupct].value = (pmb_diskio_cpupct(data.selected_disk));
  376.   EndBench();
  377. }
  378.  
  379.  
  380. void DoDiveVBW(void* p)
  381.   {
  382.   double r = -1;
  383.   if (gtWarp)
  384.      {
  385.      r = pmb_dive_bw();
  386.      if (r < 0)
  387.         {
  388.         r = -1.0;
  389.         }
  390.      }
  391.   data.c[comp_dive].datalines[dive_videobw].value = r;
  392.   EndBench();
  393. }
  394.  
  395.  
  396. void DoDiveRot(void* p)
  397. {
  398.   double r = -1;
  399.   if (gtWarp)
  400.      {
  401.      r = pmb_dive_rot();
  402.      if (r < 0)
  403.         {
  404.         r = -1.0;
  405.         }
  406.      }
  407.   data.c[comp_dive].datalines[dive_rotate].value = r;
  408.   EndBench();
  409. }
  410.  
  411.  
  412. void DoDiveMS11(void* p)
  413. {
  414.   double r = 1;
  415.   if (gtWarp)
  416.      {
  417.      r = pmb_dive_ms11();
  418.      if (r < 0)
  419.         {
  420.         r = -1.0;
  421.         }
  422.      }
  423.   data.c[comp_dive].datalines[dive_ms_11].value = r;
  424.   EndBench();
  425. }
  426.  
  427.  
  428. void DoGfxBlitBlitSS(void* p)
  429. {
  430.   data.c[comp_gfx].datalines[gfx_bitblt_SS].value = pmb_gfx_bitblitss();
  431.   EndBench();
  432. }
  433.  
  434.  
  435. void DoGfxBlitBlitMS(void* p)
  436. {
  437.   data.c[comp_gfx].datalines[gfx_bitblt_MS].value = pmb_gfx_bitblitms();
  438.   EndBench();
  439. }
  440.  
  441.  
  442. void DoGfxDLines(void* p)
  443. {
  444.   data.c[comp_gfx].datalines[gfx_dlines].value = pmb_gfx_dlines();
  445.   EndBench();
  446. }
  447.  
  448.  
  449. void DoGfxHLines(void* p)
  450. {
  451.   data.c[comp_gfx].datalines[gfx_hlines].value = pmb_gfx_hlines();
  452.   EndBench();
  453. }
  454.  
  455.  
  456. void DoGfxPatFil(void* p)
  457. {
  458.   data.c[comp_gfx].datalines[gfx_patt_fill].value = pmb_gfx_patrect();
  459.   EndBench();
  460. }
  461.  
  462. void DoGfxFillRect(void* p)
  463. {
  464.   data.c[comp_gfx].datalines[gfx_filled_rect].value = pmb_gfx_fillrect();
  465.   EndBench();
  466. }
  467.  
  468.  
  469. void DoGfxTextRender(void* p)
  470. {
  471.   data.c[comp_gfx].datalines[gfx_textrender].value = pmb_gfx_textrender();
  472.   EndBench();
  473. }
  474.  
  475.  
  476. void DoGfxVLines(void* p)
  477. {
  478.   data.c[comp_gfx].datalines[gfx_vlines].value = pmb_gfx_vlines();
  479.   EndBench();
  480. }
  481.  
  482.  
  483. void DoMem5(void* p)
  484. {
  485.   data.c[comp_mem].datalines[mem_5].value = pmb_memspeed(5*KB);
  486.   EndBench();
  487. }
  488.  
  489.  
  490. void DoMem10(void* p)
  491. {
  492.   data.c[comp_mem].datalines[mem_10].value = pmb_memspeed(10*KB);
  493.   EndBench();
  494. }
  495.  
  496.  
  497. void DoMem20(void* p)
  498. {
  499.   data.c[comp_mem].datalines[mem_20].value = pmb_memspeed(20*KB);
  500.   EndBench();
  501. }
  502.  
  503.  
  504. void DoMem40(void* p)
  505. {
  506.   data.c[comp_mem].datalines[mem_40].value = pmb_memspeed(40*KB);
  507.   EndBench();
  508. }
  509.  
  510.  
  511. void DoMem80(void* p)
  512. {
  513.   data.c[comp_mem].datalines[mem_80].value = pmb_memspeed(80*KB);
  514.   EndBench();
  515. }
  516.  
  517.  
  518. void DoMem160(void* p)
  519. {
  520.   data.c[comp_mem].datalines[mem_160].value = pmb_memspeed(160*KB);
  521.   EndBench();
  522. }
  523.  
  524.  
  525. void DoMem320(void* p)
  526. {
  527.   data.c[comp_mem].datalines[mem_320].value = pmb_memspeed(320*KB);
  528.   EndBench();
  529. }
  530.  
  531.  
  532. void DoMem640(void* p)
  533. {
  534.   data.c[comp_mem].datalines[mem_640].value = pmb_memspeed(640*KB);
  535.   EndBench();
  536. }
  537.  
  538.  
  539. void DoMem1280(void* p)
  540. {
  541.   data.c[comp_mem].datalines[mem_1280].value = pmb_memspeed(1280*KB);
  542.   EndBench();
  543. }
  544.  
  545.  
  546. void DoMemR5(void* p)
  547. {
  548.   data.c[comp_mem].datalines[memr_5].value = pmb_memspeedr(5*KB);
  549.   EndBench();
  550. }
  551.  
  552.  
  553. void DoMemR10(void* p)
  554. {
  555.   data.c[comp_mem].datalines[memr_10].value = pmb_memspeedr(10*KB);
  556.   EndBench();
  557. }
  558.  
  559.  
  560. void DoMemR20(void* p)
  561. {
  562.   data.c[comp_mem].datalines[memr_20].value = pmb_memspeedr(20*KB);
  563.   EndBench();
  564. }
  565.  
  566.  
  567. void DoMemR40(void* p)
  568. {
  569.   data.c[comp_mem].datalines[memr_40].value = pmb_memspeedr(40*KB);
  570.   EndBench();
  571. }
  572.  
  573.  
  574. void DoMemR80(void* p)
  575. {
  576.   data.c[comp_mem].datalines[memr_80].value = pmb_memspeedr(80*KB);
  577.   EndBench();
  578. }
  579.  
  580.  
  581. void DoMemR160(void* p)
  582. {
  583.   data.c[comp_mem].datalines[memr_160].value = pmb_memspeedr(160*KB);
  584.   EndBench();
  585. }
  586.  
  587.  
  588. void DoMemR320(void* p)
  589. {
  590.   data.c[comp_mem].datalines[memr_320].value = pmb_memspeedr(320*KB);
  591.   EndBench();
  592. }
  593.  
  594.  
  595. void DoMemR640(void* p)
  596. {
  597.   data.c[comp_mem].datalines[memr_640].value = pmb_memspeedr(640*KB);
  598.   EndBench();
  599. }
  600.  
  601.  
  602. void DoMemR1280(void* p)
  603. {
  604.   data.c[comp_mem].datalines[memr_1280].value = pmb_memspeedr(1280*KB);
  605.   EndBench();
  606. }
  607.  
  608.  
  609. void DoMemW5(void* p)
  610. {
  611.   data.c[comp_mem].datalines[memw_5].value = pmb_memspeedw(5*KB);
  612.   EndBench();
  613. }
  614.  
  615.  
  616. void DoMemW10(void* p)
  617. {
  618.   data.c[comp_mem].datalines[memw_10].value = pmb_memspeedw(10*KB);
  619.   EndBench();
  620. }
  621.  
  622.  
  623. void DoMemW20(void* p)
  624. {
  625.   data.c[comp_mem].datalines[memw_20].value = pmb_memspeedw(20*KB);
  626.   EndBench();
  627. }
  628.  
  629.  
  630. void DoMemW40(void* p)
  631. {
  632.   data.c[comp_mem].datalines[memw_40].value = pmb_memspeedw(40*KB);
  633.   EndBench();
  634. }
  635.  
  636.  
  637. void DoMemW80(void* p)
  638. {
  639.   data.c[comp_mem].datalines[memw_80].value = pmb_memspeedw(80*KB);
  640.   EndBench();
  641. }
  642.  
  643.  
  644. void DoMemW160(void* p)
  645. {
  646.   data.c[comp_mem].datalines[memw_160].value = pmb_memspeedw(160*KB);
  647.   EndBench();
  648. }
  649.  
  650.  
  651. void DoMemW320(void* p)
  652. {
  653.   data.c[comp_mem].datalines[memw_320].value = pmb_memspeedw(320*KB);
  654.   EndBench();
  655. }
  656.  
  657.  
  658. void DoMemW640(void* p)
  659. {
  660.   data.c[comp_mem].datalines[memw_640].value = pmb_memspeedw(640*KB);
  661.   EndBench();
  662. }
  663.  
  664.  
  665. void DoMemW1280(void* p)
  666. {
  667.   data.c[comp_mem].datalines[memw_1280].value = pmb_memspeedw(1280*KB);
  668.   EndBench();
  669. }
  670.  
  671. void DoFileIOAll(void* p)
  672. {
  673. if (!fileiodisabled)
  674.    {
  675.    if (!mult)
  676.       {
  677.       mult = true;
  678.       DoFileIO4(p);
  679.       DoFileIO8(p);
  680.       DoFileIO16(p);
  681.       DoFileIO32(p);
  682.       DoFileIO64(p);
  683.       mult = false;
  684.       PostFin(false);
  685.       }
  686.    else
  687.       {
  688.       DoFileIO4(p);
  689.       DoFileIO8(p);
  690.       DoFileIO16(p);
  691.       DoFileIO32(p);
  692.       DoFileIO64(p);
  693.       }
  694.    }
  695. }
  696.  
  697.  
  698. void DoFileIO4(void* p)
  699. {
  700.  if (!mult)
  701.     {
  702.     mult = true;
  703.     DoFileIOBuf(4096);
  704.     mult = false;
  705.     EndBench();
  706.     }
  707.  else
  708.     {
  709.     DoFileIOBuf(4096);
  710.     }
  711. }
  712.  
  713.  
  714. void DoFileIO8(void* p)
  715. {
  716.  if (!mult)
  717.     {
  718.     mult = true;
  719.     DoFileIOBuf(8192);
  720.     mult = false;
  721.     EndBench();
  722.     }
  723.  else
  724.     {
  725.     DoFileIOBuf(8192);
  726.     }
  727. }
  728.  
  729.  
  730. void DoFileIO16(void* p)
  731. {
  732.  if (!mult)
  733.     {
  734.     mult = true;
  735.     DoFileIOBuf(16384);
  736.     mult = false;
  737.     EndBench();
  738.     }
  739.  else
  740.     {
  741.     DoFileIOBuf(16384);
  742.     }
  743. }
  744.  
  745.  
  746. void DoFileIO32(void* p)
  747. {
  748.  if (!mult)
  749.     {
  750.     mult = true;
  751.     DoFileIOBuf(32768);
  752.     mult = false;
  753.     EndBench();
  754.     }
  755.  else
  756.     {
  757.     DoFileIOBuf(32768);
  758.     }
  759. }
  760.  
  761.  
  762. void DoFileIO64(void* p)
  763. {
  764.  if (!mult)
  765.     {
  766.     mult = true;
  767.     DoFileIOBuf(65536);
  768.     mult = false;
  769.     EndBench();
  770.     }
  771.  else
  772.     {
  773.     DoFileIOBuf(65536);
  774.     }
  775. }
  776.  
  777.  
  778. void DoFileIOBuf(ULONG buffersize)
  779. {
  780. int n, linenum;
  781. BOOL cache, random, reading;
  782.  
  783. for (cache = 0; cache <= 1; cache++)        /* toggle cache off then on for each */
  784.    {
  785.    for (random = 0; random <= 1; random++)     /* toggle sequential or random access */
  786.       {
  787.       for (reading = 0; reading <= 1; reading++)  /* toggle writing or reading */
  788.          {
  789.          Timeout = 1;           /* show timer not popped */
  790.          n = frexp(buffersize/4096, &linenum);
  791.          linenum = ((linenum - 1) * 8) + (cache * 4) + (random * 2) + (reading);
  792.          _beginthread(TimeThread, NULL, 8192, NULL);                             /* start timer thread */
  793.          data.c[comp_file].datalines[linenum].value = DoFileIO(buffersize, cache, reading, random); /* go do current test */
  794.          EndBench();                                                             /* update display */
  795.          }
  796.       }
  797.    }
  798. }
  799.  
  800.  
  801. void DoRef1Info(void)
  802. {
  803. }
  804.  
  805. void DoRef1Load(void)
  806. {
  807. }
  808.  
  809.  
  810. void DoRef2Info(void)
  811. {
  812. }
  813.  
  814.  
  815. void DoRef2Load(void)
  816. {
  817. }
  818.  
  819.  
  820. double CalcGfxAv(void)
  821. {
  822.   return (
  823.           (data.c[comp_gfx].datalines[gfx_bitblt_SS].value * 10) +
  824.           (data.c[comp_gfx].datalines[gfx_bitblt_MS].value * 8) +
  825.           (data.c[comp_gfx].datalines[gfx_filled_rect].value * 7) +
  826.           (data.c[comp_gfx].datalines[gfx_patt_fill].value * 4) +
  827.           (data.c[comp_gfx].datalines[gfx_vlines].value * 5) +
  828.           (data.c[comp_gfx].datalines[gfx_hlines].value * 5) +
  829.           (data.c[comp_gfx].datalines[gfx_dlines].value * 4) +
  830.           (data.c[comp_gfx].datalines[gfx_textrender].value * 8)
  831.          ) / 51 / 1.0e6;
  832. }
  833.  
  834.  
  835. double CalcCPUIntAv(void)
  836. {
  837.   return (
  838.           (data.c[comp_cpuint].datalines[cpuint_dhrystone].value * 12) +
  839.           (data.c[comp_cpuint].datalines[cpuint_hanoi].value * 5 * 1.0e6)+
  840.           (data.c[comp_cpuint].datalines[cpuint_heapsort].value * 6) +
  841.           (data.c[comp_cpuint].datalines[cpuint_sieve].value * 6)
  842.          ) / 29 / 1.0e6;
  843. }
  844.  
  845.  
  846. double CalcCPUFloatAv(void)
  847. {
  848.   return (
  849.           (data.c[comp_cpufloat].datalines[cpufloat_linpack].value * 10 * 1000) +
  850.           (data.c[comp_cpufloat].datalines[cpufloat_flops].value * 20) +
  851.           (data.c[comp_cpufloat].datalines[cpufloat_fft].value * 9 * 1.0e6)
  852.          ) / 39 / 1.0e6;
  853. }
  854.  
  855.  
  856. double CalcMemAv(void)
  857. {
  858.   return (
  859.           (data.c[comp_mem].datalines[mem_5].value * 7) +
  860.           (data.c[comp_mem].datalines[mem_10].value * 8) +
  861.           (data.c[comp_mem].datalines[mem_20].value * 7) +
  862.           (data.c[comp_mem].datalines[mem_40].value * 7) +
  863.           (data.c[comp_mem].datalines[mem_80].value * 6) +
  864.           (data.c[comp_mem].datalines[mem_160].value * 5) +
  865.           (data.c[comp_mem].datalines[mem_320].value * 4) +
  866.           (data.c[comp_mem].datalines[mem_640].value * 4) +
  867.           (data.c[comp_mem].datalines[mem_1280].value * 3) +
  868.           (data.c[comp_mem].datalines[memr_5].value * 7) +
  869.           (data.c[comp_mem].datalines[memr_10].value * 8) +
  870.           (data.c[comp_mem].datalines[memr_20].value * 7) +
  871.           (data.c[comp_mem].datalines[memr_40].value * 7) +
  872.           (data.c[comp_mem].datalines[memr_80].value * 6) +
  873.           (data.c[comp_mem].datalines[memr_160].value * 5) +
  874.           (data.c[comp_mem].datalines[memr_320].value * 4) +
  875.           (data.c[comp_mem].datalines[memr_640].value * 4) +
  876.           (data.c[comp_mem].datalines[memr_1280].value * 3) +
  877.           (data.c[comp_mem].datalines[memw_5].value * 7) +
  878.           (data.c[comp_mem].datalines[memw_10].value * 8) +
  879.           (data.c[comp_mem].datalines[memw_20].value * 7) +
  880.           (data.c[comp_mem].datalines[memw_40].value * 7) +
  881.           (data.c[comp_mem].datalines[memw_80].value * 6) +
  882.           (data.c[comp_mem].datalines[memw_160].value * 5) +
  883.           (data.c[comp_mem].datalines[memw_320].value * 4) +
  884.           (data.c[comp_mem].datalines[memw_640].value * 4) +
  885.           (data.c[comp_mem].datalines[memw_1280].value * 3)
  886.          ) / (51*3.0) / MB;
  887. }
  888.  
  889.  
  890. double CalcDIVEAv(void)
  891. {
  892.   return (
  893.           (data.c[comp_dive].datalines[dive_videobw].value * 10) +
  894.           (data.c[comp_dive].datalines[dive_rotate].value * 3 * 1.0e6) +
  895.           (data.c[comp_dive].datalines[dive_ms_11].value * 10 * 1.0e6)
  896.          ) / 43 / 1.0e6;
  897. }
  898.  
  899.  
  900. double CalcDiskIOAv(void)
  901. {
  902.   double x;
  903.   x =     ((1/(data.c[comp_disk].datalines[disk_avseek].value / 1.0e-3)) * 1.0e9 / 20.0) +
  904.           (data.c[comp_disk].datalines[disk_busxfer].value * 1) +
  905.           (data.c[comp_disk].datalines[disk_transf].value * 5);
  906.  
  907.   return (x + ( x / (data.c[comp_disk].datalines[disk_cpupct].value * 5) ) ) / 1.0e6;
  908. }
  909.  
  910.  
  911. double CalcFileIOAv(void)
  912. {
  913.   double x = 0;
  914.   int linenum, i, j, k, l;
  915.  
  916.   for (i = 0; i <= 4; i++) /* for number of buffer sizes */
  917.      {
  918.      for (j = 0; j <= 1; j++) /* cached or not */
  919.         {
  920.         for (k = 0; k <= 1; k++) /* seq or random */
  921.            {
  922.            for (l = 0; l <= 1; l++) /* writing or reading */
  923.               {
  924.               linenum = (i * 8) + (j * 4) + (k * 2) + (l);
  925.               x = x + (data.c[comp_file].datalines[linenum].value / KB);
  926.               }
  927.            }
  928.         }
  929.      }
  930.   return (x / 40);   /* total divided by # of tests */
  931. }
  932.  
  933.  
  934. double dtime(void)
  935. {
  936.    return ((double)clock())/CLOCKS_PER_SEC;
  937. /*
  938.    ULONG value[QSV_MAX] = {0};
  939.    APIRET rc = 0UL;
  940.  
  941.    rc = DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, (PVOID)value, sizeof(ULONG));
  942.  
  943.    return((double)*value/CLOCKS_PER_SEC); */
  944. }
  945.  
  946.  
  947. double rtime(void)
  948. {
  949.    return ((double)clock())/CLOCKS_PER_SEC;
  950. /*
  951.    ULONG value[QSV_MAX] = {0};
  952.    APIRET rc = 0UL;
  953.  
  954.    rc = DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, (PVOID)value, sizeof(ULONG));
  955.  
  956.    return((double)*value); */
  957. }
  958.  
  959.  
  960. void logit(char* s)
  961. {
  962.   FILE* f;
  963.   f = fopen("sb_error.log", "a+");
  964.   if (!f)
  965.      {
  966.      exit(234);
  967.      }
  968.   fprintf(f, "%s\n", s);
  969.   fclose(f);
  970. }
  971.  
  972.  
  973. static void EndBench(void)
  974. {
  975.   float size = GetSwapFileSize();
  976.  
  977.   if (startsize < size)
  978.      {
  979.      swapfilegrown++;
  980.      if (size > maxswapfilesize)
  981.         {
  982.         maxswapfilesize = size;
  983.         }
  984.      }
  985.  
  986.   if (!mult)
  987.      {
  988.      PostFin(true);
  989.      PostFin(false);
  990.      _heapmin();        /* free off memory allocated by previous test */
  991.      }
  992.   else
  993.      {
  994.      PostFin(true);
  995.      DosSleep(500); // wait for the window thread to update the screen
  996.      _heapmin();        /* free off memory allocated by previous test */
  997.      }
  998. }
  999.  
  1000.