static void setup_benchmark(sk_tools::PictureBenchmark* benchmark) { sk_tools::PictureRenderer::DrawFilterFlags drawFilters[SkDrawFilter::kTypeCount]; sk_bzero(drawFilters, sizeof(drawFilters)); if (FLAGS_filter.count() > 0) { const char* filters = FLAGS_filter[0]; const char* colon = strchr(filters, ':'); if (colon) { int32_t type = -1; size_t typeLen = colon - filters; for (size_t tIndex = 0; tIndex < kFilterTypesCount; ++tIndex) { if (typeLen == strlen(gFilterTypes[tIndex]) && !strncmp(filters, gFilterTypes[tIndex], typeLen)) { type = SkToS32(tIndex); break; } } if (type < 0) { SkString err; err.printf("Unknown type for --filter %s\n", filters); gLogger.logError(err); exit(-1); } int flag = -1; size_t flagLen = strlen(filters) - typeLen - 1; for (size_t fIndex = 0; fIndex < kFilterFlagsCount; ++fIndex) { if (flagLen == strlen(gFilterFlags[fIndex]) && !strncmp(colon + 1, gFilterFlags[fIndex], flagLen)) { flag = 1 << fIndex; break; } } if (flag < 0) { SkString err; err.printf("Unknown flag for --filter %s\n", filters); gLogger.logError(err); exit(-1); } for (int index = 0; index < SkDrawFilter::kTypeCount; ++index) { if (type != SkDrawFilter::kTypeCount && index != type) { continue; } drawFilters[index] = (sk_tools::PictureRenderer::DrawFilterFlags) (drawFilters[index] | flag); } } else { SkString err; err.printf("Unknown arg for --filter %s : missing colon\n", filters); gLogger.logError(err); exit(-1); } } if (FLAGS_timers.count() > 0) { size_t index = 0; bool timerWall = false; bool truncatedTimerWall = false; bool timerCpu = false; bool truncatedTimerCpu = false; bool timerGpu = false; while (index < strlen(FLAGS_timers[0])) { switch (FLAGS_timers[0][index]) { case 'w': timerWall = true; break; case 'c': timerCpu = true; break; case 'W': truncatedTimerWall = true; break; case 'C': truncatedTimerCpu = true; break; case 'g': timerGpu = true; break; default: SkDebugf("mystery character\n"); break; } index++; } benchmark->setTimersToShow(timerWall, truncatedTimerWall, timerCpu, truncatedTimerCpu, timerGpu); } SkString errorString; SkAutoTUnref<sk_tools::PictureRenderer> renderer(parseRenderer(errorString, kBench_PictureTool)); if (errorString.size() > 0) { gLogger.logError(errorString); } if (NULL == renderer.get()) { exit(-1); } if (FLAGS_timeIndividualTiles) { sk_tools::TiledPictureRenderer* tiledRenderer = renderer->getTiledRenderer(); if (NULL == tiledRenderer) { gLogger.logError("--timeIndividualTiles requires tiled rendering.\n"); exit(-1); } if (!tiledRenderer->supportsTimingIndividualTiles()) { gLogger.logError("This renderer does not support --timeIndividualTiles.\n"); exit(-1); } benchmark->setTimeIndividualTiles(true); } benchmark->setPurgeDecodedTex(FLAGS_purgeDecodedTex); benchmark->setPreprocess(FLAGS_preprocess); if (FLAGS_readPath.count() < 1) { gLogger.logError(".skp files or directories are required.\n"); exit(-1); } renderer->setDrawFilters(drawFilters, filtersName(drawFilters)); if (FLAGS_logPerIter) { benchmark->setTimerResultType(TimerData::kPerIter_Result); } else if (FLAGS_min) { benchmark->setTimerResultType(TimerData::kMin_Result); } else { benchmark->setTimerResultType(TimerData::kAvg_Result); } benchmark->setRenderer(renderer); benchmark->setRepeats(FLAGS_repeat); benchmark->setWriter(&gWriter); }
static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>* inputs, sk_tools::PictureBenchmark* benchmark) { const char* argv0 = argv[0]; char* const* stop = argv + argc; int repeats = DEFAULT_REPEATS; sk_tools::PictureRenderer::SkDeviceTypes deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType; SkAutoTUnref<sk_tools::PictureRenderer> renderer(NULL); // Create a string to show our current settings. // TODO: Make it prettier. Currently it just repeats the command line. SkString commandLine("bench_pictures:"); for (int i = 1; i < argc; i++) { commandLine.appendf(" %s", *(argv+i)); } commandLine.append("\n"); bool usePipe = false; int numThreads = 1; bool useTiles = false; const char* widthString = NULL; const char* heightString = NULL; int gridWidth = 0; int gridHeight = 0; bool isPowerOf2Mode = false; bool isCopyMode = false; const char* xTilesString = NULL; const char* yTilesString = NULL; const char* mode = NULL; bool gridSupported = false; sk_tools::PictureRenderer::BBoxHierarchyType bbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType; sk_tools::PictureRenderer::DrawFilterFlags drawFilters[SkDrawFilter::kTypeCount]; sk_bzero(drawFilters, sizeof(drawFilters)); SkISize viewport; viewport.setEmpty(); for (++argv; argv < stop; ++argv) { if (0 == strcmp(*argv, "--repeat")) { ++argv; if (argv < stop) { repeats = atoi(*argv); if (repeats < 1) { gLogger.logError("--repeat must be given a value > 0\n"); PRINT_USAGE_AND_EXIT; } } else { gLogger.logError("Missing arg for --repeat\n"); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--pipe")) { usePipe = true; } else if (0 == strcmp(*argv, "--logFile")) { argv++; if (argv < stop) { if (!gLogger.SetLogFile(*argv)) { SkString str; str.printf("Could not open %s for writing.", *argv); gLogger.logError(str); usage(argv0); // TODO(borenet): We're disabling this for now, due to // write-protected Android devices. The very short-term // solution is to ignore the fact that we have no log file. //exit(-1); } } else { gLogger.logError("Missing arg for --logFile\n"); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--multi")) { ++argv; if (argv >= stop) { gLogger.logError("Missing arg for --multi\n"); PRINT_USAGE_AND_EXIT; } numThreads = atoi(*argv); if (numThreads < 2) { gLogger.logError("Number of threads must be at least 2.\n"); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--bbh")) { ++argv; if (argv >= stop) { gLogger.logError("Missing value for --bbh\n"); PRINT_USAGE_AND_EXIT; } if (0 == strcmp(*argv, "none")) { bbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType; } else if (0 == strcmp(*argv, "rtree")) { bbhType = sk_tools::PictureRenderer::kRTree_BBoxHierarchyType; } else if (0 == strcmp(*argv, "grid")) { bbhType = sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType; ++argv; if (argv >= stop) { gLogger.logError("Missing width for --bbh grid\n"); PRINT_USAGE_AND_EXIT; } gridWidth = atoi(*argv); ++argv; if (argv >= stop) { gLogger.logError("Missing height for --bbh grid\n"); PRINT_USAGE_AND_EXIT; } gridHeight = atoi(*argv); } else { SkString err; err.printf("%s is not a valid value for --bbhType\n", *argv); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--mode")) { if (renderer.get() != NULL) { SkDebugf("Cannot combine modes.\n"); PRINT_USAGE_AND_EXIT; } ++argv; if (argv >= stop) { gLogger.logError("Missing mode for --mode\n"); PRINT_USAGE_AND_EXIT; } if (0 == strcmp(*argv, "record")) { renderer.reset(SkNEW(sk_tools::RecordPictureRenderer)); gridSupported = true; } else if (0 == strcmp(*argv, "clone")) { renderer.reset(sk_tools::CreatePictureCloneRenderer()); } else if (0 == strcmp(*argv, "simple")) { renderer.reset(SkNEW(sk_tools::SimplePictureRenderer)); } else if ((0 == strcmp(*argv, "tile")) || (0 == strcmp(*argv, "pow2tile")) || 0 == strcmp(*argv, "copyTile")) { useTiles = true; mode = *argv; if (0 == strcmp(*argv, "pow2tile")) { isPowerOf2Mode = true; } else if (0 == strcmp(*argv, "copyTile")) { isCopyMode = true; } else { gridSupported = true; } ++argv; if (argv >= stop) { SkString err; err.printf("Missing width for --mode %s\n", mode); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } widthString = *argv; ++argv; if (argv >= stop) { SkString err; err.appendf("Missing height for --mode %s\n", mode); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } heightString = *argv; } else if (0 == strcmp(*argv, "playbackCreation")) { renderer.reset(SkNEW(sk_tools::PlaybackCreationRenderer)); gridSupported = true; } else if (0 == strcmp(*argv, "gatherPixelRefs")) { renderer.reset(sk_tools::CreateGatherPixelRefsRenderer()); } else { SkString err; err.printf("%s is not a valid mode for --mode\n", *argv); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--viewport")) { ++argv; if (argv >= stop) { gLogger.logError("Missing width for --viewport\n"); PRINT_USAGE_AND_EXIT; } viewport.fWidth = atoi(*argv); ++argv; if (argv >= stop) { gLogger.logError("Missing height for --viewport\n"); PRINT_USAGE_AND_EXIT; } viewport.fHeight = atoi(*argv); } else if (0 == strcmp(*argv, "--tiles")) { ++argv; if (argv >= stop) { gLogger.logError("Missing x for --tiles\n"); PRINT_USAGE_AND_EXIT; } xTilesString = *argv; ++argv; if (argv >= stop) { gLogger.logError("Missing y for --tiles\n"); PRINT_USAGE_AND_EXIT; } yTilesString = *argv; } else if (0 == strcmp(*argv, "--device")) { ++argv; if (argv >= stop) { gLogger.logError("Missing mode for --device\n"); PRINT_USAGE_AND_EXIT; } if (0 == strcmp(*argv, "bitmap")) { deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType; } #if SK_SUPPORT_GPU else if (0 == strcmp(*argv, "gpu")) { deviceType = sk_tools::PictureRenderer::kGPU_DeviceType; } #endif else { SkString err; err.printf("%s is not a valid mode for --device\n", *argv); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--timers")) { ++argv; if (argv < stop) { bool timerWall = false; bool truncatedTimerWall = false; bool timerCpu = false; bool truncatedTimerCpu = false; bool timerGpu = false; for (char* t = *argv; *t; ++t) { switch (*t) { case 'w': timerWall = true; break; case 'c': timerCpu = true; break; case 'W': truncatedTimerWall = true; break; case 'C': truncatedTimerCpu = true; break; case 'g': timerGpu = true; break; default: { break; } } } benchmark->setTimersToShow(timerWall, truncatedTimerWall, timerCpu, truncatedTimerCpu, timerGpu); } else { gLogger.logError("Missing arg for --timers\n"); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--timeIndividualTiles")) { benchmark->setTimeIndividualTiles(true); } else if (0 == strcmp(*argv, "--min")) { benchmark->setPrintMin(true); } else if (0 == strcmp(*argv, "--logPerIter")) { ++argv; if (argv < stop) { bool log = atoi(*argv) != 0; benchmark->setLogPerIter(log); } else { gLogger.logError("Missing arg for --logPerIter\n"); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--filter")) { ++argv; if (argv < stop) { const char* colon = strchr(*argv, ':'); if (colon) { int type = -1; size_t typeLen = colon - *argv; for (size_t tIndex = 0; tIndex < kFilterTypesCount; ++tIndex) { if (typeLen == strlen(gFilterTypes[tIndex]) && !strncmp(*argv, gFilterTypes[tIndex], typeLen)) { type = tIndex; break; } } if (type < 0) { SkString err; err.printf("Unknown type for --filter %s\n", *argv); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } int flag = -1; size_t flagLen = strlen(*argv) - typeLen - 1; for (size_t fIndex = 0; fIndex < kFilterFlagsCount; ++fIndex) { if (flagLen == strlen(gFilterFlags[fIndex]) && !strncmp(colon + 1, gFilterFlags[fIndex], flagLen)) { flag = 1 << fIndex; break; } } if (flag < 0) { SkString err; err.printf("Unknown flag for --filter %s\n", *argv); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } for (int index = 0; index < SkDrawFilter::kTypeCount; ++index) { if (type != SkDrawFilter::kTypeCount && index != type) { continue; } drawFilters[index] = (sk_tools::PictureRenderer::DrawFilterFlags) (drawFilters[index] | flag); } } else { SkString err; err.printf("Unknown arg for --filter %s : missing colon\n", *argv); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } else { gLogger.logError("Missing arg for --filter\n"); PRINT_USAGE_AND_EXIT; } } else if (0 == strcmp(*argv, "--help") || 0 == strcmp(*argv, "-h")) { PRINT_USAGE_AND_EXIT; } else { inputs->push_back(SkString(*argv)); } } if (numThreads > 1 && !useTiles) { gLogger.logError("Multithreaded drawing requires tiled rendering.\n"); PRINT_USAGE_AND_EXIT; } if (usePipe && sk_tools::PictureRenderer::kNone_BBoxHierarchyType != bbhType) { gLogger.logError("--pipe and --bbh cannot be used together\n"); PRINT_USAGE_AND_EXIT; } if (sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType == bbhType && !gridSupported) { gLogger.logError("'--bbh grid' is not compatible with specified --mode.\n"); PRINT_USAGE_AND_EXIT; } if (useTiles) { SkASSERT(NULL == renderer); sk_tools::TiledPictureRenderer* tiledRenderer; if (isCopyMode) { int x, y; if (xTilesString != NULL) { SkASSERT(yTilesString != NULL); x = atoi(xTilesString); y = atoi(yTilesString); if (x <= 0 || y <= 0) { gLogger.logError("--tiles must be given values > 0\n"); PRINT_USAGE_AND_EXIT; } } else { x = y = 4; } tiledRenderer = SkNEW_ARGS(sk_tools::CopyTilesRenderer, (x, y)); if (benchmark->timeIndividualTiles()) { gLogger.logError("timeIndividualTiles is not compatible with copyTile\n"); PRINT_USAGE_AND_EXIT; } } else if (numThreads > 1) { tiledRenderer = SkNEW_ARGS(sk_tools::MultiCorePictureRenderer, (numThreads)); } else { tiledRenderer = SkNEW(sk_tools::TiledPictureRenderer); } if (isPowerOf2Mode) { int minWidth = atoi(widthString); if (!SkIsPow2(minWidth) || minWidth < 0) { tiledRenderer->unref(); SkString err; err.printf("-mode %s must be given a width" " value that is a power of two\n", mode); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } tiledRenderer->setTileMinPowerOf2Width(minWidth); } else if (sk_tools::is_percentage(widthString)) { if (isCopyMode) { tiledRenderer->unref(); SkString err; err.printf("--mode %s does not support percentages.\n", mode); gLogger.logError(err.c_str()); PRINT_USAGE_AND_EXIT; } tiledRenderer->setTileWidthPercentage(atof(widthString)); if (!(tiledRenderer->getTileWidthPercentage() > 0)) { tiledRenderer->unref(); SkString err; err.appendf("--mode %s must be given a width percentage > 0\n", mode); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } else { tiledRenderer->setTileWidth(atoi(widthString)); if (!(tiledRenderer->getTileWidth() > 0)) { tiledRenderer->unref(); SkString err; err.appendf("--mode %s must be given a width > 0\n", mode); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } if (sk_tools::is_percentage(heightString)) { if (isCopyMode) { tiledRenderer->unref(); SkString err; err.printf("--mode %s does not support percentages.\n", mode); gLogger.logError(err.c_str()); PRINT_USAGE_AND_EXIT; } tiledRenderer->setTileHeightPercentage(atof(heightString)); if (!(tiledRenderer->getTileHeightPercentage() > 0)) { tiledRenderer->unref(); SkString err; err.appendf("--mode %s must be given a height percentage > 0\n", mode); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } else { tiledRenderer->setTileHeight(atoi(heightString)); if (!(tiledRenderer->getTileHeight() > 0)) { tiledRenderer->unref(); SkString err; err.appendf("--mode %s must be given a height > 0\n", mode); gLogger.logError(err); PRINT_USAGE_AND_EXIT; } } if (numThreads > 1) { #if SK_SUPPORT_GPU if (sk_tools::PictureRenderer::kGPU_DeviceType == deviceType) { tiledRenderer->unref(); gLogger.logError("GPU not compatible with multithreaded tiling.\n"); PRINT_USAGE_AND_EXIT; } #endif } renderer.reset(tiledRenderer); if (usePipe) { gLogger.logError("Pipe rendering is currently not compatible with tiling.\n" "Turning off pipe.\n"); } } else { if (benchmark->timeIndividualTiles()) { gLogger.logError("timeIndividualTiles requires tiled rendering.\n"); PRINT_USAGE_AND_EXIT; } if (usePipe) { if (renderer.get() != NULL) { gLogger.logError("Pipe is incompatible with other modes.\n"); PRINT_USAGE_AND_EXIT; } renderer.reset(SkNEW(sk_tools::PipePictureRenderer)); } } if (inputs->count() < 1) { PRINT_USAGE_AND_EXIT; } if (NULL == renderer) { renderer.reset(SkNEW(sk_tools::SimplePictureRenderer)); } renderer->setBBoxHierarchyType(bbhType); renderer->setDrawFilters(drawFilters, filtersName(drawFilters)); renderer->setGridSize(gridWidth, gridHeight); renderer->setViewport(viewport); benchmark->setRenderer(renderer); benchmark->setRepeats(repeats); benchmark->setDeviceType(deviceType); benchmark->setLogger(&gLogger); // Report current settings: gLogger.logProgress(commandLine); }