home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / demos / x11perf / x11perf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-26  |  30.1 KB  |  1,181 lines
  1. /*****************************************************************************
  2. Copyright 1988, 1989 by Digital Equipment Corporation, Maynard, Massachusetts.
  3.  
  4.                         All Rights Reserved
  5.  
  6. Permission to use, copy, modify, and distribute this software and its 
  7. documentation for any purpose and without fee is hereby granted, 
  8. provided that the above copyright notice appear in all copies and that
  9. both that copyright notice and this permission notice appear in 
  10. supporting documentation, and that the name of Digital not be
  11. used in advertising or publicity pertaining to distribution of the
  12. software without specific, written prior permission.  
  13.  
  14. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  15. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  16. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  17. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  18. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  19. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  20. SOFTWARE.
  21.  
  22. ******************************************************************************/
  23.  
  24. #include <stdio.h>
  25. #include <ctype.h>
  26. #include <signal.h>
  27.  
  28. #ifndef VMS
  29. #include <X11/Xatom.h>
  30. #include <X11/Xos.h>
  31. #else
  32. #include <decw$include/Xatom.h>
  33. #endif
  34. #include "x11perf.h"
  35.  
  36. /* Only for working on ``fake'' servers, for hardware that doesn't exist */
  37. static Bool     drawToFakeServer = False;
  38. static Pixmap   tileToQuery     = None;
  39.  
  40. typedef struct _RopNames { char    *name; int  rop; } RopNameRec, *RopNamePtr;
  41.  
  42. RopNameRec ropNames[] = {
  43.     "clear",        GXclear,    /* 0 */
  44.     "and",        GXand,        /* src AND dst */
  45.     "andReverse",    GXandReverse,    /* src AND NOT dst */
  46.     "copy",        GXcopy,        /* src */
  47.     "andInverted",    GXandInverted,    /* NOT src AND dst */
  48.     "noop",        GXnoop,        /* dst */
  49.     "xor",        GXxor,        /* src XOR dst */
  50.     "or",        GXor,        /* src OR dst */
  51.     "nor",        GXnor,        /* NOT src AND NOT dst */
  52.     "equiv",    GXequiv,    /* NOT src XOR dst */
  53.     "invert",    GXinvert,    /* NOT dst */
  54.     "orReverse",    GXorReverse,    /* src OR NOT dst */
  55.     "copyInverted",    GXcopyInverted,    /* NOT src */
  56.     "orInverted",    GXorInverted,    /* NOT src OR dst */
  57.     "nand",        GXnand,        /* NOT src OR NOT dst */
  58.     "set",        GXset,        /* 1 */
  59. };
  60.  
  61. static Bool     labels        = False;
  62. static int      repeat        = 5;
  63. static int    seconds        = 5;
  64.  
  65. static Window   status;     /* Status window and GC */
  66. static GC       tgc;
  67.  
  68. static double syncTime = 0.0;
  69.  
  70. static int saveargc;
  71. static char **saveargv;
  72.  
  73. static int  numRops = 1;
  74. static int  rops[16] = { GXcopy };
  75. static int  numPlanemasks = 1;
  76. static unsigned long planemasks[256] = { (unsigned long)~0 };
  77.  
  78. static char *foreground = NULL;
  79. static char *background = NULL;
  80.  
  81. static int numSubWindows = 7;
  82. static int subWindows[] = {4, 16, 25, 50, 75, 100, 200, 0};
  83.  
  84. static int  fixedReps = 0;
  85.  
  86. static Bool *doit;
  87.  
  88. static XRectangle ws[] = {  /* Clip rectangles */
  89.     {195, 195, 120, 120},
  90.     { 45, 145, 120, 120},
  91.     {345, 245, 120, 120}
  92.  
  93. };
  94. #define MAXCLIP     (sizeof(ws) / sizeof(ws[0]))
  95. static Window clipWindows[MAXCLIP];
  96. static Colormap cmap;
  97. static int depth = -1;  /* -1 means use default depth */
  98.  
  99. /* ScreenSaver state */
  100. static XParmRec    xparms;
  101. static int ssTimeout, ssInterval, ssPreferBlanking, ssAllowExposures;
  102.  
  103.  
  104. /************************************************
  105. *        time related stuff            *
  106. ************************************************/
  107.  
  108. #ifdef VMS
  109.  
  110. typedef struct _vms_time {
  111.     unsigned long low;
  112.     unsigned long high;
  113. }vms_time;
  114.  
  115. struct timeval {
  116.     long tv_sec;        /* seconds since Jan. 1, 1970 */
  117.     long tv_usec;  /* and microseconds */
  118. };
  119.  
  120. struct timezone {
  121.     int  tz_minuteswest;     /* of Greenwich */
  122.     int  tz_dsttime;    /* type of dst correction to apply */
  123. };
  124.  
  125.  
  126. static int firsttime = True;
  127. static vms_time basetime;
  128.  
  129. int gettimeofday(tp, tzp)
  130.     struct timeval *tp;
  131.     struct timezone *tzp;
  132. {
  133.     vms_time current_time, resultant;
  134.     unsigned long mumble, foo;
  135.     int status;
  136.  
  137.     if (firsttime) {
  138.         sys$gettim(&basetime);
  139.         firsttime = False;
  140.     }
  141.     sys$gettim(¤t_time);
  142.     resultant.high = current_time.high - basetime.high;
  143.     resultant.low = current_time.low - basetime.low;
  144.     if (current_time.low < basetime.low) {
  145.         resultant.high -= 1;
  146.     }
  147.     status = lib$ediv( &(10000000), &resultant, &tp->tv_sec, &tp->tv_usec);
  148.     tp->tv_usec /= 10;
  149.     return 0;
  150. }
  151.  
  152. #endif
  153.  
  154. static struct  timeval start;
  155.  
  156. void PrintTime()
  157. {
  158.     time_t t;
  159.  
  160.     t = time((long *)NULL);
  161.     printf("%s\n", ctime(&t));
  162. }
  163.  
  164. void InitTimes ()
  165. {
  166.     struct timezone foo;
  167.     gettimeofday(&start, &foo);
  168. }
  169.  
  170. double ElapsedTime(correction)
  171.     double correction;
  172. {
  173.     struct timeval stop;
  174.     struct timezone foo;
  175.     
  176.     gettimeofday(&stop, &foo);
  177.     if (stop.tv_usec < start.tv_usec) {
  178.         stop.tv_usec += 1000000;
  179.     stop.tv_sec -= 1;
  180.     }
  181.     return  (double)(stop.tv_usec - start.tv_usec) +
  182.             (1000000.0 * (double)(stop.tv_sec - start.tv_sec)) - correction;
  183. }
  184.  
  185. double RoundTo3Digits(d)
  186.     double d;
  187. {
  188.     /* It's kind of silly to print out things like ``193658.4/sec'' so just
  189.        junk all but 3 most significant digits. */
  190.  
  191.     double exponent, sign;
  192.  
  193.     exponent = 1.0;
  194.     /* the code below won't work if d should happen to be non-positive. */
  195.     if (d < 0.0) {
  196.     d = -d;
  197.     sign = -1.0;
  198.     } else
  199.     sign = 1.0;
  200.     if (d >= 1000.0) {
  201.     do {
  202.         exponent *= 10.0;
  203.     } while (d/exponent >= 1000.0);
  204.     d = (double)((int) (d/exponent + 0.5));
  205.     d *= exponent;
  206.     } else {
  207.     if (d != 0.0) {
  208.         while (d*exponent < 100.0) {
  209.             exponent *= 10.0;
  210.         }
  211.     }
  212.     d = (double)((int) (d*exponent + 0.5));
  213.     d /= exponent;
  214.     }
  215.     return d * sign;
  216. }
  217.  
  218.  
  219. void ReportTimes(usecs, n, str, average)
  220.     double  usecs;
  221.     int     n;
  222.     char    *str;
  223. {
  224.     double msecsperobj, objspersec;
  225.  
  226.     if(usecs != 0.0)
  227.     {
  228.         msecsperobj = usecs / (1000.0 * (double)n);
  229.         objspersec = (double) n * 1000000.0 / usecs;
  230.  
  231.         /* Round obj/sec to 3 significant digits.  Leave msec untouched, to
  232.        allow averaging results from several repetitions. */
  233.         objspersec =  RoundTo3Digits(objspersec);
  234.  
  235.         if (average) {
  236.         printf("%6d trep @ %7.4f msec (%6.1f/sec): %s\n", 
  237.             n, msecsperobj, objspersec, str);
  238.     } else {
  239.         printf("%6d reps @ %7.4f msec (%6.1f/sec): %s\n", 
  240.             n, msecsperobj, objspersec, str);
  241.     }
  242.     } else {
  243.     printf("%6d %sreps @ 0.0 msec (unmeasurably fast): %s\n",
  244.         n, average ? "t" : "", str);
  245.     }
  246.  
  247. }
  248.  
  249.  
  250.  
  251. /************************************************
  252. *        Generic X stuff            *
  253. ************************************************/
  254.  
  255. static char *program_name;
  256. void usage();
  257.  
  258. /*
  259.  * Get_Display_Name (argc, argv) Look for -display, -d, or host:dpy (obselete)
  260.  * If found, remove it from command line.  Don't go past a lone -.
  261.  */
  262. char *Get_Display_Name(pargc, argv)
  263.     int     *pargc;  /* MODIFIED */
  264.     char    **argv; /* MODIFIED */
  265. {
  266.     int     argc = *pargc;
  267.     char    **pargv = argv+1;
  268.     char    *displayname = NULL;
  269.     int     i;
  270.  
  271.     for (i = 1; i != argc; i++) {
  272.     char *arg = argv[i];
  273.  
  274.     if (!strcmp (arg, "-display") || !strcmp (arg, "-d")) {
  275.         if (++i >= argc) usage ();
  276.  
  277.         displayname = argv[i];
  278.         *pargc -= 2;
  279.         continue;
  280.     }
  281.     if (!strcmp(arg,"-")) {
  282.         while (i<argc)  *pargv++ = argv[i++];
  283.         break;
  284.     }
  285.     *pargv++ = arg;
  286.     }
  287.  
  288.     *pargv = NULL;
  289.     return (displayname);
  290. }
  291.  
  292.  
  293. /*
  294.  * Open_Display: Routine to open a display with correct error handling.
  295.  */
  296. Display *Open_Display(display_name)
  297.     char *display_name;
  298. {
  299.     Display *d;
  300.  
  301.     d = XOpenDisplay(display_name);
  302.     if (d == NULL) {
  303.     fprintf (stderr, "%s:  unable to open display '%s'\n",
  304.          program_name, XDisplayName (display_name));
  305.     usage ();
  306.     /* doesn't return */
  307.     }
  308.  
  309.     return(d);
  310. }
  311.  
  312.  
  313. #ifdef SIGNALRETURNSINT
  314. int
  315. #else
  316. void
  317. #endif
  318. Cleanup(sig)
  319.     int sig;
  320. {
  321.     fflush(stdout);
  322.     /* This will screw up if Xlib is in the middle of something */
  323.     XSetScreenSaver(xparms.d, ssTimeout, ssInterval, ssPreferBlanking,
  324.     ssAllowExposures);
  325.     XFlush(xparms.d);
  326.     exit(sig);
  327. }
  328.  
  329.  
  330. /************************************************
  331. *        Performance stuff        *
  332. ************************************************/
  333.  
  334.  
  335. void usage()
  336. {
  337.     char    **cpp;
  338.     int     i = 0;
  339.     static char *help_message[] = {
  340. "where options include:",
  341. "    -display <host:display>   the X server to contact",
  342. "    -sync                     do the tests in synchronous mode",
  343. "    -pack                     pack rectangles right next to each other",
  344. "    -repeat <n>               do tests <n> times (default = 5)",
  345. "    -time <s>                 do tests for <s> seconds each (default = 5)",
  346. /*
  347. "    -draw                     draw after each test -- pmax only",
  348. */
  349. "    -all                      do all tests",
  350. "    -range <test1>[,<test2>]  like all, but do <test1> to <test2>",
  351. "    -labels                   generate test labels for use by fillblnk",
  352. "    -fg                       the foreground color to use",
  353. "    -bg                       the background color to use",
  354. "    -rop <rop0 rop1 ...>      use the given rops to draw (default = GXcopy)",
  355. "    -pm <pm0 pm1 ...>         use the given planemasks to draw (default = ~0)",
  356. "    -depth <depth>            use a visual with <depth> planes per pixel",
  357. "    -reps <n>                 fix the rep count (default = auto scale)",
  358. "    -subs <s0 s1 ...>         a list of the number of sub-windows to use",
  359. "    -v1.2                     perform only v1.2 tests using old semantics",
  360. NULL};
  361.  
  362.     fflush(stdout);
  363.     fprintf(stderr, "usage: %s [-options ...]\n", program_name);
  364.     for (cpp = help_message; *cpp; cpp++) {
  365.     fprintf(stderr, "%s\n", *cpp);
  366.     }
  367.     while (test[i].option != NULL) {
  368.         fprintf(stderr, "    %-24s   %s\n",
  369.         test[i].option, test[i].label);
  370.         i++;
  371.     }
  372.     fprintf(stderr, "\n");
  373.     
  374.     /* Print out original command line as the above usage message is so long */
  375.     for (i = 0; i != saveargc; i++) {
  376.     fprintf(stderr, "%s ", saveargv[i]);
  377.     }
  378.     fprintf(stderr, "\n\n");
  379.     exit (1);
  380. }
  381.  
  382. void NullProc(xp, p)
  383.     XParms  xp;
  384.     Parms   p;
  385. {
  386. }
  387.  
  388. Bool NullInitProc(xp, p, reps)
  389.     XParms  xp;
  390.     Parms   p;
  391.     int reps;
  392. {
  393.     return reps;
  394. }
  395.  
  396.  
  397. void HardwareSync(xp)
  398.     XParms  xp;
  399. {
  400.     /*
  401.      * Some graphics hardware allows the server to claim it is done,
  402.      * while in reality the hardware is busily working away.  So fetch
  403.      * a pixel from the window that was drawn to, which should be
  404.      * enough to make the server wait for the graphics hardware.
  405.      */
  406.     XImage *image;
  407.  
  408.     image = XGetImage(xp->d, xp->w, WIDTH-1, HEIGHT-1, 1, 1, ~0, ZPixmap);
  409.     XDestroyImage(image);
  410. }
  411.  
  412. void DoHardwareSync(xp, p, reps)
  413.     XParms  xp;
  414.     Parms   p;
  415.     int     reps;
  416. {
  417.     int i;
  418.     
  419.     for (i = 0; i != reps; i++) {
  420.     HardwareSync(xp);
  421.     }
  422. }
  423.  
  424. static Test syncTest = {
  425.     "syncTime", "Internal test for finding how long HardwareSync takes",
  426.     NullInitProc, DoHardwareSync, NullProc, NullProc, 
  427.     VALL, NONROP, 0,
  428.     {1}
  429. };
  430.  
  431.  
  432. static Window CreatePerfWindow(xp, x, y, width, height)
  433.     XParms  xp;
  434.     int     width, height, x, y;
  435. {
  436.     XSetWindowAttributes xswa;
  437.     Window w;
  438.     Screen *s;
  439.     int su;
  440.  
  441. /*
  442.     s = DefaultScreenOfDisplay(xp->d);
  443.     su = XDoesBackingStore(s);
  444.     printf("Backing store of screen returns %d\n", su);
  445.     su = XDoesSaveUnders(s);
  446.     printf("Save unders of screen returns %d\n", su);
  447.     su = XPlanesOfScreen(s);
  448.     printf("Planes of screen returns %d\n", su);
  449. */
  450.     xswa.background_pixel = xp->background;
  451.     xswa.border_pixel = xp->foreground;
  452.     xswa.colormap = cmap;
  453.     xswa.override_redirect = True;
  454.     xswa.backing_store = False;
  455.     xswa.save_under = False;
  456.     w = XCreateWindow(xp->d, DefaultRootWindow(xp->d), x, y, width, height, 1,
  457.         xp->vinfo.depth, CopyFromParent, xp->vinfo.visual,
  458.     CWBackPixel | CWBorderPixel | CWColormap | CWOverrideRedirect 
  459.     | CWBackingStore | CWSaveUnder, &xswa);
  460.     XMapWindow (xp->d, w);
  461.     return w;
  462. }
  463.  
  464.  
  465. void CreateClipWindows(xp, clips)
  466.     XParms  xp;
  467.     int     clips;
  468. {
  469.     int j;
  470.     XWindowAttributes    xwa;
  471.  
  472.     (void) XGetWindowAttributes(xp->d, xp->w, &xwa);
  473.     if (clips > MAXCLIP) clips = MAXCLIP;
  474.     for (j = 0; j != clips; j++) {
  475.     clipWindows[j] = CreatePerfWindow(xp,
  476.         xwa.x + ws[j].x, xwa.y + ws[j].y, ws[j].width, ws[j].height);
  477.     }
  478. } /* CreateClipWindows */
  479.  
  480.  
  481. void DestroyClipWindows(xp, clips)
  482.     XParms  xp;
  483.     int     clips;
  484. {
  485.     int j;
  486.  
  487.     if (clips > MAXCLIP) clips = MAXCLIP;
  488.     for (j = 0; j != clips; j++) {
  489.     XDestroyWindow(xp->d, clipWindows[j]);
  490.     }
  491. } /* DestroyClipWindows */
  492.  
  493.  
  494. double DoTest(xp, test, reps)
  495.     XParms  xp;
  496.     Test    *test;
  497.     int     reps;
  498. {
  499.     double  time;
  500.     unsigned int ret_width, ret_height;
  501.  
  502.     /* Tell screen-saver to restart counting again.  See comments below for the
  503.        XSetScreenSaver call. */
  504.     XForceScreenSaver(xp->d, ScreenSaverReset);
  505.     HardwareSync (xp); 
  506.     InitTimes ();
  507.     (*test->proc) (xp, &test->parms, reps);
  508.     HardwareSync(xp);
  509.  
  510.     time = ElapsedTime(syncTime);
  511.     if (drawToFakeServer)
  512.         XQueryBestSize(xp->d, TileShape, tileToQuery,
  513.                32, 32, &ret_width, &ret_height);
  514.     (*test->passCleanup) (xp, &test->parms);
  515.     return time;
  516. }
  517.  
  518.  
  519. int CalibrateTest(xp, test, seconds, usecperobj)
  520.     XParms  xp;
  521.     Test    *test;
  522.     int     seconds;
  523.     double  *usecperobj;
  524. {
  525. #define goal    2500000.0   /* Try to get up to 2.5 seconds            */
  526. #define enough  2000000.0   /* But settle for 2.0 seconds            */
  527. #define tick      10000.0   /* Assume clock not faster than .01 seconds     */
  528.  
  529.     double  usecs;
  530.     int     reps, didreps;  /* Reps desired, reps performed            */
  531.     int     exponent;
  532.  
  533.     /* Attempt to get an idea how long each rep lasts by getting enough
  534.        reps to last more tan enough.  Then scale that up to the number of
  535.        seconds desired.
  536.  
  537.        If init call to test ever fails, return False and test will be skipped.
  538.     */
  539.  
  540.     if (fixedReps != 0) {
  541.     return fixedReps;
  542.     }
  543.     reps = 1;
  544.     for (;;) {
  545.     XDestroySubwindows(xp->d, xp->w);
  546.     XClearWindow(xp->d, xp->w);
  547.     didreps = (*test->init) (xp, &test->parms, reps);
  548.     if (didreps == 0) {
  549.         return 0;
  550.     }
  551.     /* Create clip windows if requested */
  552.     CreateClipWindows(xp, test->clips);
  553.     HardwareSync(xp);
  554.     InitTimes();
  555.     (*test->proc) (xp, &test->parms, reps);
  556.     HardwareSync(xp);
  557.     usecs = ElapsedTime(syncTime);
  558.     (*test->cleanup) (xp, &test->parms);
  559.     DestroyClipWindows(xp, test->clips);
  560.  
  561.     if (didreps != reps) {
  562.         /* The test can't do the number of reps as we asked for.  
  563.            Give up */
  564.         *usecperobj = 
  565.         usecs / (double)(didreps * test->parms.objects);
  566.         return didreps;
  567.     }
  568.     /* Did we go long enough? */
  569.     if (usecs >= enough) break;
  570.  
  571.     /* Don't let too short a clock make new reps wildly high */
  572.     if (usecs < tick) usecs = tick;
  573.  
  574.     /* Try to get up to goal seconds. */
  575.     reps = (int) (goal * (double)reps / usecs) + 1;
  576.     }
  577.  
  578.     *usecperobj = usecs / (double) (reps * test->parms.objects);
  579.     reps = (int) ((double)seconds * 1000000.0 * (double)reps / usecs) + 1;
  580.  
  581.     /* Now round reps up to 1 digit accuracy, so we don't get stupid-looking
  582.        numbers of repetitions. */
  583.     reps--;
  584.     exponent = 1;
  585.     while (reps > 9) {
  586.     reps /= 10;
  587.     exponent *= 10;
  588.     }
  589.     reps = (reps + 1) * exponent;
  590.     return reps;
  591. } /* CalibrateTest */
  592.  
  593. void CreatePerfGCs(xp, func, pm)
  594.     XParms  xp;
  595.     int     func;
  596.     unsigned long   pm;
  597. {
  598.     XGCValues gcvfg, gcvbg;
  599.     unsigned long    fg, bg;
  600.  
  601.     fg = xp->foreground;
  602.     bg = xp->background;
  603.     gcvfg.graphics_exposures = False;
  604.     gcvbg.graphics_exposures = False;
  605.     gcvfg.plane_mask = pm;
  606.     gcvbg.plane_mask = pm;
  607.     gcvfg.function = func;
  608.     gcvbg.function = func;
  609.     
  610.     if (func == GXxor) {
  611.     /* Make test look good visually if possible */
  612.     gcvbg.foreground = gcvfg.foreground = bg ^ fg;
  613.     gcvbg.background = gcvfg.background = bg;
  614.     } else {
  615.     gcvfg.foreground = fg;
  616.     gcvfg.background = bg;
  617.     gcvbg.foreground = bg;
  618.     gcvbg.background = fg;
  619.     }
  620.     xp->fggc = XCreateGC(xp->d, xp->w,
  621.     GCForeground | GCBackground | GCGraphicsExposures
  622.       | GCFunction | GCPlaneMask, &gcvfg);
  623.     xp->bggc = XCreateGC(xp->d, xp->w, 
  624.     GCForeground | GCBackground | GCGraphicsExposures
  625.       | GCFunction | GCPlaneMask, &gcvbg);
  626. }
  627.  
  628.  
  629. void DestroyPerfGCs(xp)
  630.     XParms(xp);
  631. {
  632.     XFreeGC(xp->d, xp->fggc);
  633.     XFreeGC(xp->d, xp->bggc);
  634. }
  635.  
  636. int AllocateColor(display, name, pixel)
  637.     Display     *display;
  638.     char    *name;
  639.     int        pixel;
  640. {
  641.     XColor      color;
  642.  
  643.     if (name != NULL) {
  644.     /* Try to parse color name */
  645.     if (XParseColor(display, cmap, name, &color)) {
  646.         if (XAllocColor(display, cmap, &color)) {
  647.         pixel = color.pixel;
  648.         } else {
  649.         (void) fprintf(stderr,
  650.             "Can't allocate colormap entry for color %s\n", name);
  651.         }
  652.     } else {
  653.         (void) fprintf(stderr, "Can't parse color name %s\n", name);
  654.     }
  655.     }
  656.     return pixel;
  657. } /* AllocateColor */
  658.  
  659.  
  660. void DisplayStatus(d, message, test)
  661.     Display *d;
  662.     char    *message;
  663.     char    *test;
  664. {
  665.     char    s[500];
  666.  
  667.     XClearWindow(d, status);
  668.     sprintf(s, "%s %s", message, test);
  669.     /* We should really look at the height, descent of the font, etc. but
  670.        who cares.  This works. */
  671.     XDrawString(d, status, tgc, 10, 13, s, strlen(s));
  672. }
  673.  
  674.  
  675. void ProcessTest(xp, test, func, pm, label)
  676.     XParms  xp;
  677.     Test    *test;
  678.     int     func;
  679.     unsigned long   pm;
  680.     char    *label;
  681. {
  682.     double  time, totalTime;
  683.     int     reps, fooreps;
  684.     int     j;
  685.  
  686.     CreatePerfGCs(xp, func, pm);
  687.     DisplayStatus(xp->d, "Calibrating", label);
  688.     reps = CalibrateTest(xp, test, seconds, &time);
  689.     if (reps != 0) {
  690.     DisplayStatus(xp->d, "Testing", label);
  691.     XDestroySubwindows(xp->d, xp->w);
  692.     XClearWindow(xp->d, xp->w);
  693.     reps = (*test->init) (xp, &test->parms, reps);
  694.     /* Create clip windows if requested */
  695.     CreateClipWindows(xp, test->clips);
  696.  
  697.     totalTime = 0.0;
  698.     for (j = 0; j != repeat; j++) {
  699.         time = DoTest(xp, test, reps);
  700.         totalTime += time;
  701.         ReportTimes (time, reps * test->parms.objects,
  702.             label, False);
  703.     }
  704.     if (repeat > 1) {
  705.         ReportTimes(totalTime,
  706.         repeat * reps * test->parms.objects,
  707.         label, True);
  708.     }
  709.     (*test->cleanup) (xp, &test->parms);
  710.     DestroyClipWindows(xp, test->clips);
  711.     } else {
  712.     /* Test failed to initialize properly */
  713.     }
  714.     printf ("\n");
  715.     fflush(stdout);
  716.     DestroyPerfGCs(xp);
  717. } /* ProcessTest */
  718.  
  719.  
  720. main(argc, argv)
  721.     int argc;
  722.     char **argv;
  723.  
  724. {
  725.     int        i, j, n, skip;
  726.     int        numTests;       /* Even though the linker knows, we don't. */
  727.     char    hostname[100];
  728.     char    *displayName;
  729.     Bool    foundOne = False;
  730.     Bool    synchronous = False;
  731.     XGCValues    tgcv;
  732.     int        screen;
  733.     int        rop, pm;
  734.     XVisualInfo *vinfolist, vinfotempl;
  735.     unsigned long vmask;
  736.  
  737.     /* Save away argv, argc, for usage to print out */
  738.     saveargc = argc;
  739.     saveargv = (char **) malloc(argc * sizeof(char *));
  740.     for (i = 0; i != argc; i++) {
  741.     saveargv[i] = argv[i];
  742.     }
  743.  
  744.     xparms.pack = False;
  745.     xparms.version = VERSION1_3;
  746.  
  747.     /* Count number of tests */
  748.     ForEachTest(numTests);
  749.     doit = (Bool *)calloc(numTests, sizeof(Bool));
  750.  
  751.     /* Parse arguments */
  752.     program_name = argv[0];
  753.     displayName = Get_Display_Name (&argc, argv);
  754.     for (i = 1; i != argc; i++) {
  755.     if (strcmp (argv[i], "-all") == 0) {
  756.         ForEachTest (j)
  757.         doit[j] = True;
  758.         foundOne = True;
  759.     } else if (strcmp (argv[i], "-labels") == 0) {
  760.         labels = True;
  761.     } else if (strcmp(argv[i], "-range") == 0) {
  762.         char *cp1;
  763.         char *cp2;
  764.         
  765.         if (argc <= ++i)
  766.         usage();
  767.         cp1 = argv[i];
  768.         if (*cp1 == '-')
  769.         *cp1++;
  770.         for (cp2 = cp1; *cp2 != '\0' && *cp2 != ','; cp2++) {};
  771.         if (*cp2 == ',') {
  772.         *cp2++ = '\0';
  773.         if (*cp2 == '-')
  774.             *cp2++;
  775.         } else {
  776.         cp2 = "-";
  777.         }
  778.         ForEachTest (j) {
  779.         if (strcmp (cp1, (test[j].option) + 1) == 0 &&
  780.             (test[j].versions & xparms.version)) {
  781.             int k = j;
  782.             do {
  783.             doit[k] = True;
  784.             } while (strcmp(cp2, (test[k].option + 1)) != 0 &&
  785.                  (test[k].versions & xparms.version) &&
  786.                  test[++k].option != NULL);
  787.             if (*cp2 != '-' && test[k].option == NULL)
  788.             usage();
  789.             break;
  790.         }
  791.         }
  792.         if (test[j].option == NULL)
  793.         usage();
  794.         foundOne = True;
  795.     } else if (strcmp (argv[i], "-sync") == 0) {
  796.         synchronous = True;
  797.     } else if (strcmp(argv[i], "-pack") == 0) {
  798.         xparms.pack = True;
  799.     } else if (strcmp (argv[i], "-draw") == 0) {
  800.         drawToFakeServer = True;
  801.     } else if (strcmp (argv[i], "-repeat") == 0) {
  802.         i++;
  803.         if (argc <= i)
  804.         usage ();
  805.         repeat = atoi (argv[i]);
  806.         if (repeat <= 0)
  807.            usage ();
  808.     } else if (strcmp (argv[i], "-time") == 0) {
  809.         i++;
  810.         if (argc <= i)
  811.         usage ();
  812.         seconds = atoi (argv[i]);
  813.         if (seconds <= 0)
  814.            usage ();
  815.     } else if (strcmp(argv[i], "-fg") == 0) {
  816.         i++;
  817.         if (argc <= i)
  818.         usage ();
  819.         foreground = argv[i];
  820.         } else if (strcmp(argv[i], "-bg") == 0) {
  821.         i++;
  822.         if (argc <= i)
  823.         usage ();
  824.         background = argv[i];
  825.     } else if (strcmp(argv[i], "-rop") == 0) {
  826.         skip = GetRops (i+1, argc, argv, rops, &numRops);
  827.         i += skip;
  828.     } else if (strcmp(argv[i], "-pm") == 0) {
  829.         skip = GetNumbers (i+1, argc, argv, planemasks, &numPlanemasks);
  830.         i += skip;
  831.     } else if (strcmp(argv[i], "-xor") == 0) {
  832.         numRops = 1;
  833.         rops[0] = GXxor;
  834.     } else if (strcmp (argv[i], "-both") == 0) {
  835.         numRops = 2;
  836.         rops[0] = GXcopy;
  837.         rops[1] = GXxor;
  838.     } else if (strcmp(argv[i], "-reps") == 0) {
  839.         i++;
  840.         if (argc <= i)
  841.         usage ();
  842.         fixedReps = atoi (argv[i]);
  843.         if (fixedReps <= 0)
  844.         usage ();
  845.         } else if (strcmp(argv[i], "-depth") == 0) {
  846.         i++;
  847.         if (argc <= i)
  848.                 usage ();
  849.             depth = atoi(argv[i]);
  850.             if (depth <= 0)
  851.         usage ();
  852.     } else if (strcmp(argv[i], "-subs") == 0) {
  853.         skip = GetNumbers (i+1, argc, argv, subWindows, &numSubWindows);
  854.         i += skip;
  855.     } else if (strcmp(argv[i], "-v1.2") == 0) {
  856.         xparms.version = VERSION1_2;
  857.     } else {
  858.         ForEachTest (j) {
  859.         if (strcmp (argv[i], test[j].option) == 0 &&
  860.             (test[j].versions & xparms.version)) {
  861.             doit[j] = True;
  862.             goto LegalOption;
  863.         }
  864.         }
  865.         usage ();
  866.     LegalOption: 
  867.         foundOne = True;
  868.     }
  869.     }
  870.  
  871.     if (labels) {
  872.     /* Just print out list of tests for use with .sh programs that
  873.        assemble data from different x11perf runs into a nice format */
  874.     ForEachTest (i) {
  875.         int child;
  876.         if (doit[i] && (test[i].versions & xparms.version)) {
  877.         switch (test[i].testType) {
  878.             case NONROP:
  879.             printf ("%s\n", test[i].label);
  880.             break;
  881.     
  882.             case ROP:
  883.             /* Run it through all specified rops and planemasks */
  884.             for (rop = 0; rop < numRops; rop++) {
  885.                 for (pm = 0; pm < numPlanemasks; pm++) {
  886.                 if (planemasks[pm] == ~0) {
  887.                     if (rops[rop] == GXcopy) {
  888.                     printf ("%s\n", test[i].label);
  889.                     } else {
  890.                     printf ("(%s) %s\n",
  891.                         ropNames[rops[rop]].name,
  892.                         test[i].label);
  893.                     }
  894.                 } else {
  895.                     printf ("(%s 0x%x) %s\n",
  896.                         ropNames[rops[rop]].name,
  897.                         planemasks[pm],
  898.                         test[i].label);
  899.                 }
  900.                 } /* for pm */
  901.             } /* for rop */
  902.             break;
  903.             
  904.             case WINDOW:
  905.             for (child = 0; child != numSubWindows; child++) {
  906.                 printf ("%s (%d kids)\n",
  907.                 test[i].label, subWindows[child]);
  908.             }
  909.             break;
  910.         } /* switch */
  911.         }
  912.     }
  913.     exit(0);
  914.     }
  915.  
  916.     if (!foundOne)
  917.     usage ();
  918.     xparms.d = Open_Display (displayName);
  919.     screen = DefaultScreen(xparms.d);
  920.  
  921.     /* get visual info of default visual */
  922.     vmask = VisualIDMask | VisualScreenMask;
  923.     vinfotempl.visualid = XVisualIDFromVisual(XDefaultVisual(xparms.d, screen));
  924.     vinfotempl.screen = screen;
  925.     vinfolist = XGetVisualInfo(xparms.d, vmask, &vinfotempl, &n);
  926.     if (!vinfolist || n != 1) {
  927.     fprintf (stderr, "%s: can't get visual info of default visual\n",
  928.         program_name);
  929.     exit(1);
  930.     }
  931.  
  932.     if (depth == -1) {
  933.     /* use the default visual and colormap */
  934.     xparms.vinfo = *vinfolist;
  935.     cmap = XDefaultColormap(xparms.d, screen);
  936.     } else {
  937.     /* find the specified visual */
  938.     vmask = VisualDepthMask | VisualScreenMask;
  939.     vinfotempl.depth = depth;
  940.     vinfotempl.screen = screen;
  941.     vinfolist = XGetVisualInfo(xparms.d, vmask, &vinfotempl, &n);
  942.     if (!vinfolist) {
  943.         fprintf (stderr, "%s: can't find a visual of depth %d\n",
  944.         program_name, depth);
  945.         exit(1);
  946.     }
  947.     xparms.vinfo = *vinfolist;  /* use the first one in list */
  948.     if (xparms.vinfo.visualid ==
  949.         XVisualIDFromVisual(XDefaultVisual(xparms.d, screen))) {
  950.         /* matched visual is same as default visual */
  951.         cmap = XDefaultColormap(xparms.d, screen);
  952.     } else {
  953.         cmap = XCreateColormap(xparms.d, DefaultRootWindow(xparms.d),
  954.         xparms.vinfo.visual, AllocNone);
  955.         /* since this is not default cmap, must force color allocation */
  956.         if (!foreground) foreground = "Black";
  957.         if (!background) background = "White";
  958.     }
  959.     }
  960.  
  961.     printf("x11perf - X11 performance program, version 1.3\n");
  962. #ifndef VMS
  963.     gethostname (hostname, 100);
  964.     printf ("%s server on %s\nfrom %s\n",
  965.         ServerVendor (xparms.d), DisplayString (xparms.d), hostname);
  966. #else
  967.     printf ("%s server on %s\n",
  968.         ServerVendor (xparms.d), DisplayString (xparms.d));
  969. #endif
  970.     PrintTime ();
  971.  
  972.     /* Force screen out of screen-saver mode, grab current data, and set
  973.        time to blank to 8 hours.  We should just be able to turn the screen-
  974.        saver off, but this causes problems on some servers.  We also reset
  975.        the screen-saver timer each test, as 8 hours is about the maximum time
  976.        we can use, and that isn't long enough for some X terminals using a
  977.        serial protocol to finish all the tests.  As long as the tests run to 
  978.        completion, the old screen-saver values are restored. */
  979.     XForceScreenSaver(xparms.d, ScreenSaverReset);
  980.     XGetScreenSaver(xparms.d, &ssTimeout, &ssInterval, &ssPreferBlanking,
  981.     &ssAllowExposures);
  982.     (void) signal(SIGINT, Cleanup); /* ^C */
  983.     (void) signal(SIGQUIT, Cleanup);
  984.     (void) signal(SIGTERM, Cleanup);
  985.     (void) signal(SIGHUP, Cleanup);
  986.     XSetScreenSaver(xparms.d, 8 * 3600, ssInterval, ssPreferBlanking, 
  987.     ssAllowExposures);
  988.  
  989.     if (drawToFakeServer) {
  990.         tileToQuery =
  991.         XCreatePixmap(xparms.d, DefaultRootWindow (xparms.d), 32, 32, 1);
  992.     }
  993.  
  994.  
  995.     xparms.foreground =
  996.     AllocateColor(xparms.d, foreground, BlackPixel(xparms.d, screen));
  997.     xparms.background =
  998.     AllocateColor(xparms.d, background, WhitePixel(xparms.d, screen));
  999.     xparms.w = CreatePerfWindow(&xparms, 2, 2, WIDTH, HEIGHT);
  1000.     status = CreatePerfWindow(&xparms, 2, HEIGHT+5, WIDTH, 20);
  1001.     tgcv.foreground = BlackPixel(xparms.d, screen);
  1002.     tgcv.background = WhitePixel(xparms.d, screen);
  1003.     tgc = XCreateGC(xparms.d, status, GCForeground | GCBackground, &tgcv);
  1004.    
  1005.  
  1006.     if (synchronous)
  1007.     XSynchronize (xparms.d, True);
  1008.  
  1009.     /* Get mouse pointer out of the way of the performance window.  On
  1010.        software cursor machines it will slow graphics performance.  On
  1011.        all current MIT-derived servers it will slow window 
  1012.        creation/configuration performance. */
  1013.     XWarpPointer(xparms.d, None, status, 0, 0, 0, 0, WIDTH, 20);
  1014.  
  1015.     /* Figure out how long to call HardwareSync, so we can adjust for that
  1016.        in our total elapsed time */
  1017.     (void) CalibrateTest(&xparms, &syncTest, 1, &syncTime);
  1018.     printf("Sync time adjustment is %6.4f msecs.\n\n", syncTime/1000);
  1019.  
  1020.     ForEachTest (i) {
  1021.     int child;
  1022.     char label[200];
  1023.  
  1024.     if (doit[i] && (test[i].versions & xparms.version)) {
  1025.         switch (test[i].testType) {
  1026.             case NONROP:
  1027.             /* Simplest...just run it once */
  1028.             strcpy (label, test[i].label);
  1029.             ProcessTest(&xparms, &test[i], GXcopy, ~0, label);
  1030.             break;
  1031.  
  1032.         case ROP:
  1033.             /* Run it through all specified rops and planemasks */
  1034.             for (rop = 0; rop < numRops; rop++) {
  1035.             for (pm = 0; pm < numPlanemasks; pm++) {
  1036.                 if (planemasks[pm] == ~0) {
  1037.                 if (rops[rop] == GXcopy) {
  1038.                     sprintf (label, "%s", test[i].label);
  1039.                 } else {
  1040.                     sprintf (label, "(%s) %s",
  1041.                     ropNames[rops[rop]].name,
  1042.                     test[i].label);
  1043.                 }
  1044.                 } else {
  1045.                 sprintf (label, "(%s 0x%x) %s",
  1046.                     ropNames[rops[rop]].name,
  1047.                     planemasks[pm],
  1048.                     test[i].label);
  1049.                 }
  1050.                 ProcessTest(&xparms, &test[i], rops[rop],
  1051.                         planemasks[pm], label);
  1052.             } /* for pm */
  1053.             } /* for rop */
  1054.             break;
  1055.         
  1056.         case WINDOW:
  1057.             /* Loop through number of children array */
  1058.             for (child = 0; child != numSubWindows; child++) {
  1059.             test[i].parms.objects = subWindows[child];
  1060.             sprintf(label, "%s (%d kids)",
  1061.                 test[i].label, test[i].parms.objects);
  1062.             ProcessTest(&xparms, &test[i], GXcopy, ~0, label);
  1063.             }
  1064.             break;
  1065.         } /* switch */
  1066.     } /* if doit */
  1067.     } /* ForEachTest */
  1068.  
  1069.     XDestroyWindow(xparms.d, xparms.w);
  1070.  
  1071.     /* Restore ScreenSaver to original state. */
  1072.     XSetScreenSaver(xparms.d, ssTimeout, ssInterval, ssPreferBlanking,
  1073.     ssAllowExposures);
  1074.     XCloseDisplay(xparms.d);
  1075. }
  1076.  
  1077. int
  1078. GetWords (argi, argc, argv, wordsp, nump)
  1079.     int     argi;
  1080.     int     argc;
  1081.     char    **argv;
  1082.     char    **wordsp;
  1083.     int     *nump;
  1084. {
  1085.     int        count;
  1086.  
  1087.     if (argc <= argi)
  1088.     usage();
  1089.     count = 0;
  1090.     while (argv[argi] && *(argv[argi]) != '-') {
  1091.     *wordsp++ = argv[argi];
  1092.     ++argi;
  1093.     count++;
  1094.     }
  1095.     *nump = count;
  1096.     return count;
  1097. }
  1098.  
  1099. static int
  1100. atox (s)
  1101.     char    *s;
  1102. {
  1103.     int     v, c;
  1104.  
  1105.     v = 0;
  1106.     while (*s) {
  1107.     if ('0' <= *s && *s <= '9')
  1108.         c = *s - '0';
  1109.     else if ('a' <= *s && *s <= 'f')
  1110.         c = *s - 'a' + 10;
  1111.     else if ('A' <= *s && *s <= 'F')
  1112.         c = *s - 'A' + 10;
  1113.     v = v * 16 + c;
  1114.     s++;
  1115.     }
  1116.     return v;
  1117. }
  1118.  
  1119. int GetNumbers (argi, argc, argv, intsp, nump)
  1120.     int     argi;
  1121.     int     argc;
  1122.     char    **argv;
  1123.     int     *intsp;
  1124.     int     *nump;
  1125. {
  1126.     char    *words[256];
  1127.     int        count;
  1128.     int        i;
  1129.     int        flip;
  1130.  
  1131.     count = GetWords (argi, argc, argv, words, nump);
  1132.     for (i = 0; i < count; i++) {
  1133.     flip = 0;
  1134.     if (!strncmp (words[i], "~", 1)) {
  1135.         words[i]++;
  1136.         flip = ~0;
  1137.     }
  1138.     if (!strncmp (words[i], "0x", 2))
  1139.         intsp[i] = atox(words[i] + 2) ^ flip;
  1140.     else
  1141.         intsp[i] = atoi (words[i]) ^ flip;
  1142.     }
  1143.     return count;
  1144. }
  1145.  
  1146. GetRops (argi, argc, argv, ropsp, nump)
  1147.     int     argi;
  1148.     int     argc;
  1149.     char    **argv;
  1150.     int     *ropsp;
  1151.     int     *nump;
  1152. {
  1153.     char    *words[256];
  1154.     int        count;
  1155.     int        i;
  1156.     int        rop;
  1157.  
  1158.     count = GetWords (argi, argc, argv, words, nump);
  1159.     for (i = 0; i < count; i++) {
  1160.     if (!strncmp (words[i], "GX", 2))
  1161.         words[i] += 2;
  1162.     if (!strcmp (words[i], "all")) {
  1163.         for (i = 0; i < 16; i++)
  1164.         ropsp[i] = ropNames[i].rop;
  1165.         *nump = 16;
  1166.         break;
  1167.     }
  1168.     for (rop = 0; rop < 16; rop++) {
  1169.         if (!strcmp (words[i], ropNames[rop].name)) {
  1170.         ropsp[i] = ropNames[rop].rop;
  1171.         break;
  1172.         }
  1173.     }
  1174.     if (rop == 16) {
  1175.         fprintf (stderr, "unknown rop name %s\n", words[i]);
  1176.         usage ();
  1177.     }
  1178.     }
  1179.     return count;
  1180. }
  1181.