int tool_main(int argc, char** argv) {
SetupCrashHandler();
SkCommandLineFlags::SetUsage("");
SkCommandLineFlags::Parse(argc, argv);
SkGraphics::Init();
SkString header("PathOps SkpClip:");
if (!FLAGS_match.isEmpty()) {
header.appendf(" --match");
for (int index = 0; index < FLAGS_match.count(); ++index) {
header.appendf(" %s", FLAGS_match[index]);
}
}
if (!FLAGS_dir.isEmpty()) {
int count = FLAGS_dir.count();
for (int i = 0; i < count; ++i) {
const char* range = FLAGS_dir[i];
const char* dash = strchr(range, '-');
if (!dash) {
dash = strchr(range, ',');
}
int first = atoi(range);
int last = dash ? atoi(dash + 1) : first;
if (!first || !last) {
SkDebugf("couldn't parse --dir %s\n", range);
return 1;
}
gDirs.set(first, last);
}
}
if (!FLAGS_skp.isEmpty()) {
gNames.set(FLAGS_skp);
}
#ifdef SK_DEBUG
header.append(" SK_DEBUG");
#else
header.append(" SK_RELEASE");
#endif
header.appendf(" skia_arch_width=%d", (int)sizeof(void*) * 8);
if (FLAGS_verbose) {
header.appendf("\n");
}
SkDebugf("%s", header.c_str());
Iter iter;
Test* test;
while ((test = iter.next()) != NULL) {
SkAutoTDelete<Test> owned(test);
if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, test->getName())) {
test->run();
}
}
SkGraphics::Term();
return 0;
}
int tool_main(int argc, char** argv) {
SetupCrashHandler();
SkString usage;
usage.printf("Time drawing .skp files.\n"
"\tPossible arguments for --filter: [%s]\n\t\t[%s]",
filterTypesUsage().c_str(), filterFlagsUsage().c_str());
SkCommandLineFlags::SetUsage(usage.c_str());
SkCommandLineFlags::Parse(argc, argv);
if (FLAGS_repeat < 1) {
SkString error;
error.printf("--repeats must be >= 1. Was %i\n", FLAGS_repeat);
gLogger.logError(error);
exit(-1);
}
if (FLAGS_logFile.count() == 1) {
if (!gLogger.SetLogFile(FLAGS_logFile[0])) {
SkString str;
str.printf("Could not open %s for writing.\n", FLAGS_logFile[0]);
gLogger.logError(str);
// 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);
}
}
SkAutoTDelete<PictureJSONResultsWriter> jsonWriter;
if (FLAGS_jsonLog.count() == 1) {
SkASSERT(FLAGS_builderName.count() == 1 && FLAGS_gitHash.count() == 1);
jsonWriter.reset(SkNEW(PictureJSONResultsWriter(
FLAGS_jsonLog[0],
FLAGS_builderName[0],
FLAGS_buildNumber,
FLAGS_timestamp,
FLAGS_gitHash[0],
FLAGS_gitNumber)));
gWriter.add(jsonWriter.get());
}
gWriter.add(&gLogWriter);
#if SK_ENABLE_INST_COUNT
gPrintInstCount = true;
#endif
SkAutoGraphics ag;
sk_tools::PictureBenchmark benchmark;
setup_benchmark(&benchmark);
int failures = 0;
for (int i = 0; i < FLAGS_readPath.count(); ++i) {
failures += process_input(FLAGS_readPath[i], benchmark);
}
if (failures != 0) {
SkString err;
err.printf("Failed to run %i benchmarks.\n", failures);
gLogger.logError(err);
return 1;
}
#if SK_LAZY_CACHE_STATS
if (FLAGS_trackDeferredCaching) {
SkDebugf("Total cache hit rate: %f\n",
(double) gTotalCacheHits / (gTotalCacheHits + gTotalCacheMisses));
}
#endif
gWriter.end();
return 0;
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int retCode = 1; // by default it's error
#ifdef DEBUG
// Memory leak detection (only enable _CRTDBG_LEAK_CHECK_DF for
// regular termination so that leaks aren't checked on exceptions,
// aborts, etc. where some clean-up might not take place)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF);
//_CrtSetBreakAlloc(421);
TryLoadMemTrace();
#endif
DisableDataExecution();
// ensure that C functions behave consistently under all OS locales
// (use Win32 functions where localized input or output is desired)
setlocale(LC_ALL, "C");
// don't show system-provided dialog boxes when accessing files on drives
// that are not mounted (e.g. a: drive without floppy or cd rom drive
// without a cd).
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
#if defined(DEBUG) || defined(SVN_PRE_RELEASE_VER)
if (str::StartsWith(lpCmdLine, "/tester")) {
extern int TesterMain(); // in Tester.cpp
return TesterMain();
}
if (str::StartsWith(lpCmdLine, "/regress")) {
extern int RegressMain(); // in Regress.cpp
return RegressMain();
}
#endif
#ifdef SUPPORTS_AUTO_UPDATE
if (str::StartsWith(lpCmdLine, "-autoupdate")) {
bool quit = AutoUpdateMain();
if (quit)
return 0;
}
#endif
srand((unsigned int)time(NULL));
// load uiautomationcore.dll before installing crash handler (i.e. initializing
// dbghelp.dll), so that we get function names/offsets in GetCallstack()
uia::Initialize();
#ifdef DEBUG
dbghelp::RememberCallstackLogs();
#endif
SetupCrashHandler();
ScopedOle ole;
InitAllCommonControls();
ScopedGdiPlus gdiPlus(true);
mui::Initialize();
uitask::Initialize();
prefs::Load();
CommandLineInfo i(GetCommandLine());
SetCurrentLang(i.lang ? i.lang : gGlobalPrefs->uiLanguage);
// This allows ad-hoc comparison of gdi, gdi+ and gdi+ quick when used
// in layout
#if 0
RedirectIOToConsole();
BenchEbookLayout(L"C:\\kjk\\downloads\\pg12.mobi");
system("pause");
goto Exit;
#endif
if (i.showConsole) {
RedirectIOToConsole();
RedirectDllIOToConsole();
}
if (i.makeDefault)
AssociateExeWithPdfExtension();
if (i.pathsToBenchmark.Count() > 0) {
BenchFileOrDir(i.pathsToBenchmark);
if (i.showConsole)
system("pause");
}
if (i.exitImmediately)
goto Exit;
gCrashOnOpen = i.crashOnOpen;
gPolicyRestrictions = GetPolicies(i.restrictedUse);
GetFixedPageUiColors(gRenderCache.textColor, gRenderCache.backgroundColor);
DebugGdiPlusDevice(gUseGdiRenderer);
if (!RegisterWinClass())
goto Exit;
CrashIf(hInstance != GetModuleHandle(NULL));
if (!InstanceInit(nCmdShow))
goto Exit;
if (i.hwndPluginParent) {
if (!SetupPluginMode(i))
goto Exit;
}
if (i.printerName) {
// note: this prints all PDF files. Another option would be to
// print only the first one
for (size_t n = 0; n < i.fileNames.Count(); n++) {
bool ok = PrintFile(i.fileNames.At(n), i.printerName, !i.silent, i.printSettings);
if (!ok)
retCode++;
}
--retCode; // was 1 if no print failures, turn 1 into 0
goto Exit;
}
bool showStartPage = i.fileNames.Count() == 0 && gGlobalPrefs->rememberOpenedFiles && gGlobalPrefs->showStartPage;
if (showStartPage) {
// make the shell prepare the image list, so that it's ready when the first window's loaded
SHFILEINFO sfi;
SHGetFileInfo(L".pdf", 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES);
}
if (gGlobalPrefs->reopenOnce) {
WStrVec moreFileNames;
ParseCmdLine(gGlobalPrefs->reopenOnce, moreFileNames);
moreFileNames.Reverse();
for (WCHAR **fileName = moreFileNames.IterStart(); fileName; fileName = moreFileNames.IterNext()) {
i.fileNames.Append(*fileName);
}
moreFileNames.RemoveAt(0, moreFileNames.Count());
str::ReplacePtr(&gGlobalPrefs->reopenOnce, NULL);
}
HANDLE hMutex = NULL;
HWND hPrevWnd = NULL;
if (i.printDialog || i.stressTestPath || gPluginMode) {
// TODO: pass print request through to previous instance?
}
else if (i.reuseDdeInstance) {
hPrevWnd = FindWindow(FRAME_CLASS_NAME, NULL);
}
else if (gGlobalPrefs->reuseInstance || gGlobalPrefs->useTabs) {
hPrevWnd = FindPrevInstWindow(&hMutex);
}
if (hPrevWnd) {
for (size_t n = 0; n < i.fileNames.Count(); n++) {
OpenUsingDde(hPrevWnd, i.fileNames.At(n), i, 0 == n);
}
goto Exit;
}
WindowInfo *win = NULL;
for (size_t n = 0; n < i.fileNames.Count(); n++) {
win = LoadOnStartup(i.fileNames.At(n), i, !win);
if (!win) {
retCode++;
continue;
}
if (i.printDialog)
OnMenuPrint(win, i.exitWhenDone);
}
if (i.fileNames.Count() > 0 && !win) {
// failed to create any window, even though there
// were files to load (or show a failure message for)
goto Exit;
}
if (i.printDialog && i.exitWhenDone)
goto Exit;
if (!win) {
win = CreateAndShowWindowInfo();
if (!win)
goto Exit;
}
UpdateUITextForLanguage(); // needed for RTL languages
if (win->IsAboutWindow()) {
// TODO: shouldn't CreateAndShowWindowInfo take care of this?
UpdateToolbarAndScrollbarState(*win);
}
// Make sure that we're still registered as default,
// if the user has explicitly told us to be
if (gGlobalPrefs->associatedExtensions)
RegisterForPdfExtentions(win->hwndFrame);
if (i.stressTestPath) {
// don't save file history and preference changes
gPolicyRestrictions = (gPolicyRestrictions | Perm_RestrictedUse) & ~Perm_SavePreferences;
RebuildMenuBarForWindow(win);
StartStressTest(&i, win, &gRenderCache);
}
if (gGlobalPrefs->checkForUpdates)
UpdateCheckAsync(win, true);
// only hide newly missing files when showing the start page on startup
if (showStartPage && gFileHistory.Get(0)) {
gFileExistenceChecker = new FileExistenceChecker();
gFileExistenceChecker->Start();
}
// call this once it's clear whether Perm_SavePreferences has been granted
prefs::RegisterForFileChanges();
retCode = RunMessageLoop();
SafeCloseHandle(&hMutex);
CleanUpThumbnailCache(gFileHistory);
Exit:
prefs::UnregisterForFileChanges();
while (gWindows.Count() > 0) {
DeleteWindowInfo(gWindows.At(0));
}
#ifndef DEBUG
// leave all the remaining clean-up to the OS
// (as recommended for a quick exit)
ExitProcess(retCode);
#else
DeleteObject(GetDefaultGuiFont());
DeleteBitmap(gBitmapReloadingCue);
DeleteSplitterBrush();
// wait for FileExistenceChecker to terminate
// (which should be necessary only very rarely)
while (gFileExistenceChecker) {
Sleep(10);
uitask::DrainQueue();
}
mui::Destroy();
uitask::Destroy();
trans::Destroy();
SaveCallstackLogs();
dbghelp::FreeCallstackLogs();
// must be after uitask::Destroy() because we might have queued prefs::Reload()
// which crashes if gGlobalPrefs is freed
gFileHistory.UpdateStatesSource(NULL);
DeleteGlobalPrefs(gGlobalPrefs);
// it's still possible to crash after this (destructors of static classes,
// atexit() code etc.) point, but it's very unlikely
UninstallCrashHandler();
// output leaks after all destructors of static objects have run
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
return retCode;
#endif
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int retCode = 1; // by default it's error
#ifdef DEBUG
// Memory leak detection (only enable _CRTDBG_LEAK_CHECK_DF for
// regular termination so that leaks aren't checked on exceptions,
// aborts, etc. where some clean-up might not take place)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF);
//_CrtSetBreakAlloc(421);
TryLoadMemTrace();
#endif
DisableDataExecution();
// ensure that C functions behave consistently under all OS locales
// (use Win32 functions where localized input or output is desired)
setlocale(LC_ALL, "C");
// don't show system-provided dialog boxes when accessing files on drives
// that are not mounted (e.g. a: drive without floppy or cd rom drive
// without a cd).
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
#if defined(DEBUG) || defined(SVN_PRE_RELEASE_VER)
if (str::StartsWith(lpCmdLine, "/tester")) {
extern int TesterMain(); // in Tester.cpp
return TesterMain();
}
if (str::StartsWith(lpCmdLine, "/regress")) {
extern int RegressMain(); // in Regress.cpp
return RegressMain();
}
#endif
#ifdef SUPPORTS_AUTO_UPDATE
if (str::StartsWith(lpCmdLine, "-autoupdate")) {
bool quit = AutoUpdateMain();
if (quit)
return 0;
}
#endif
srand((unsigned int)time(NULL));
// load uiautomationcore.dll before installing crash handler (i.e. initializing
// dbghelp.dll), so that we get function names/offsets in GetCallstack()
uia::Initialize();
#ifdef DEBUG
dbghelp::RememberCallstackLogs();
#endif
SetupCrashHandler();
ScopedOle ole;
InitAllCommonControls();
ScopedGdiPlus gdiPlus(true);
mui::Initialize();
uitask::Initialize();
prefs::Load();
CommandLineInfo i;
GetCommandLineInfo(i);
SetCurrentLang(i.lang ? i.lang : gGlobalPrefs->uiLanguage);
if (i.showConsole)
RedirectIOToConsole();
if (i.makeDefault)
AssociateExeWithPdfExtension();
if (i.pathsToBenchmark.Count() > 0) {
BenchFileOrDir(i.pathsToBenchmark);
if (i.showConsole)
system("pause");
}
if (i.exitImmediately)
goto Exit;
gCrashOnOpen = i.crashOnOpen;
gGlobalPrefs->mainWindowBackground = i.bgColor;
if (gGlobalPrefs->forwardSearch.highlightColor != i.forwardSearch.highlightColor ||
gGlobalPrefs->forwardSearch.highlightOffset != i.forwardSearch.highlightOffset ||
gGlobalPrefs->forwardSearch.highlightPermanent != i.forwardSearch.highlightPermanent ||
gGlobalPrefs->forwardSearch.highlightWidth != i.forwardSearch.highlightWidth) {
gGlobalPrefs->enableTeXEnhancements = true;
}
gGlobalPrefs->forwardSearch = i.forwardSearch;
gGlobalPrefs->escToExit = i.escToExit;
gGlobalPrefs->comicBookUI.cbxMangaMode = i.cbxMangaMode;
gPolicyRestrictions = GetPolicies(i.restrictedUse);
gRenderCache.colorRange[0] = i.colorRange[0];
gRenderCache.colorRange[1] = i.colorRange[1];
DebugGdiPlusDevice(gUseGdiRenderer);
if (i.inverseSearchCmdLine) {
str::ReplacePtr(&gGlobalPrefs->inverseSearchCmdLine, i.inverseSearchCmdLine);
gGlobalPrefs->enableTeXEnhancements = true;
}
if (!RegisterWinClass(hInstance))
goto Exit;
if (!InstanceInit(hInstance, nCmdShow))
goto Exit;
if (i.hwndPluginParent) {
if (!SetupPluginMode(i))
goto Exit;
}
if (i.printerName) {
// note: this prints all PDF files. Another option would be to
// print only the first one
for (size_t n = 0; n < i.fileNames.Count(); n++) {
bool ok = PrintFile(i.fileNames.At(n), i.printerName, !i.silent, i.printSettings);
if (!ok)
retCode++;
}
--retCode; // was 1 if no print failures, turn 1 into 0
goto Exit;
}
if (i.fileNames.Count() == 0 && gGlobalPrefs->rememberOpenedFiles && gGlobalPrefs->showStartPage) {
// make the shell prepare the image list, so that it's ready when the first window's loaded
SHFILEINFO sfi;
SHGetFileInfo(L".pdf", 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES);
}
if (!i.reuseInstance && gGlobalPrefs->reuseInstance && FindWindow(FRAME_CLASS_NAME, 0))
i.reuseInstance = true;
WindowInfo *win = NULL;
bool isFirstWin = true;
for (size_t n = 0; n < i.fileNames.Count(); n++) {
if (i.reuseInstance && !i.printDialog) {
OpenUsingDde(i.fileNames.At(n), i, isFirstWin);
} else {
win = LoadOnStartup(i.fileNames.At(n), i, isFirstWin);
if (!win) {
retCode++;
continue;
}
if (i.printDialog)
OnMenuPrint(win, i.exitWhenDone);
}
isFirstWin = false;
}
if (i.fileNames.Count() > 0 && isFirstWin) {
// failed to create any window, even though there
// were files to load (or show a failure message for)
goto Exit;
}
if (i.reuseInstance && !i.printDialog || i.printDialog && i.exitWhenDone)
goto Exit;
if (isFirstWin) {
win = CreateAndShowWindowInfo();
if (!win)
goto Exit;
}
UpdateUITextForLanguage(); // needed for RTL languages
if (isFirstWin)
UpdateToolbarAndScrollbarState(*win);
// Make sure that we're still registered as default,
// if the user has explicitly told us to be
if (gGlobalPrefs->associatedExtensions && win)
RegisterForPdfExtentions(win->hwndFrame);
if (gGlobalPrefs->checkForUpdates && gWindows.Count() > 0)
AutoUpdateCheckAsync(gWindows.At(0)->hwndFrame, true);
if (i.stressTestPath) {
// don't save file history and preference changes
gPolicyRestrictions = (gPolicyRestrictions | Perm_RestrictedUse) & ~Perm_SavePreferences;
RebuildMenuBarForWindow(win);
StartStressTest(&i, win, &gRenderCache);
}
if (gFileHistory.Get(0)) {
gFileExistenceChecker = new FileExistenceChecker();
gFileExistenceChecker->Start();
}
// call this once it's clear whether Perm_SavePreferences has been granted
prefs::RegisterForFileChanges();
retCode = RunMessageLoop();
CleanUpThumbnailCache(gFileHistory);
Exit:
prefs::UnregisterForFileChanges();
while (gWindows.Count() > 0) {
DeleteWindowInfo(gWindows.At(0));
}
while (gEbookWindows.Count() > 0) {
DeleteEbookWindow(gEbookWindows.At(0), true);
}
#ifndef DEBUG
// leave all the remaining clean-up to the OS
// (as recommended for a quick exit)
ExitProcess(retCode);
#else
DeleteObject(gDefaultGuiFont);
DeleteBitmap(gBitmapReloadingCue);
// wait for FileExistenceChecker to terminate
// (which should be necessary only very rarely)
while (gFileExistenceChecker) {
Sleep(10);
uitask::DrainQueue();
}
mui::Destroy();
uitask::Destroy();
trans::Destroy();
SaveCallstackLogs();
dbghelp::FreeCallstackLogs();
// must be after uitask::Destroy() because we might have queued prefs::Reload()
// which crashes if gGlobalPrefs is freed
gFileHistory.UpdateStatesSource(NULL);
DeleteGlobalPrefs(gGlobalPrefs);
// it's still possible to crash after this (destructors of static classes,
// atexit() code etc.) point, but it's very unlikely
UninstallCrashHandler();
// output leaks after all destructors of static objects have run
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
return retCode;
#endif
}
int tool_main(int argc, char** argv) {
SetupCrashHandler();
SkCommandLineFlags::Parse(argc, argv);
#if SK_ENABLE_INST_COUNT
if (FLAGS_leaks) {
gPrintInstCount = true;
}
#endif
SkAutoGraphics ag;
// First, parse some flags.
BenchLogger logger;
if (FLAGS_logFile.count()) {
logger.SetLogFile(FLAGS_logFile[0]);
}
LoggerResultsWriter logWriter(logger, FLAGS_timeFormat[0]);
MultiResultsWriter writer;
writer.add(&logWriter);
SkAutoTDelete<JSONResultsWriter> jsonWriter;
if (FLAGS_outResultsFile.count()) {
jsonWriter.reset(SkNEW(JSONResultsWriter(FLAGS_outResultsFile[0])));
writer.add(jsonWriter.get());
}
// Instantiate after all the writers have been added to writer so that we
// call close() before their destructors are called on the way out.
CallEnd<MultiResultsWriter> ender(writer);
const uint8_t alpha = FLAGS_forceBlend ? 0x80 : 0xFF;
SkTriState::State dither = SkTriState::kDefault;
for (size_t i = 0; i < 3; i++) {
if (strcmp(SkTriState::Name[i], FLAGS_forceDither[0]) == 0) {
dither = static_cast<SkTriState::State>(i);
}
}
BenchMode benchMode = kNormal_BenchMode;
for (size_t i = 0; i < SK_ARRAY_COUNT(BenchMode_Name); i++) {
if (strcmp(FLAGS_mode[0], BenchMode_Name[i]) == 0) {
benchMode = static_cast<BenchMode>(i);
}
}
SkTDArray<int> configs;
bool runDefaultConfigs = false;
// Try user-given configs first.
for (int i = 0; i < FLAGS_config.count(); i++) {
for (int j = 0; j < static_cast<int>(SK_ARRAY_COUNT(gConfigs)); ++j) {
if (0 == strcmp(FLAGS_config[i], gConfigs[j].name)) {
*configs.append() = j;
} else if (0 == strcmp(FLAGS_config[i], kDefaultsConfigStr)) {
runDefaultConfigs = true;
}
}
}
// If there weren't any, fill in with defaults.
if (runDefaultConfigs) {
for (int i = 0; i < static_cast<int>(SK_ARRAY_COUNT(gConfigs)); ++i) {
if (gConfigs[i].runByDefault) {
*configs.append() = i;
}
}
}
// Filter out things we can't run.
if (kNormal_BenchMode != benchMode) {
// Non-rendering configs only run in normal mode
for (int i = 0; i < configs.count(); ++i) {
const Config& config = gConfigs[configs[i]];
if (Benchmark::kNonRendering_Backend == config.backend) {
configs.remove(i, 1);
--i;
}
}
}
#if SK_SUPPORT_GPU
for (int i = 0; i < configs.count(); ++i) {
const Config& config = gConfigs[configs[i]];
if (Benchmark::kGPU_Backend == config.backend) {
GrContext* context = gContextFactory.get(config.contextType);
if (NULL == context) {
SkDebugf("GrContext could not be created for config %s. Config will be skipped.\n",
config.name);
configs.remove(i);
--i;
continue;
}
if (config.sampleCount > context->getMaxSampleCount()){
SkDebugf(
"Sample count (%d) for config %s is not supported. Config will be skipped.\n",
config.sampleCount, config.name);
configs.remove(i);
--i;
continue;
}
}
}
#endif
// All flags should be parsed now. Report our settings.
if (FLAGS_runOnce) {
logger.logError("bench was run with --runOnce, so we're going to hide the times."
" It's for your own good!\n");
}
writer.option("mode", FLAGS_mode[0]);
writer.option("alpha", SkStringPrintf("0x%02X", alpha).c_str());
writer.option("antialias", SkStringPrintf("%d", FLAGS_forceAA).c_str());
writer.option("filter", SkStringPrintf("%d", FLAGS_forceFilter).c_str());
writer.option("dither", SkTriState::Name[dither]);
writer.option("rotate", SkStringPrintf("%d", FLAGS_rotate).c_str());
writer.option("scale", SkStringPrintf("%d", FLAGS_scale).c_str());
writer.option("clip", SkStringPrintf("%d", FLAGS_clip).c_str());
#if defined(SK_BUILD_FOR_WIN32)
writer.option("system", "WIN32");
#elif defined(SK_BUILD_FOR_MAC)
writer.option("system", "MAC");
#elif defined(SK_BUILD_FOR_ANDROID)
writer.option("system", "ANDROID");
#elif defined(SK_BUILD_FOR_UNIX)
writer.option("system", "UNIX");
#else
writer.option("system", "other");
#endif
#if defined(SK_DEBUG)
writer.option("build", "DEBUG");
#else
writer.option("build", "RELEASE");
#endif
// Set texture cache limits if non-default.
for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
#if SK_SUPPORT_GPU
const Config& config = gConfigs[i];
if (Benchmark::kGPU_Backend != config.backend) {
continue;
}
GrContext* context = gContextFactory.get(config.contextType);
if (NULL == context) {
continue;
}
size_t bytes;
int count;
context->getResourceCacheLimits(&count, &bytes);
if (-1 != FLAGS_gpuCacheBytes) {
bytes = static_cast<size_t>(FLAGS_gpuCacheBytes);
}
if (-1 != FLAGS_gpuCacheCount) {
count = FLAGS_gpuCacheCount;
}
context->setResourceCacheLimits(count, bytes);
#endif
}
// Run each bench in each configuration it supports and we asked for.
Iter iter;
Benchmark* bench;
while ((bench = iter.next()) != NULL) {
SkAutoTUnref<Benchmark> benchUnref(bench);
if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getName())) {
continue;
}
bench->setForceAlpha(alpha);
bench->setForceAA(FLAGS_forceAA);
bench->setForceFilter(FLAGS_forceFilter);
bench->setDither(dither);
bench->preDraw();
bool loggedBenchName = false;
for (int i = 0; i < configs.count(); ++i) {
const int configIndex = configs[i];
const Config& config = gConfigs[configIndex];
if (!bench->isSuitableFor(config.backend)) {
continue;
}
GrContext* context = NULL;
#if SK_SUPPORT_GPU
SkGLContextHelper* glContext = NULL;
if (Benchmark::kGPU_Backend == config.backend) {
context = gContextFactory.get(config.contextType);
if (NULL == context) {
continue;
}
glContext = gContextFactory.getGLContext(config.contextType);
}
#endif
SkAutoTUnref<SkCanvas> canvas;
SkAutoTUnref<SkPicture> recordFrom;
SkPictureRecorder recorderTo;
const SkIPoint dim = bench->getSize();
SkAutoTUnref<SkSurface> surface;
if (Benchmark::kNonRendering_Backend != config.backend) {
surface.reset(make_surface(config.fColorType,
dim,
config.backend,
config.sampleCount,
context));
if (!surface.get()) {
logger.logError(SkStringPrintf(
"Device creation failure for config %s. Will skip.\n", config.name));
continue;
}
switch(benchMode) {
case kDeferredSilent_BenchMode:
case kDeferred_BenchMode:
canvas.reset(SkDeferredCanvas::Create(surface.get()));
break;
case kRecord_BenchMode:
canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY)));
break;
case kPictureRecord_BenchMode: {
SkPictureRecorder recorderFrom;
bench->draw(1, recorderFrom.beginRecording(dim.fX, dim.fY));
recordFrom.reset(recorderFrom.endRecording());
canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY)));
break;
}
case kNormal_BenchMode:
canvas.reset(SkRef(surface->getCanvas()));
break;
default:
SkASSERT(false);
}
}
if (NULL != canvas) {
canvas->clear(SK_ColorWHITE);
if (FLAGS_clip) {
perform_clip(canvas, dim.fX, dim.fY);
}
if (FLAGS_scale) {
perform_scale(canvas, dim.fX, dim.fY);
}
if (FLAGS_rotate) {
perform_rotate(canvas, dim.fX, dim.fY);
}
}
if (!loggedBenchName) {
loggedBenchName = true;
writer.bench(bench->getName(), dim.fX, dim.fY);
}
#if SK_SUPPORT_GPU
SkGLContextHelper* contextHelper = NULL;
if (Benchmark::kGPU_Backend == config.backend) {
contextHelper = gContextFactory.getGLContext(config.contextType);
}
BenchTimer timer(contextHelper);
#else
BenchTimer timer;
#endif
double previous = std::numeric_limits<double>::infinity();
bool converged = false;
// variables used to compute loopsPerFrame
double frameIntervalTime = 0.0f;
int frameIntervalTotalLoops = 0;
bool frameIntervalComputed = false;
int loopsPerFrame = 0;
int loopsPerIter = 0;
if (FLAGS_verbose) { SkDebugf("%s %s: ", bench->getName(), config.name); }
if (!FLAGS_dryRun) {
do {
// Ramp up 1 -> 2 -> 4 -> 8 -> 16 -> ... -> ~1 billion.
loopsPerIter = (loopsPerIter == 0) ? 1 : loopsPerIter * 2;
if (loopsPerIter >= (1<<30) || timer.fWall > FLAGS_maxMs) {
// If you find it takes more than a billion loops to get up to 20ms of runtime,
// you've got a computer clocked at several THz or have a broken benchmark. ;)
// "1B ought to be enough for anybody."
logger.logError(SkStringPrintf(
"\nCan't get %s %s to converge in %dms (%d loops)",
bench->getName(), config.name, FLAGS_maxMs, loopsPerIter));
break;
}
if ((benchMode == kRecord_BenchMode || benchMode == kPictureRecord_BenchMode)) {
// Clear the recorded commands so that they do not accumulate.
canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY)));
}
timer.start();
// Inner loop that allows us to break the run into smaller
// chunks (e.g. frames). This is especially useful for the GPU
// as we can flush and/or swap buffers to keep the GPU from
// queuing up too much work.
for (int loopCount = loopsPerIter; loopCount > 0; ) {
// Save and restore around each call to draw() to guarantee a pristine canvas.
SkAutoCanvasRestore saveRestore(canvas, true/*also save*/);
int loops;
if (frameIntervalComputed && loopCount > loopsPerFrame) {
loops = loopsPerFrame;
loopCount -= loopsPerFrame;
} else {
loops = loopCount;
loopCount = 0;
}
if (benchMode == kPictureRecord_BenchMode) {
recordFrom->draw(canvas);
} else {
bench->draw(loops, canvas);
}
if (kDeferredSilent_BenchMode == benchMode) {
static_cast<SkDeferredCanvas*>(canvas.get())->silentFlush();
} else if (NULL != canvas) {
canvas->flush();
}
#if SK_SUPPORT_GPU
// swap drawing buffers on each frame to prevent the GPU
// from queuing up too much work
if (NULL != glContext) {
glContext->swapBuffers();
}
#endif
}
// Stop truncated timers before GL calls complete, and stop the full timers after.
timer.truncatedEnd();
#if SK_SUPPORT_GPU
if (NULL != glContext) {
context->flush();
SK_GL(*glContext, Finish());
}
#endif
timer.end();
// setup the frame interval for subsequent iterations
if (!frameIntervalComputed) {
frameIntervalTime += timer.fWall;
frameIntervalTotalLoops += loopsPerIter;
if (frameIntervalTime >= FLAGS_minMs) {
frameIntervalComputed = true;
loopsPerFrame =
(int)(((double)frameIntervalTotalLoops / frameIntervalTime) * FLAGS_minMs);
if (loopsPerFrame < 1) {
loopsPerFrame = 1;
}
// SkDebugf(" %s has %d loops in %f ms (normalized to %d)\n",
// bench->getName(), frameIntervalTotalLoops,
// timer.fWall, loopsPerFrame);
}
}
const double current = timer.fWall / loopsPerIter;
if (FLAGS_verbose && current > previous) { SkDebugf("↑"); }
if (FLAGS_verbose) { SkDebugf("%.3g ", current); }
converged = HasConverged(previous, current, timer.fWall);
previous = current;
} while (!FLAGS_runOnce && !converged);
}
if (FLAGS_verbose) { SkDebugf("\n"); }
if (!FLAGS_dryRun && FLAGS_outDir.count() && Benchmark::kNonRendering_Backend != config.backend) {
SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
if (image.get()) {
saveFile(bench->getName(), config.name, FLAGS_outDir[0],
image);
}
}
if (FLAGS_runOnce) {
// Let's not mislead ourselves by looking at Debug build or single iteration bench times!
continue;
}
// Normalize to ms per 1000 iterations.
const double normalize = 1000.0 / loopsPerIter;
const struct { char shortName; const char* longName; double ms; } times[] = {
{'w', "msecs", normalize * timer.fWall},
{'W', "Wmsecs", normalize * timer.fTruncatedWall},
{'c', "cmsecs", normalize * timer.fCpu},
{'C', "Cmsecs", normalize * timer.fTruncatedCpu},
{'g', "gmsecs", normalize * timer.fGpu},
};
writer.config(config.name);
for (size_t i = 0; i < SK_ARRAY_COUNT(times); i++) {
if (strchr(FLAGS_timers[0], times[i].shortName) && times[i].ms > 0) {
writer.timer(times[i].longName, times[i].ms);
}
}
}
}
#if SK_SUPPORT_GPU
gContextFactory.destroyContexts();
#endif
return 0;
}
int tool_main(int argc, char** argv) {
SetupCrashHandler();
SkAutoGraphics ag;
SkCommandLineFlags::Parse(argc, argv);
const double overhead = estimate_timer_overhead();
if (FLAGS_verbose) {
// No header.
} else if (FLAGS_quiet) {
SkDebugf("min\tbench\tconfig\n");
} else {
SkDebugf("loops\tmin\tmean\tmax\tstddev\tbench\tconfig\n");
}
for (const BenchRegistry* r = BenchRegistry::Head(); r != NULL; r = r->next()) {
SkAutoTDelete<Benchmark> bench(r->factory()(NULL));
if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getName())) {
continue;
}
SkTDArray<SkSurface*> surfaces;
SkTDArray<const char*> configs;
create_surfaces(bench.get(), &surfaces, &configs);
bench->preDraw();
for (int j = 0; j < surfaces.count(); j++) {
SkCanvas* canvas = surfaces[j] ? surfaces[j]->getCanvas() : NULL;
const char* config = configs[j];
bench->draw(1, canvas); // Just paranoid warmup.
safe_flush(canvas);
const int loops = guess_loops(overhead, bench.get(), canvas);
SkAutoTMalloc<double> samples(FLAGS_samples);
WallTimer timer;
for (int i = 0; i < FLAGS_samples; i++) {
timer.start();
bench->draw(loops, canvas);
safe_flush(canvas);
timer.end();
samples[i] = timer.fWall / loops;
}
Stats stats(samples.get(), FLAGS_samples);
if (FLAGS_verbose) {
for (int i = 0; i < FLAGS_samples; i++) {
SkDebugf("%s ", humanize(samples[i]).c_str());
}
SkDebugf("%s\n", bench->getName());
} else if (FLAGS_quiet) {
if (configs.count() == 1) {
config = ""; // Only print the config if we run the same bench on more than one.
}
SkDebugf("%s\t%s\t%s\n", humanize(stats.min).c_str(), bench->getName(), config);
} else {
const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
SkDebugf("%d\t%s\t%s\t%s\t%.0f%%\t%s\t%s\n"
, loops
, humanize(stats.min).c_str()
, humanize(stats.mean).c_str()
, humanize(stats.max).c_str()
, stddev_percent
, bench->getName()
, config
);
}
}
surfaces.deleteAll();
}
return 0;
}
