Home | History | Annotate | Download | only in hwc
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  *
     16  */
     17 
     18 /*
     19  * Hardware Composer stress test
     20  *
     21  * Performs a pseudo-random (prandom) sequence of operations to the
     22  * Hardware Composer (HWC), for a specified number of passes or for
     23  * a specified period of time.  By default the period of time is FLT_MAX,
     24  * so that the number of passes will take precedence.
     25  *
     26  * The passes are grouped together, where (pass / passesPerGroup) specifies
     27  * which group a particular pass is in.  This causes every passesPerGroup
     28  * worth of sequential passes to be within the same group.  Computationally
     29  * intensive operations are performed just once at the beginning of a group
     30  * of passes and then used by all the passes in that group.  This is done
     31  * so as to increase both the average and peak rate of graphic operations,
     32  * by moving computationally intensive operations to the beginning of a group.
     33  * In particular, at the start of each group of passes a set of
     34  * graphic buffers are created, then used by the first and remaining
     35  * passes of that group of passes.
     36  *
     37  * The per-group initialization of the graphic buffers is performed
     38  * by a function called initFrames.  This function creates an array
     39  * of smart pointers to the graphic buffers, in the form of a vector
     40  * of vectors.  The array is accessed in row major order, so each
     41  * row is a vector of smart pointers.  All the pointers of a single
     42  * row point to graphic buffers which use the same pixel format and
     43  * have the same dimension, although it is likely that each one is
     44  * filled with a different color.  This is done so that after doing
     45  * the first HWC prepare then set call, subsequent set calls can
     46  * be made with each of the layer handles changed to a different
     47  * graphic buffer within the same row.  Since the graphic buffers
     48  * in a particular row have the same pixel format and dimension,
     49  * additional HWC set calls can be made, without having to perform
     50  * an HWC prepare call.
     51  *
     52  * This test supports the following command-line options:
     53  *
     54  *   -v        Verbose
     55  *   -s num    Starting pass
     56  *   -e num    Ending pass
     57  *   -p num    Execute the single pass specified by num
     58  *   -n num    Number of set operations to perform after each prepare operation
     59  *   -t float  Maximum time in seconds to execute the test
     60  *   -d float  Delay in seconds performed after each set operation
     61  *   -D float  Delay in seconds performed after the last pass is executed
     62  *
     63  * Typically the test is executed for a large range of passes.  By default
     64  * passes 0 through 99999 (100,000 passes) are executed.  Although this test
     65  * does not validate the generated image, at times it is useful to reexecute
     66  * a particular pass and leave the displayed image on the screen for an
     67  * extended period of time.  This can be done either by setting the -s
     68  * and -e options to the desired pass, along with a large value for -D.
     69  * This can also be done via the -p option, again with a large value for
     70  * the -D options.
     71  *
     72  * So far this test only contains code to create graphic buffers with
     73  * a continuous solid color.  Although this test is unable to validate the
     74  * image produced, any image that contains other than rectangles of a solid
     75  * color are incorrect.  Note that the rectangles may use a transparent
     76  * color and have a blending operation that causes the color in overlapping
     77  * rectangles to be mixed.  In such cases the overlapping portions may have
     78  * a different color from the rest of the rectangle.
     79  */
     80 
     81 #include <algorithm>
     82 #include <assert.h>
     83 #include <cerrno>
     84 #include <cmath>
     85 #include <cstdlib>
     86 #include <ctime>
     87 #include <libgen.h>
     88 #include <sched.h>
     89 #include <sstream>
     90 #include <stdint.h>
     91 #include <string.h>
     92 #include <unistd.h>
     93 #include <vector>
     94 
     95 #include <sys/syscall.h>
     96 #include <sys/types.h>
     97 #include <sys/wait.h>
     98 
     99 #include <EGL/egl.h>
    100 #include <EGL/eglext.h>
    101 #include <GLES2/gl2.h>
    102 #include <GLES2/gl2ext.h>
    103 
    104 #include <ui/FramebufferNativeWindow.h>
    105 #include <ui/GraphicBuffer.h>
    106 
    107 #define LOG_TAG "hwcStressTest"
    108 #include <utils/Log.h>
    109 #include <testUtil.h>
    110 
    111 #include <hardware/hwcomposer.h>
    112 
    113 #include <glTestLib.h>
    114 #include "hwcTestLib.h"
    115 
    116 using namespace std;
    117 using namespace android;
    118 
    119 const float maxSizeRatio = 1.3;  // Graphic buffers can be upto this munch
    120                                  // larger than the default screen size
    121 const unsigned int passesPerGroup = 10; // A group of passes all use the same
    122                                         // graphic buffers
    123 
    124 // Ratios at which rare and frequent conditions should be produced
    125 const float rareRatio = 0.1;
    126 const float freqRatio = 0.9;
    127 
    128 // Defaults for command-line options
    129 const bool defaultVerbose = false;
    130 const unsigned int defaultStartPass = 0;
    131 const unsigned int defaultEndPass = 99999;
    132 const unsigned int defaultPerPassNumSet = 10;
    133 const float defaultPerSetDelay = 0.0; // Default delay after each set
    134                                       // operation.  Default delay of
    135                                       // zero used so as to perform the
    136                                       // the set operations as quickly
    137                                       // as possible.
    138 const float defaultEndDelay = 2.0; // Default delay between completion of
    139                                    // final pass and restart of framework
    140 const float defaultDuration = FLT_MAX; // A fairly long time, so that
    141                                        // range of passes will have
    142                                        // precedence
    143 
    144 // Command-line option settings
    145 static bool verbose = defaultVerbose;
    146 static unsigned int startPass = defaultStartPass;
    147 static unsigned int endPass = defaultEndPass;
    148 static unsigned int numSet = defaultPerPassNumSet;
    149 static float perSetDelay = defaultPerSetDelay;
    150 static float endDelay = defaultEndDelay;
    151 static float duration = defaultDuration;
    152 
    153 // Command-line mutual exclusion detection flags.
    154 // Corresponding flag set true once an option is used.
    155 bool eFlag, sFlag, pFlag;
    156 
    157 #define MAXSTR               100
    158 #define MAXCMD               200
    159 #define BITSPERBYTE            8 // TODO: Obtain from <values.h>, once
    160                                  // it has been added
    161 
    162 #define CMD_STOP_FRAMEWORK   "stop 2>&1"
    163 #define CMD_START_FRAMEWORK  "start 2>&1"
    164 
    165 #define NUMA(a) (sizeof(a) / sizeof(a [0]))
    166 #define MEMCLR(addr, size) do { \
    167         memset((addr), 0, (size)); \
    168     } while (0)
    169 
    170 // File scope constants
    171 const unsigned int blendingOps[] = {
    172     HWC_BLENDING_NONE,
    173     HWC_BLENDING_PREMULT,
    174     HWC_BLENDING_COVERAGE,
    175 };
    176 const unsigned int layerFlags[] = {
    177     HWC_SKIP_LAYER,
    178 };
    179 const vector<unsigned int> vecLayerFlags(layerFlags,
    180     layerFlags + NUMA(layerFlags));
    181 
    182 const unsigned int transformFlags[] = {
    183     HWC_TRANSFORM_FLIP_H,
    184     HWC_TRANSFORM_FLIP_V,
    185     HWC_TRANSFORM_ROT_90,
    186     // ROT_180 & ROT_270 intentionally not listed, because they
    187     // they are formed from combinations of the flags already listed.
    188 };
    189 const vector<unsigned int> vecTransformFlags(transformFlags,
    190     transformFlags + NUMA(transformFlags));
    191 
    192 // File scope globals
    193 static const int texUsage = GraphicBuffer::USAGE_HW_TEXTURE |
    194         GraphicBuffer::USAGE_SW_WRITE_RARELY;
    195 static hwc_composer_device_t *hwcDevice;
    196 static EGLDisplay dpy;
    197 static EGLSurface surface;
    198 static EGLint width, height;
    199 static vector <vector <sp<GraphicBuffer> > > frames;
    200 
    201 // File scope prototypes
    202 void init(void);
    203 void initFrames(unsigned int seed);
    204 template <class T> vector<T> vectorRandSelect(const vector<T>& vec, size_t num);
    205 template <class T> T vectorOr(const vector<T>& vec);
    206 
    207 /*
    208  * Main
    209  *
    210  * Performs the following high-level sequence of operations:
    211  *
    212  *   1. Command-line parsing
    213  *
    214  *   2. Initialization
    215  *
    216  *   3. For each pass:
    217  *
    218  *        a. If pass is first pass or in a different group from the
    219  *           previous pass, initialize the array of graphic buffers.
    220  *
    221  *        b. Create a HWC list with room to specify a prandomly
    222  *           selected number of layers.
    223  *
    224  *        c. Select a subset of the rows from the graphic buffer array,
    225  *           such that there is a unique row to be used for each
    226  *           of the layers in the HWC list.
    227  *
    228  *        d. Prandomly fill in the HWC list with handles
    229  *           selected from any of the columns of the selected row.
    230  *
    231  *        e. Pass the populated list to the HWC prepare call.
    232  *
    233  *        f. Pass the populated list to the HWC set call.
    234  *
    235  *        g. If additional set calls are to be made, then for each
    236  *           additional set call, select a new set of handles and
    237  *           perform the set call.
    238  */
    239 int
    240 main(int argc, char *argv[])
    241 {
    242     int rv, opt;
    243     char *chptr;
    244     unsigned int pass;
    245     char cmd[MAXCMD];
    246     struct timeval startTime, currentTime, delta;
    247 
    248     testSetLogCatTag(LOG_TAG);
    249 
    250     // Parse command line arguments
    251     while ((opt = getopt(argc, argv, "vp:d:D:n:s:e:t:?h")) != -1) {
    252         switch (opt) {
    253           case 'd': // Delay after each set operation
    254             perSetDelay = strtod(optarg, &chptr);
    255             if ((*chptr != '\0') || (perSetDelay < 0.0)) {
    256                 testPrintE("Invalid command-line specified per pass delay of: "
    257                            "%s", optarg);
    258                 exit(1);
    259             }
    260             break;
    261 
    262           case 'D': // End of test delay
    263                     // Delay between completion of final pass and restart
    264                     // of framework
    265             endDelay = strtod(optarg, &chptr);
    266             if ((*chptr != '\0') || (endDelay < 0.0)) {
    267                 testPrintE("Invalid command-line specified end of test delay "
    268                            "of: %s", optarg);
    269                 exit(2);
    270             }
    271             break;
    272 
    273           case 't': // Duration
    274             duration = strtod(optarg, &chptr);
    275             if ((*chptr != '\0') || (duration < 0.0)) {
    276                 testPrintE("Invalid command-line specified duration of: %s",
    277                            optarg);
    278                 exit(3);
    279             }
    280             break;
    281 
    282           case 'n': // Num set operations per pass
    283             numSet = strtoul(optarg, &chptr, 10);
    284             if (*chptr != '\0') {
    285                 testPrintE("Invalid command-line specified num set per pass "
    286                            "of: %s", optarg);
    287                 exit(4);
    288             }
    289             break;
    290 
    291           case 's': // Starting Pass
    292             sFlag = true;
    293             if (pFlag) {
    294                 testPrintE("Invalid combination of command-line options.");
    295                 testPrintE("  The -p option is mutually exclusive from the");
    296                 testPrintE("  -s and -e options.");
    297                 exit(5);
    298             }
    299             startPass = strtoul(optarg, &chptr, 10);
    300             if (*chptr != '\0') {
    301                 testPrintE("Invalid command-line specified starting pass "
    302                            "of: %s", optarg);
    303                 exit(6);
    304             }
    305             break;
    306 
    307           case 'e': // Ending Pass
    308             eFlag = true;
    309             if (pFlag) {
    310                 testPrintE("Invalid combination of command-line options.");
    311                 testPrintE("  The -p option is mutually exclusive from the");
    312                 testPrintE("  -s and -e options.");
    313                 exit(7);
    314             }
    315             endPass = strtoul(optarg, &chptr, 10);
    316             if (*chptr != '\0') {
    317                 testPrintE("Invalid command-line specified ending pass "
    318                            "of: %s", optarg);
    319                 exit(8);
    320             }
    321             break;
    322 
    323           case 'p': // Run a single specified pass
    324             pFlag = true;
    325             if (sFlag || eFlag) {
    326                 testPrintE("Invalid combination of command-line options.");
    327                 testPrintE("  The -p option is mutually exclusive from the");
    328                 testPrintE("  -s and -e options.");
    329                 exit(9);
    330             }
    331             startPass = endPass = strtoul(optarg, &chptr, 10);
    332             if (*chptr != '\0') {
    333                 testPrintE("Invalid command-line specified pass of: %s",
    334                            optarg);
    335                 exit(10);
    336             }
    337             break;
    338 
    339           case 'v': // Verbose
    340             verbose = true;
    341             break;
    342 
    343           case 'h': // Help
    344           case '?':
    345           default:
    346             testPrintE("  %s [options]", basename(argv[0]));
    347             testPrintE("    options:");
    348             testPrintE("      -p Execute specified pass");
    349             testPrintE("      -s Starting pass");
    350             testPrintE("      -e Ending pass");
    351             testPrintE("      -t Duration");
    352             testPrintE("      -d Delay after each set operation");
    353             testPrintE("      -D End of test delay");
    354             testPrintE("      -n Num set operations per pass");
    355             testPrintE("      -v Verbose");
    356             exit(((optopt == 0) || (optopt == '?')) ? 0 : 11);
    357         }
    358     }
    359     if (endPass < startPass) {
    360         testPrintE("Unexpected ending pass before starting pass");
    361         testPrintE("  startPass: %u endPass: %u", startPass, endPass);
    362         exit(12);
    363     }
    364     if (argc != optind) {
    365         testPrintE("Unexpected command-line postional argument");
    366         testPrintE("  %s [-s start_pass] [-e end_pass] [-t duration]",
    367             basename(argv[0]));
    368         exit(13);
    369     }
    370     testPrintI("duration: %g", duration);
    371     testPrintI("startPass: %u", startPass);
    372     testPrintI("endPass: %u", endPass);
    373     testPrintI("numSet: %u", numSet);
    374 
    375     // Stop framework
    376     rv = snprintf(cmd, sizeof(cmd), "%s", CMD_STOP_FRAMEWORK);
    377     if (rv >= (signed) sizeof(cmd) - 1) {
    378         testPrintE("Command too long for: %s", CMD_STOP_FRAMEWORK);
    379         exit(14);
    380     }
    381     testExecCmd(cmd);
    382     testDelay(1.0); // TODO - need means to query whether asyncronous stop
    383                     // framework operation has completed.  For now, just wait
    384                     // a long time.
    385 
    386     init();
    387 
    388     // For each pass
    389     gettimeofday(&startTime, NULL);
    390     for (pass = startPass; pass <= endPass; pass++) {
    391         // Stop if duration of work has already been performed
    392         gettimeofday(&currentTime, NULL);
    393         delta = tvDelta(&startTime, &currentTime);
    394         if (tv2double(&delta) > duration) { break; }
    395 
    396         // Regenerate a new set of test frames when this pass is
    397         // either the first pass or is in a different group then
    398         // the previous pass.  A group of passes are passes that
    399         // all have the same quotient when their pass number is
    400         // divided by passesPerGroup.
    401         if ((pass == startPass)
    402             || ((pass / passesPerGroup) != ((pass - 1) / passesPerGroup))) {
    403             initFrames(pass / passesPerGroup);
    404         }
    405 
    406         testPrintI("==== Starting pass: %u", pass);
    407 
    408         // Cause deterministic sequence of prandom numbers to be
    409         // generated for this pass.
    410         srand48(pass);
    411 
    412         hwc_layer_list_t *list;
    413         list = hwcTestCreateLayerList(testRandMod(frames.size()) + 1);
    414         if (list == NULL) {
    415             testPrintE("hwcTestCreateLayerList failed");
    416             exit(20);
    417         }
    418 
    419         // Prandomly select a subset of frames to be used by this pass.
    420         vector <vector <sp<GraphicBuffer> > > selectedFrames;
    421         selectedFrames = vectorRandSelect(frames, list->numHwLayers);
    422 
    423         // Any transform tends to create a layer that the hardware
    424         // composer is unable to support and thus has to leave for
    425         // SurfaceFlinger.  Place heavy bias on specifying no transforms.
    426         bool noTransform = testRandFract() > rareRatio;
    427 
    428         for (unsigned int n1 = 0; n1 < list->numHwLayers; n1++) {
    429             unsigned int idx = testRandMod(selectedFrames[n1].size());
    430             sp<GraphicBuffer> gBuf = selectedFrames[n1][idx];
    431             hwc_layer_t *layer = &list->hwLayers[n1];
    432             layer->handle = gBuf->handle;
    433 
    434             layer->blending = blendingOps[testRandMod(NUMA(blendingOps))];
    435             layer->flags = (testRandFract() > rareRatio) ? 0
    436                 : vectorOr(vectorRandSelect(vecLayerFlags,
    437                            testRandMod(vecLayerFlags.size() + 1)));
    438             layer->transform = (noTransform || testRandFract() > rareRatio) ? 0
    439                 : vectorOr(vectorRandSelect(vecTransformFlags,
    440                            testRandMod(vecTransformFlags.size() + 1)));
    441             layer->sourceCrop.left = testRandMod(gBuf->getWidth());
    442             layer->sourceCrop.top = testRandMod(gBuf->getHeight());
    443             layer->sourceCrop.right = layer->sourceCrop.left
    444                 + testRandMod(gBuf->getWidth() - layer->sourceCrop.left) + 1;
    445             layer->sourceCrop.bottom = layer->sourceCrop.top
    446                 + testRandMod(gBuf->getHeight() - layer->sourceCrop.top) + 1;
    447             layer->displayFrame.left = testRandMod(width);
    448             layer->displayFrame.top = testRandMod(height);
    449             layer->displayFrame.right = layer->displayFrame.left
    450                 + testRandMod(width - layer->displayFrame.left) + 1;
    451             layer->displayFrame.bottom = layer->displayFrame.top
    452                 + testRandMod(height - layer->displayFrame.top) + 1;
    453 
    454             // Increase the frequency that a scale factor of 1.0 from
    455             // the sourceCrop to displayFrame occurs.  This is the
    456             // most common scale factor used by applications and would
    457             // be rarely produced by this stress test without this
    458             // logic.
    459             if (testRandFract() <= freqRatio) {
    460                 // Only change to scale factor to 1.0 if both the
    461                 // width and height will fit.
    462                 int sourceWidth = layer->sourceCrop.right
    463                                   - layer->sourceCrop.left;
    464                 int sourceHeight = layer->sourceCrop.bottom
    465                                    - layer->sourceCrop.top;
    466                 if (((layer->displayFrame.left + sourceWidth) <= width)
    467                     && ((layer->displayFrame.top + sourceHeight) <= height)) {
    468                     layer->displayFrame.right = layer->displayFrame.left
    469                                                 + sourceWidth;
    470                     layer->displayFrame.bottom = layer->displayFrame.top
    471                                                  + sourceHeight;
    472                 }
    473             }
    474 
    475             layer->visibleRegionScreen.numRects = 1;
    476             layer->visibleRegionScreen.rects = &layer->displayFrame;
    477         }
    478 
    479         // Perform prepare operation
    480         if (verbose) { testPrintI("Prepare:"); hwcTestDisplayList(list); }
    481         hwcDevice->prepare(hwcDevice, list);
    482         if (verbose) {
    483             testPrintI("Post Prepare:");
    484             hwcTestDisplayListPrepareModifiable(list);
    485         }
    486 
    487         // Turn off the geometry changed flag
    488         list->flags &= ~HWC_GEOMETRY_CHANGED;
    489 
    490         // Perform the set operation(s)
    491         if (verbose) {testPrintI("Set:"); }
    492         for (unsigned int n1 = 0; n1 < numSet; n1++) {
    493             if (verbose) { hwcTestDisplayListHandles(list); }
    494             hwcDevice->set(hwcDevice, dpy, surface, list);
    495 
    496             // Prandomly select a new set of handles
    497             for (unsigned int n1 = 0; n1 < list->numHwLayers; n1++) {
    498                 unsigned int idx = testRandMod(selectedFrames[n1].size());
    499                 sp<GraphicBuffer> gBuf = selectedFrames[n1][idx];
    500                 hwc_layer_t *layer = &list->hwLayers[n1];
    501                 layer->handle = (native_handle_t *) gBuf->handle;
    502             }
    503 
    504             testDelay(perSetDelay);
    505         }
    506 
    507         hwcTestFreeLayerList(list);
    508         testPrintI("==== Completed pass: %u", pass);
    509     }
    510 
    511     testDelay(endDelay);
    512 
    513     // Start framework
    514     rv = snprintf(cmd, sizeof(cmd), "%s", CMD_START_FRAMEWORK);
    515     if (rv >= (signed) sizeof(cmd) - 1) {
    516         testPrintE("Command too long for: %s", CMD_START_FRAMEWORK);
    517         exit(21);
    518     }
    519     testExecCmd(cmd);
    520 
    521     testPrintI("Successfully completed %u passes", pass - startPass);
    522 
    523     return 0;
    524 }
    525 
    526 void init(void)
    527 {
    528     srand48(0); // Defensively set pseudo random number generator.
    529                 // Should not need to set this, because a stress test
    530                 // sets the seed on each pass.  Defensively set it here
    531                 // so that future code that uses pseudo random numbers
    532                 // before the first pass will be deterministic.
    533 
    534     hwcTestInitDisplay(verbose, &dpy, &surface, &width, &height);
    535 
    536     hwcTestOpenHwc(&hwcDevice);
    537 }
    538 
    539 /*
    540  * Initialize Frames
    541  *
    542  * Creates an array of graphic buffers, within the global variable
    543  * named frames.  The graphic buffers are contained within a vector of
    544  * vectors.  All the graphic buffers in a particular row are of the same
    545  * format and dimension.  Each graphic buffer is uniformly filled with a
    546  * prandomly selected color.  It is likely that each buffer, even
    547  * in the same row, will be filled with a unique color.
    548  */
    549 void initFrames(unsigned int seed)
    550 {
    551     int rv;
    552     const size_t maxRows = 5;
    553     const size_t minCols = 2;  // Need at least double buffering
    554     const size_t maxCols = 4;  // One more than triple buffering
    555 
    556     if (verbose) { testPrintI("initFrames seed: %u", seed); }
    557     srand48(seed);
    558     size_t rows = testRandMod(maxRows) + 1;
    559 
    560     frames.clear();
    561     frames.resize(rows);
    562 
    563     for (unsigned int row = 0; row < rows; row++) {
    564         // All frames within a row have to have the same format and
    565         // dimensions.  Width and height need to be >= 1.
    566         unsigned int formatIdx = testRandMod(NUMA(hwcTestGraphicFormat));
    567         const struct hwcTestGraphicFormat *formatPtr
    568             = &hwcTestGraphicFormat[formatIdx];
    569         int format = formatPtr->format;
    570 
    571         // Pick width and height, which must be >= 1 and the size
    572         // mod the wMod/hMod value must be equal to 0.
    573         size_t w = (width * maxSizeRatio) * testRandFract();
    574         size_t h = (height * maxSizeRatio) * testRandFract();
    575         w = max(1u, w);
    576         h = max(1u, h);
    577         if ((w % formatPtr->wMod) != 0) {
    578             w += formatPtr->wMod - (w % formatPtr->wMod);
    579         }
    580         if ((h % formatPtr->hMod) != 0) {
    581             h += formatPtr->hMod - (h % formatPtr->hMod);
    582         }
    583         if (verbose) {
    584             testPrintI("  frame %u width: %u height: %u format: %u %s",
    585                        row, w, h, format, hwcTestGraphicFormat2str(format));
    586         }
    587 
    588         size_t cols = testRandMod((maxCols + 1) - minCols) + minCols;
    589         frames[row].resize(cols);
    590         for (unsigned int col = 0; col < cols; col++) {
    591             ColorFract color(testRandFract(), testRandFract(), testRandFract());
    592             float alpha = testRandFract();
    593 
    594             frames[row][col] = new GraphicBuffer(w, h, format, texUsage);
    595             if ((rv = frames[row][col]->initCheck()) != NO_ERROR) {
    596                 testPrintE("GraphicBuffer initCheck failed, rv: %i", rv);
    597                 testPrintE("  frame %u width: %u height: %u format: %u %s",
    598                            row, w, h, format, hwcTestGraphicFormat2str(format));
    599                 exit(80);
    600             }
    601 
    602             hwcTestFillColor(frames[row][col].get(), color, alpha);
    603             if (verbose) {
    604                 testPrintI("    buf: %p handle: %p color: %s alpha: %f",
    605                            frames[row][col].get(), frames[row][col]->handle,
    606                            string(color).c_str(), alpha);
    607             }
    608         }
    609     }
    610 }
    611 
    612 /*
    613  * Vector Random Select
    614  *
    615  * Prandomly selects and returns num elements from vec.
    616  */
    617 template <class T>
    618 vector<T> vectorRandSelect(const vector<T>& vec, size_t num)
    619 {
    620     vector<T> rv = vec;
    621 
    622     while (rv.size() > num) {
    623         rv.erase(rv.begin() + testRandMod(rv.size()));
    624     }
    625 
    626     return rv;
    627 }
    628 
    629 /*
    630  * Vector Or
    631  *
    632  * Or's togethen the values of each element of vec and returns the result.
    633  */
    634 template <class T>
    635 T vectorOr(const vector<T>& vec)
    636 {
    637     T rv = 0;
    638 
    639     for (size_t n1 = 0; n1 < vec.size(); n1++) {
    640         rv |= vec[n1];
    641     }
    642 
    643     return rv;
    644 }
    645