nanobench.cpp File Reference

#include <ctype.h>
#include "bench/nanobench.h"
#include "bench/AndroidCodecBench.h"
#include "bench/Benchmark.h"
#include "bench/CodecBench.h"
#include "bench/CodecBenchPriv.h"
#include "bench/GMBench.h"
#include "bench/MSKPBench.h"
#include "bench/RecordingBench.h"
#include "bench/ResultsWriter.h"
#include "bench/SKPAnimationBench.h"
#include "bench/SKPBench.h"
#include "bench/SkGlyphCacheBench.h"
#include "bench/SkSLBench.h"
#include "include/codec/SkAndroidCodec.h"
#include "include/codec/SkCodec.h"
#include "include/codec/SkJpegDecoder.h"
#include "include/codec/SkPngDecoder.h"
#include "include/core/SkBBHFactory.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkData.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/encode/SkPngEncoder.h"
#include "include/private/base/SkMacros.h"
#include "src/base/SkAutoMalloc.h"
#include "src/base/SkLeanWindows.h"
#include "src/base/SkTime.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkTaskGroup.h"
#include "src/core/SkTraceEvent.h"
#include "src/utils/SkJSONWriter.h"
#include "src/utils/SkOSPath.h"
#include "src/utils/SkShaderUtils.h"
#include "tools/AutoreleasePool.h"
#include "tools/CrashHandler.h"
#include "tools/MSKPPlayer.h"
#include "tools/ProcStats.h"
#include "tools/Stats.h"
#include "tools/ToolUtils.h"
#include "tools/flags/CommonFlags.h"
#include "tools/flags/CommonFlagsConfig.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/ios_utils.h"
#include "tools/trace/EventTracingPriv.h"
#include "tools/trace/SkDebugfTracer.h"
#include <cinttypes>
#include <memory>
#include <optional>
#include <stdlib.h>
#include <thread>
#include <unistd.h>
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/SkGr.h"
#include "tools/gpu/GrContextFactory.h"

Go to the source code of this file.

Classes
struct	GPUTarget
class	BenchmarkStream
class	NanobenchShaderErrorHandler

Macros
#define	HUMANIZE(ms)   humanize(ms).c_str()
#define	kBogusContextType   skgpu::ContextType::kGL
#define	kBogusContextOverrides   GrContextFactory::ContextOverrides::kNone
#define	CPU_CONFIG(name, backend, color, alpha)

Functions
static SkString	loops_help_txt ()
static SkString	to_string (int n)
static	DEFINE_int (loops, kAutoTuneLoops, loops_help_txt().c_str())
static	DEFINE_int (samples, 10, "Number of samples to measure for each bench.")
static	DEFINE_int (ms, 0, "If >0, run each bench for this many ms instead of obeying --samples.")
static	DEFINE_int (overheadLoops, 100000, "Loops to estimate timer overhead.")
static	DEFINE_double (overheadGoal, 0.0001, "Loop until timer overhead is at most this fraction of our measurments.")
static	DEFINE_double (gpuMs, 5, "Target bench time in millseconds for GPU.")
static	DEFINE_int (gpuFrameLag, 5, "If unknown, estimated maximum number of frames GPU allows to lag.")
static	DEFINE_string (outResultsFile, "", "If given, write results here as JSON.")
static	DEFINE_int (maxCalibrationAttempts, 3, "Try up to this many times to guess loops for a bench, or skip the bench.")
static	DEFINE_int (maxLoops, 1000000, "Never run a bench more times than this.")
static	DEFINE_string (clip, "0,0,1000,1000", "Clip for SKPs.")
static	DEFINE_string (scales, "1.0", "Space-separated scales for SKPs.")
static	DEFINE_string (zoom, "1.0,0", "Comma-separated zoomMax,zoomPeriodMs factors for a periodic SKP zoom " "function that ping-pongs between 1.0 and zoomMax.")
static	DEFINE_bool (bbh, true, "Build a BBH for SKPs?")
static	DEFINE_bool (loopSKP, true, "Loop SKPs like we do for micro benches?")
static	DEFINE_int (flushEvery, 10, "Flush --outResultsFile every Nth run.")
static	DEFINE_bool (gpuStats, false, "Print GPU stats after each gpu benchmark?")
static	DEFINE_bool (gpuStatsDump, false, "Dump GPU stats after each benchmark to json")
static	DEFINE_bool (dmsaaStatsDump, false, "Dump DMSAA stats after each benchmark to json")
static	DEFINE_bool (keepAlive, false, "Print a message every so often so that we don't time out")
static	DEFINE_bool (csv, false, "Print status in CSV format")
static	DEFINE_string (sourceType, "", "Apply usual --match rules to source type: bench, gm, skp, image, etc.")
static	DEFINE_string (benchType, "", "Apply usual --match rules to bench type: micro, recording, " "piping, playback, skcodec, etc.")
static	DEFINE_bool (forceRasterPipeline, false, "sets gSkForceRasterPipelineBlitter")
static	DEFINE_bool (forceRasterPipelineHP, false, "sets gSkForceRasterPipelineBlitter and gForceHighPrecisionRasterPipeline")
static	DEFINE_bool2 (pre_log, p, false, "Log before running each test. May be incomprehensible when threading")
static	DEFINE_bool (cpu, true, "Run CPU-bound work?")
static	DEFINE_bool (gpu, true, "Run GPU-bound work?")
static	DEFINE_bool (dryRun, false, "just print the tests that would be run, without actually running them.")
static	DEFINE_string (images, "", "List of images and/or directories to decode. A directory with no images" " is treated as a fatal error.")
static	DEFINE_bool (simpleCodec, false, "Runs of a subset of the codec tests, always N32, Premul or Opaque")
static	DEFINE_string2 (match, m, nullptr, "[~][^]substring[$] [...] of name to run.\n" "Multiple matches may be separated by spaces.\n" "~ causes a matching name to always be skipped\n" "^ requires the start of the name to match\n" "$ requires the end of the name to match\n" "^ and $ requires an exact match\n" "If a name does not match any list entry,\n" "it is skipped unless some list entry starts with ~")
static	DEFINE_bool2 (quiet, q, false, "if true, don't print status updates.")
static	DEFINE_bool2 (verbose, v, false, "enable verbose output from the test driver.")
static	DEFINE_string (skps, "skps", "Directory to read skps from.")
static	DEFINE_string (mskps, "mskps", "Directory to read mskps from.")
static	DEFINE_string (svgs, "", "Directory to read SVGs from, or a single SVG file.")
static	DEFINE_string (texttraces, "", "Directory to read TextBlobTrace files from.")
static	DEFINE_int_2 (threads, j, -1, "Run threadsafe tests on a threadpool with this many extra threads, " "defaulting to one extra thread per core.")
static	DEFINE_string2 (writePath, w, "", "If set, write bitmaps here as .pngs.")
static	DEFINE_string (key, "", "Space-separated key/value pairs to add to JSON identifying this builder.")
static	DEFINE_string (properties, "", "Space-separated key/value pairs to add to JSON identifying this run.")
static	DEFINE_bool (purgeBetweenBenches, false, "Call SkGraphics::PurgeAllCaches() between each benchmark?")
static	DEFINE_bool (splitPerfettoTracesByBenchmark, true, "Create separate perfetto trace files for each benchmark?\n" "Will only take effect if perfetto tracing is enabled. See --trace.")
static	DEFINE_bool (runtimeCPUDetection, true, "Skip runtime CPU detection and optimization")
static double	now_ms ()
static SkString	humanize (double ms)
static double	time (int loops, Benchmark *bench, Target *target)
static double	estimate_timer_overhead ()
static int	detect_forever_loops (int loops)
static int	clamp_loops (int loops)
static bool	write_canvas_png (Target *target, const SkString &filename)
static int	setup_cpu_bench (const double overhead, Target *target, Benchmark *bench)
static int	setup_gpu_bench (Target *target, Benchmark *bench, int maxGpuFrameLag)
static std::optional< Config >	create_config (const SkCommandLineConfig *config)
void	create_configs (TArray< Config > *configs)
static Target *	is_enabled (Benchmark *bench, const Config &config)
static void	cleanup_run (Target *target)
static void	collect_files (const CommandLineFlags::StringArray &paths, const char *ext, TArray< SkString > *list)
static void	start_keepalive ()
int	main (int argc, char **argv)

Variables
bool	gSkForceRasterPipelineBlitter
bool	gForceHighPrecisionRasterPipeline
GrContextOptions	grContextOpts
static const int	kAutoTuneLoops = 0
static int	kFailedLoops = -2

Macro Definition Documentation

CPU_CONFIG

#define CPU_CONFIG	(		name,
			backend,
			color,
			alpha
	)

Value:

    if (config->getBackend().equals(name)) {                                            \
        if (!FLAGS_cpu) {                                                               \
            SkDebugf("Skipping config '%s' as requested.\n", config->getTag().c_str()); \
            return std::nullopt;                                                      \
        }                                                                               \
        return Config{SkString(name),                                                   \
                      Benchmark::backend,                                               \
                      color,                                                            \
                      alpha,                                                            \
                      config->refColorSpace(),                                          \
                      0,                                                                \
                      kBogusContextType,                                                \
                      kBogusContextOverrides,                                           \
                      0};                                                               \
    }

HUMANIZE

#define HUMANIZE

(

ms

)

humanize(ms).c_str()

Definition at line 220 of file nanobench.cpp.

kBogusContextOverrides

#define kBogusContextOverrides   GrContextFactory::ContextOverrides::kNone

Definition at line 558 of file nanobench.cpp.

kBogusContextType

#define kBogusContextType   skgpu::ContextType::kGL

Definition at line 557 of file nanobench.cpp.

Function Documentation

clamp_loops()

static int clamp_loops ( int  loops )

static

Definition at line 428 of file nanobench.cpp.

                                  {
    if (loops < 1) {
        SkDebugf("ERROR: clamping loops from %d to 1. "
                 "There's probably something wrong with the bench.\n", loops);
        return 1;
    }
    if (loops > FLAGS_maxLoops) {
        SkDebugf("WARNING: clamping loops from %d to FLAGS_maxLoops, %d.\n", loops, FLAGS_maxLoops);
        return FLAGS_maxLoops;
    }
    return loops;
}

cleanup_run()

static void cleanup_run ( Target *  target )

static

Definition at line 772 of file nanobench.cpp.

                                        {
    delete target;
}

collect_files()

static void collect_files ( const CommandLineFlags::StringArray &  paths, const char *  ext, TArray< SkString > *  list  )

static

Definition at line 776 of file nanobench.cpp.

                                                                   {
    for (int i = 0; i < paths.size(); ++i) {
        if (SkStrEndsWith(paths[i], ext)) {
            list->push_back(SkString(paths[i]));
        } else {
            SkOSFile::Iter it(paths[i], ext);
            SkString path;
            while (it.next(&path)) {
                list->push_back(SkOSPath::Join(paths[i], path.c_str()));
            }
        }
    }
}

create_config()

static std::optional< Config > create_config ( const SkCommandLineConfig *  config )

static

Definition at line 560 of file nanobench.cpp.

                                                                            {
    if (const auto* gpuConfig = config->asConfigGpu()) {
        if (!FLAGS_gpu) {
            SkDebugf("Skipping config '%s' as requested.\n", config->getTag().c_str());
            return std::nullopt;
        }
 
        const auto ctxType = gpuConfig->getContextType();
        const auto ctxOverrides = gpuConfig->getContextOverrides();
        const auto sampleCount = gpuConfig->getSamples();
        const auto colorType = gpuConfig->getColorType();
        if (gpuConfig->getSurfType() != SkCommandLineConfigGpu::SurfType::kDefault) {
            SkDebugf("This tool only supports the default surface type.");
            return std::nullopt;
        }
 
        GrContextFactory factory(grContextOpts);
        if (const auto ctx = factory.get(ctxType, ctxOverrides)) {
            GrBackendFormat format = ctx->defaultBackendFormat(colorType, GrRenderable::kYes);
            int supportedSampleCount =
                    ctx->priv().caps()->getRenderTargetSampleCount(sampleCount, format);
            if (sampleCount != supportedSampleCount) {
                SkDebugf("Configuration '%s' sample count %d is not a supported sample count.\n",
                         config->getTag().c_str(),
                         sampleCount);
                return std::nullopt;
            }
        } else {
            SkDebugf("No context was available matching config '%s'.\n", config->getTag().c_str());
            return std::nullopt;
        }
 
        return Config{gpuConfig->getTag(),
                      Benchmark::Backend::kGanesh,
                      colorType,
                      kPremul_SkAlphaType,
                      config->refColorSpace(),
                      sampleCount,
                      ctxType,
                      ctxOverrides,
                      gpuConfig->getSurfaceFlags()};
    }
#if defined(SK_GRAPHITE)
    if (const auto* gpuConfig = config->asConfigGraphite()) {
        if (!FLAGS_gpu) {
            SkDebugf("Skipping config '%s' as requested.\n", config->getTag().c_str());
            return std::nullopt;
        }
 
        const auto graphiteCtxType = gpuConfig->getContextType();
        const auto sampleCount = 1; // TODO: gpuConfig->getSamples();
        const auto colorType = gpuConfig->getColorType();
 
        using ContextFactory = skiatest::graphite::ContextFactory;
 
        ContextFactory factory(gpuConfig->asConfigGraphite()->getOptions());
        skiatest::graphite::ContextInfo ctxInfo = factory.getContextInfo(graphiteCtxType);
        skgpu::graphite::Context* ctx = ctxInfo.fContext;
        if (ctx) {
            // TODO: Add graphite ctx queries for supported sample count by color type.
#if 0
            GrBackendFormat format = ctx->defaultBackendFormat(colorType, GrRenderable::kYes);
            int supportedSampleCount =
                    ctx->priv().caps()->getRenderTargetSampleCount(sampleCount, format);
            if (sampleCount != supportedSampleCount) {
                SkDebugf("Configuration '%s' sample count %d is not a supported sample count.\n",
                         config->getTag().c_str(),
                         sampleCount);
                return std::nullopt;
            }
#else
            if (sampleCount > 1) {
                SkDebugf("Configuration '%s' sample count %d is not a supported sample count.\n",
                         config->getTag().c_str(),
                         sampleCount);
                return std::nullopt;
            }
#endif
        } else {
            SkDebugf("No context was available matching config '%s'.\n", config->getTag().c_str());
            return std::nullopt;
        }
 
        return Config{gpuConfig->getTag(),
                      Benchmark::Backend::kGraphite,
                      colorType,
                      kPremul_SkAlphaType,
                      config->refColorSpace(),
                      sampleCount,
                      graphiteCtxType,
                      kBogusContextOverrides,
                      0};
    }
#endif
 
#define CPU_CONFIG(name, backend, color, alpha)                                         \
    if (config->getBackend().equals(name)) {                                            \
        if (!FLAGS_cpu) {                                                               \
            SkDebugf("Skipping config '%s' as requested.\n", config->getTag().c_str()); \
            return std::nullopt;                                                      \
        }                                                                               \
        return Config{SkString(name),                                                   \
                      Benchmark::backend,                                               \
                      color,                                                            \
                      alpha,                                                            \
                      config->refColorSpace(),                                          \
                      0,                                                                \
                      kBogusContextType,                                                \
                      kBogusContextOverrides,                                           \
                      0};                                                               \
    }
 
    CPU_CONFIG("nonrendering", Backend::kNonRendering, kUnknown_SkColorType, kUnpremul_SkAlphaType)
 
    CPU_CONFIG("a8",    Backend::kRaster,    kAlpha_8_SkColorType, kPremul_SkAlphaType)
    CPU_CONFIG("565",   Backend::kRaster,    kRGB_565_SkColorType, kOpaque_SkAlphaType)
    CPU_CONFIG("8888",  Backend::kRaster,        kN32_SkColorType, kPremul_SkAlphaType)
    CPU_CONFIG("rgba",  Backend::kRaster,  kRGBA_8888_SkColorType, kPremul_SkAlphaType)
    CPU_CONFIG("bgra",  Backend::kRaster,  kBGRA_8888_SkColorType, kPremul_SkAlphaType)
    CPU_CONFIG("f16",   Backend::kRaster,   kRGBA_F16_SkColorType, kPremul_SkAlphaType)
    CPU_CONFIG("srgba", Backend::kRaster, kSRGBA_8888_SkColorType, kPremul_SkAlphaType)
 
#undef CPU_CONFIG
 
    SkDebugf("Unknown config '%s'.\n", config->getTag().c_str());
    return std::nullopt;
}

create_configs()

void create_configs

(

TArray< Config > *

configs

)

Definition at line 689 of file nanobench.cpp.

                                             {
    SkCommandLineConfigArray array;
    ParseConfigs(FLAGS_config, &array);
    for (int i = 0; i < array.size(); ++i) {
        if (std::optional<Config> config = create_config(array[i].get())) {
            configs->push_back(*config);
        }
    }
 
    // If no just default configs were requested, then we're okay.
    if (array.size() == 0 || FLAGS_config.size() == 0 ||
        // Otherwise, make sure that all specified configs have been created.
        array.size() == configs->size()) {
        return;
    }
    exit(1);
}

DEFINE_bool() [1/16]

static DEFINE_bool ( bbh  , true  , "Build a BBH for SKPs?"    )

static

DEFINE_bool() [2/16]

static DEFINE_bool ( cpu  , true  , "Run CPU-bound work?"    )

static

DEFINE_bool() [3/16]

static DEFINE_bool ( csv  , false  , "Print status in CSV format"    )

static

DEFINE_bool() [4/16]

static DEFINE_bool ( dmsaaStatsDump  , false  , "Dump DMSAA stats after each benchmark to json"    )

static

DEFINE_bool() [5/16]

static DEFINE_bool ( dryRun  , false  , "just print the tests that would be  run, without actually running them."    )

static

DEFINE_bool() [6/16]

static DEFINE_bool ( forceRasterPipeline  , false  , "sets gSkForceRasterPipelineBlitter"    )

static

DEFINE_bool() [7/16]

static DEFINE_bool ( forceRasterPipelineHP  , false  , "sets gSkForceRasterPipelineBlitter and gForceHighPrecisionRasterPipeline"    )

static

DEFINE_bool() [8/16]

static DEFINE_bool ( gpu  , true  , "Run GPU-bound work?"    )

static

DEFINE_bool() [9/16]

static DEFINE_bool ( gpuStats  , false  , "Print GPU stats after each gpu benchmark?"    )

static

DEFINE_bool() [10/16]

static DEFINE_bool ( gpuStatsDump  , false  , "Dump GPU stats after each benchmark to json"    )

static

DEFINE_bool() [11/16]

static DEFINE_bool ( keepAlive  , false  , "Print a message every so often so that we don't time out"    )

static

DEFINE_bool() [12/16]

static DEFINE_bool ( loopSKP  , true  , "Loop SKPs like we do for micro benches?"    )

static

DEFINE_bool() [13/16]

static DEFINE_bool ( purgeBetweenBenches  , false  , "Call SkGraphics::PurgeAllCaches() between each benchmark?"    )

static

DEFINE_bool() [14/16]

static DEFINE_bool ( runtimeCPUDetection  , true  , "Skip runtime CPU detection and optimization"    )

static

DEFINE_bool() [15/16]

static DEFINE_bool ( simpleCodec  , false  , "Runs of a subset of the codec  tests, always  N32, Premul or Opaque"    )

static

DEFINE_bool() [16/16]

static DEFINE_bool ( splitPerfettoTracesByBenchmark  , true  , "Create separate perfetto trace files for each benchmark?\n" "Will only take effect if perfetto tracing is enabled. See --trace."    )

static

DEFINE_bool2() [1/3]

static DEFINE_bool2 ( pre_log  , p  , false  , "Log before running each test. May be incomprehensible when threading"    )

static

DEFINE_bool2() [2/3]

static DEFINE_bool2 ( quiet  , q  , false  , "if  true, don 't print status updates."    )

static

DEFINE_bool2() [3/3]

static DEFINE_bool2 ( verbose  , v  , false  , "enable verbose output from the test driver."    )

static

DEFINE_double() [1/2]

static DEFINE_double ( gpuMs  , 5  , "Target bench time in millseconds for GPU."    )

static

DEFINE_double() [2/2]

static DEFINE_double ( overheadGoal  , 0.  0001, "Loop until timer overhead is at most this fraction of our measurments."    )

static

DEFINE_int() [1/8]

static DEFINE_int ( flushEvery  , 10  , "Flush --outResultsFile every Nth run."    )

static

DEFINE_int() [2/8]

static DEFINE_int ( gpuFrameLag  , 5  , "If  unknown, estimated maximum number of frames GPU allows to lag."    )

static

DEFINE_int() [3/8]

static DEFINE_int ( loops  , kAutoTuneLoops  , loops_help_txt().c_str()    )

static

DEFINE_int() [4/8]

static DEFINE_int ( maxCalibrationAttempts  , 3  , "Try up to this many times to guess loops for a  bench, or skip the bench."    )

static

DEFINE_int() [5/8]

static DEFINE_int ( maxLoops  , 1000000  , "Never run a bench more times than this."    )

static

DEFINE_int() [6/8]

static DEFINE_int ( ms  , 0  , "  If, 0  , run each bench for this many ms instead of obeying --samples."    )

static

DEFINE_int() [7/8]

static DEFINE_int ( overheadLoops  , 100000  , "Loops to estimate timer overhead."    )

static

DEFINE_int() [8/8]

static DEFINE_int ( samples  , 10  , "Number of samples to measure for each bench."    )

static

DEFINE_int_2()

static DEFINE_int_2 ( threads  , j  , -  1, "Run threadsafe tests on a threadpool with this many extra  threads, " "defaulting to one extra thread per core."    )

static

DEFINE_string() [1/13]

static DEFINE_string ( benchType  , ""  , "Apply usual --match rules to bench type:  micro, recording  , " "  piping, playback  , skcodec  , etc."    )

static

DEFINE_string() [2/13]

static DEFINE_string ( clip  , "  0, 0  , 1000  , 1000"  , "Clip for SKPs."    )

static

DEFINE_string() [3/13]

static DEFINE_string ( images  , ""  , "List of images and/or directories to decode. A directory with no images" " is treated as a fatal error."    )

static

DEFINE_string() [4/13]

static DEFINE_string ( key  , ""  , "Space-separated key/value pairs to add to JSON identifying this builder."    )

static

DEFINE_string() [5/13]

static DEFINE_string ( mskps  , "mskps"  , "Directory to read mskps from."    )

static

DEFINE_string() [6/13]

static DEFINE_string ( outResultsFile  , ""  , "If  given, write results here as JSON."    )

static

DEFINE_string() [7/13]

static DEFINE_string ( properties  , ""  , "Space-separated key/value pairs to add to JSON identifying this run."    )

static

DEFINE_string() [8/13]

static DEFINE_string ( scales  , "1.0"  , "Space-separated scales for SKPs."    )

static

DEFINE_string() [9/13]

static DEFINE_string ( skps  , "skps"  , "Directory to read skps from."    )

static

DEFINE_string() [10/13]

static DEFINE_string ( sourceType  , ""  , "Apply usual --match rules to source type:  bench, gm  , skp  , image  , etc."    )

static

DEFINE_string() [11/13]

static DEFINE_string ( svgs  , ""  , "Directory to read SVGs  from, or a single SVG file."    )

static

DEFINE_string() [12/13]

static DEFINE_string ( texttraces  , ""  , "Directory to read TextBlobTrace files from."    )

static

DEFINE_string() [13/13]

static DEFINE_string ( zoom  , "1.  0, 0"  , "Comma-separated  zoomMax, zoomPeriodMs factors for a periodic SKP zoom " "function that ping-pongs between 1.0 and zoomMax."    )

static

DEFINE_string2() [1/2]

static DEFINE_string2 ( match  , m  , nullptr  , "substring of name to run.\n" "Multiple matches may be separated by spaces.\n" "~ causes a matching name to always be skipped\n" "^ requires the start of the name to match\n" "$ requires the end of the name to match\n" "^ and $ requires an exact match\n" "If a name does not match any list  entry[~][^][$][...], \n" "it is skipped unless some list entry starts with ~"    )

static

DEFINE_string2() [2/2]

static DEFINE_string2 ( writePath  , w  , ""  , "If  set, write bitmaps here as .pngs."    )

static

detect_forever_loops()

static int detect_forever_loops ( int  loops )

static

Definition at line 420 of file nanobench.cpp.

                                           {
    // look for a magic run-forever value
    if (loops < 0) {
        loops = SK_MaxS32;
    }
    return loops;
}

estimate_timer_overhead()

static double estimate_timer_overhead ( )

static

Definition at line 411 of file nanobench.cpp.

                                        {
    double overhead = 0;
    for (int i = 0; i < FLAGS_overheadLoops; i++) {
        double start = now_ms();
        overhead += now_ms() - start;
    }
    return overhead / FLAGS_overheadLoops;
}

humanize()

static SkString humanize ( double  ms )

static

Definition at line 216 of file nanobench.cpp.

                                    {
    if (FLAGS_verbose) return SkStringPrintf("%" PRIu64, (uint64_t)(ms*1e6));
    return HumanizeMs(ms);
}

is_enabled()

static Target * is_enabled ( Benchmark *  bench, const Config &  config  )

static

Definition at line 714 of file nanobench.cpp.

                                                                  {
    if (!bench->isSuitableFor(config.backend)) {
        return nullptr;
    }
 
    SkImageInfo info =
            SkImageInfo::Make(bench->getSize(), config.color, config.alpha, config.colorSpace);
 
    Target* target = nullptr;
 
    switch (config.backend) {
    case Benchmark::Backend::kGanesh:
        target = new GPUTarget(config);
        break;
#if defined(SK_GRAPHITE)
    case Benchmark::Backend::kGraphite:
        target = new GraphiteTarget(config);
        break;
#endif
    default:
        target = new Target(config);
        break;
    }
 
    if (!target->init(info, bench)) {
        delete target;
        return nullptr;
    }
    return target;
}

loops_help_txt()

static SkString loops_help_txt ( )

static

Definition at line 111 of file nanobench.cpp.

                                 {
    SkString help;
    help.printf("Number of times to run each bench. Set this to %d to auto-"
                "tune for each bench. Timings are only reported when auto-tuning.",
                kAutoTuneLoops);
    return help;
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 1349 of file nanobench.cpp.

                                {
    CommandLineFlags::Parse(argc, argv);
 
    initializeEventTracingForTools();
 
#if defined(SK_BUILD_FOR_IOS)
    cd_Documents();
#endif
    SetupCrashHandler();
    if (FLAGS_runtimeCPUDetection) {
        SkGraphics::Init();
    }
 
    // Our benchmarks only currently decode .png or .jpg files
    SkCodecs::Register(SkPngDecoder::Decoder());
    SkCodecs::Register(SkJpegDecoder::Decoder());
 
    SkTaskGroup::Enabler enabled(FLAGS_threads);
 
    CommonFlags::SetCtxOptions(&grContextOpts);
 
    NanobenchShaderErrorHandler errorHandler;
    grContextOpts.fShaderErrorHandler = &errorHandler;
 
    if (kAutoTuneLoops != FLAGS_loops) {
        FLAGS_samples     = 1;
        FLAGS_gpuFrameLag = 0;
    }
 
    if (!FLAGS_writePath.isEmpty()) {
        SkDebugf("Writing files to %s.\n", FLAGS_writePath[0]);
        if (!sk_mkdir(FLAGS_writePath[0])) {
            SkDebugf("Could not create %s. Files won't be written.\n", FLAGS_writePath[0]);
            FLAGS_writePath.set(0, nullptr);
        }
    }
 
    std::unique_ptr<SkWStream> logStream(new SkNullWStream);
    if (!FLAGS_outResultsFile.isEmpty()) {
#if defined(SK_RELEASE)
        logStream.reset(new SkFILEWStream(FLAGS_outResultsFile[0]));
#else
        SkDebugf("I'm ignoring --outResultsFile because this is a Debug build.");
        return 1;
#endif
    }
    NanoJSONResultsWriter log(logStream.get(), SkJSONWriter::Mode::kPretty);
    log.beginObject(); // root
 
    if (1 == FLAGS_properties.size() % 2) {
        SkDebugf("ERROR: --properties must be passed with an even number of arguments.\n");
        return 1;
    }
    for (int i = 1; i < FLAGS_properties.size(); i += 2) {
        log.appendCString(FLAGS_properties[i-1], FLAGS_properties[i]);
    }
 
    if (1 == FLAGS_key.size() % 2) {
        SkDebugf("ERROR: --key must be passed with an even number of arguments.\n");
        return 1;
    }
    if (FLAGS_key.size()) {
        log.beginObject("key");
        for (int i = 1; i < FLAGS_key.size(); i += 2) {
            log.appendCString(FLAGS_key[i - 1], FLAGS_key[i]);
        }
        log.endObject(); // key
    }
 
    const double overhead = estimate_timer_overhead();
    if (!FLAGS_quiet && !FLAGS_csv) {
        SkDebugf("Timer overhead: %s\n", HUMANIZE(overhead));
    }
 
    TArray<double> samples;
 
    if (kAutoTuneLoops != FLAGS_loops) {
        SkDebugf("Fixed number of loops; times would only be misleading so we won't print them.\n");
    } else if (FLAGS_quiet) {
        SkDebugf("! -> high variance, ? -> moderate variance\n");
        SkDebugf("    micros   \tbench\n");
    } else if (FLAGS_csv) {
        SkDebugf("min,median,mean,max,stddev,config,bench\n");
    } else if (FLAGS_ms) {
        SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\tsamples\tconfig\tbench\n");
    } else {
        SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
                 FLAGS_samples, "samples");
    }
 
    GrRecordingContextPriv::DMSAAStats combinedDMSAAStats;
 
    TArray<Config> configs;
    create_configs(&configs);
 
    if (FLAGS_keepAlive) {
        start_keepalive();
    }
 
    gSkForceRasterPipelineBlitter     = FLAGS_forceRasterPipelineHP || FLAGS_forceRasterPipeline;
    gForceHighPrecisionRasterPipeline = FLAGS_forceRasterPipelineHP;
 
    // The SkSL memory benchmark must run before any GPU painting occurs. SkSL allocates memory for
    // its modules the first time they are accessed, and this test is trying to measure the size of
    // those allocations. If a paint has already occurred, some modules will have already been
    // loaded, so we won't be able to capture a delta for them.
    log.beginObject("results");
    RunSkSLModuleBenchmarks(&log);
 
    int runs = 0;
    BenchmarkStream benchStream;
    AutoreleasePool pool;
    while (Benchmark* b = benchStream.next()) {
        std::unique_ptr<Benchmark> bench(b);
        if (CommandLineFlags::ShouldSkip(FLAGS_match, bench->getUniqueName())) {
            continue;
        }
 
        if (!configs.empty()) {
            log.beginBench(
                    bench->getUniqueName(), bench->getSize().width(), bench->getSize().height());
            bench->delayedSetup();
        }
        for (int i = 0; i < configs.size(); ++i) {
            Target* target = is_enabled(b, configs[i]);
            if (!target) {
                continue;
            }
 
            // During HWUI output this canvas may be nullptr.
            SkCanvas* canvas = target->getCanvas();
            const char* config = target->config.name.c_str();
 
            if (FLAGS_pre_log || FLAGS_dryRun) {
                SkDebugf("Running %s\t%s\n"
                         , bench->getUniqueName()
                         , config);
                if (FLAGS_dryRun) {
                    continue;
                }
            }
 
            if (FLAGS_purgeBetweenBenches) {
                SkGraphics::PurgeAllCaches();
            }
 
            if (FLAGS_splitPerfettoTracesByBenchmark) {
                TRACE_EVENT_API_NEW_TRACE_SECTION(TRACE_STR_COPY(bench->getUniqueName()));
            }
            TRACE_EVENT2("skia", "Benchmark", "name", TRACE_STR_COPY(bench->getUniqueName()),
                                              "config", TRACE_STR_COPY(config));
 
            target->setup();
            bench->perCanvasPreDraw(canvas);
 
            int maxFrameLag;
            int loops = target->needsFrameTiming(&maxFrameLag)
                ? setup_gpu_bench(target, bench.get(), maxFrameLag)
                : setup_cpu_bench(overhead, target, bench.get());
 
            if (kFailedLoops == loops) {
                // Can't be timed.  A warning note has already been printed.
                cleanup_run(target);
                continue;
            }
 
            if (runs == 0 && FLAGS_ms < 1000) {
                // Run the first bench for 1000ms to warm up the nanobench if FLAGS_ms < 1000.
                // Otherwise, the first few benches' measurements will be inaccurate.
                auto stop = now_ms() + 1000;
                do {
                    time(loops, bench.get(), target);
                    pool.drain();
                } while (now_ms() < stop);
            }
 
            if (FLAGS_ms) {
                samples.clear();
                auto stop = now_ms() + FLAGS_ms;
                do {
                    samples.push_back(time(loops, bench.get(), target) / loops);
                    pool.drain();
                } while (now_ms() < stop);
            } else {
                samples.reset(FLAGS_samples);
                for (int s = 0; s < FLAGS_samples; s++) {
                    samples[s] = time(loops, bench.get(), target) / loops;
                    pool.drain();
                }
            }
 
            // Scale each result to the benchmark's own units, time/unit.
            for (double& sample : samples) {
                sample *= (1.0 / bench->getUnits());
            }
 
            TArray<SkString> keys;
            TArray<double> values;
            if (configs[i].backend == Benchmark::Backend::kGanesh) {
                if (FLAGS_gpuStatsDump) {
                    // TODO cache stats
                    bench->getGpuStats(canvas, &keys, &values);
                }
                if (FLAGS_dmsaaStatsDump && bench->getDMSAAStats(canvas->recordingContext())) {
                    const auto& dmsaaStats = canvas->recordingContext()->priv().dmsaaStats();
                    dmsaaStats.dumpKeyValuePairs(&keys, &values);
                    dmsaaStats.dump();
                    combinedDMSAAStats.merge(dmsaaStats);
                }
            }
 
            bench->perCanvasPostDraw(canvas);
 
            if (Benchmark::Backend::kNonRendering != target->config.backend &&
                !FLAGS_writePath.isEmpty() && FLAGS_writePath[0]) {
                SkString pngFilename = SkOSPath::Join(FLAGS_writePath[0], config);
                pngFilename = SkOSPath::Join(pngFilename.c_str(), bench->getUniqueName());
                pngFilename.append(".png");
                write_canvas_png(target, pngFilename);
            }
 
            // Building stats.plot often shows up in profiles,
            // so skip building it when we're not going to print it anyway.
            const bool want_plot = !FLAGS_quiet && !FLAGS_ms;
 
            Stats stats(samples, want_plot);
            log.beginObject(config);
 
            log.beginObject("options");
            log.appendCString("name", bench->getName());
            benchStream.fillCurrentOptions(log);
            log.endObject(); // options
 
            // Metrics
            log.appendMetric("min_ms", stats.min);
            log.appendMetric("min_ratio", sk_ieee_double_divide(stats.median, stats.min));
            log.beginArray("samples");
            for (double sample : samples) {
                log.appendDoubleDigits(sample, 16);
            }
            log.endArray(); // samples
            benchStream.fillCurrentMetrics(log);
            if (!keys.empty()) {
                // dump to json, only SKPBench currently returns valid keys / values
                SkASSERT(keys.size() == values.size());
                for (int j = 0; j < keys.size(); j++) {
                    log.appendMetric(keys[j].c_str(), values[j]);
                }
            }
 
            log.endObject(); // config
 
            if (runs++ % FLAGS_flushEvery == 0) {
                log.flush();
            }
 
            if (kAutoTuneLoops != FLAGS_loops) {
                if (configs.size() == 1) {
                    config = ""; // Only print the config if we run the same bench on more than one.
                }
                SkDebugf("%4d/%-4dMB\t%s\t%s "
                         , sk_tools::getCurrResidentSetSizeMB()
                         , sk_tools::getMaxResidentSetSizeMB()
                         , bench->getUniqueName()
                         , config);
                SkDebugf("\n");
            } else if (FLAGS_quiet) {
                const char* mark = " ";
                const double stddev_percent =
                    sk_ieee_double_divide(100 * sqrt(stats.var), stats.mean);
                if (stddev_percent >  5) mark = "?";
                if (stddev_percent > 10) mark = "!";
 
                SkDebugf("%10.2f %s\t%s\t%s\n",
                         stats.median*1e3, mark, bench->getUniqueName(), config);
            } else if (FLAGS_csv) {
                const double stddev_percent =
                    sk_ieee_double_divide(100 * sqrt(stats.var), stats.mean);
                SkDebugf("%g,%g,%g,%g,%g,%s,%s\n"
                         , stats.min
                         , stats.median
                         , stats.mean
                         , stats.max
                         , stddev_percent
                         , config
                         , bench->getUniqueName()
                         );
            } else {
                const double stddev_percent =
                    sk_ieee_double_divide(100 * sqrt(stats.var), stats.mean);
                SkDebugf("%4d/%-4dMB\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n"
                        , sk_tools::getCurrResidentSetSizeMB()
                        , sk_tools::getMaxResidentSetSizeMB()
                        , loops
                        , HUMANIZE(stats.min)
                        , HUMANIZE(stats.median)
                        , HUMANIZE(stats.mean)
                        , HUMANIZE(stats.max)
                        , stddev_percent
                        , FLAGS_ms ? to_string(samples.size()).c_str() : stats.plot.c_str()
                        , config
                        , bench->getUniqueName()
                        );
            }
 
            if (FLAGS_gpuStats && Benchmark::Backend::kGanesh == configs[i].backend) {
                target->dumpStats();
            }
 
            if (FLAGS_verbose) {
                SkDebugf("Samples:  ");
                for (int j = 0; j < samples.size(); j++) {
                    SkDebugf("%s  ", HUMANIZE(samples[j]));
                }
                SkDebugf("%s\n", bench->getUniqueName());
            }
            cleanup_run(target);
            pool.drain();
        }
        if (!configs.empty()) {
            log.endBench();
        }
    }
 
    if (FLAGS_dmsaaStatsDump) {
        SkDebugf("<<Total Combined DMSAA Stats>>\n");
        combinedDMSAAStats.dump();
    }
 
    SkGraphics::PurgeAllCaches();
 
    log.beginBench("memory_usage", 0, 0);
    log.beginObject("meta"); // config
    log.appendS32("max_rss_mb", sk_tools::getMaxResidentSetSizeMB());
    log.endObject(); // config
    log.endBench();
 
    log.endObject(); // results
    log.endObject(); // root
    log.flush();
 
    return 0;
}

now_ms()

static double now_ms ( )

static

Definition at line 214 of file nanobench.cpp.

{ return SkTime::GetNSecs() * 1e-6; }

setup_cpu_bench()

static int setup_cpu_bench ( const double  overhead, Target *  target, Benchmark *  bench  )

static

Definition at line 475 of file nanobench.cpp.

                                                                                    {
    // First figure out approximately how many loops of bench it takes to make overhead negligible.
    double bench_plus_overhead = 0.0;
    int round = 0;
    int loops = bench->shouldLoop() ? FLAGS_loops : 1;
    if (kAutoTuneLoops == loops) {
        while (bench_plus_overhead < overhead) {
            if (round++ == FLAGS_maxCalibrationAttempts) {
                SkDebugf("WARNING: Can't estimate loops for %s (%s vs. %s); skipping.\n",
                         bench->getUniqueName(), HUMANIZE(bench_plus_overhead), HUMANIZE(overhead));
                return kFailedLoops;
            }
            bench_plus_overhead = time(1, bench, target);
        }
    }
 
    // Later we'll just start and stop the timer once but loop N times.
    // We'll pick N to make timer overhead negligible:
    //
    //          overhead
    //  -------------------------  < FLAGS_overheadGoal
    //  overhead + N * Bench Time
    //
    // where bench_plus_overhead ~=~ overhead + Bench Time.
    //
    // Doing some math, we get:
    //
    //  (overhead / FLAGS_overheadGoal) - overhead
    //  ------------------------------------------  < N
    //       bench_plus_overhead - overhead)
    //
    // Luckily, this also works well in practice. :)
    if (kAutoTuneLoops == loops) {
        const double numer = overhead / FLAGS_overheadGoal - overhead;
        const double denom = bench_plus_overhead - overhead;
        loops = (int)ceil(numer / denom);
        loops = clamp_loops(loops);
    } else {
        loops = detect_forever_loops(loops);
    }
 
    return loops;
}

setup_gpu_bench()

static int setup_gpu_bench ( Target *  target, Benchmark *  bench, int  maxGpuFrameLag  )

static

Definition at line 519 of file nanobench.cpp.

                                                                                 {
    // First, figure out how many loops it'll take to get a frame up to FLAGS_gpuMs.
    int loops = bench->shouldLoop() ? FLAGS_loops : 1;
    if (kAutoTuneLoops == loops) {
        loops = 1;
        double elapsed = 0;
        do {
            if (1<<30 == loops) {
                // We're about to wrap.  Something's wrong with the bench.
                loops = 0;
                break;
            }
            loops *= 2;
            // If the GPU lets frames lag at all, we need to make sure we're timing
            // _this_ round, not still timing last round.
            for (int i = 0; i < maxGpuFrameLag; i++) {
                elapsed = time(loops, bench, target);
            }
        } while (elapsed < FLAGS_gpuMs);
 
        // We've overshot at least a little.  Scale back linearly.
        loops = (int)ceil(loops * FLAGS_gpuMs / elapsed);
        loops = clamp_loops(loops);
 
        // Make sure we're not still timing our calibration.
        target->submitWorkAndSyncCPU();
    } else {
        loops = detect_forever_loops(loops);
    }
    // Pretty much the same deal as the calibration: do some warmup to make
    // sure we're timing steady-state pipelined frames.
    for (int i = 0; i < maxGpuFrameLag; i++) {
        time(loops, bench, target);
    }
 
    return loops;
}

start_keepalive()

static void start_keepalive ( )

static

Definition at line 1324 of file nanobench.cpp.

                              {
    static std::thread* intentionallyLeaked = new std::thread([]{
        for (;;) {
            static const int kSec = 1200;
        #if defined(SK_BUILD_FOR_WIN)
            Sleep(kSec * 1000);
        #else
            sleep(kSec);
        #endif
            SkDebugf("\nBenchmarks still running...\n");
        }
    });
    (void)intentionallyLeaked;
    SK_INTENTIONALLY_LEAKED(intentionallyLeaked);
}

time()

static double time ( int  loops, Benchmark *  bench, Target *  target  )

static

Definition at line 394 of file nanobench.cpp.

                                                                {
    SkCanvas* canvas = target->getCanvas();
    if (canvas) {
        canvas->clear(SK_ColorWHITE);
    }
    bench->preDraw(canvas);
    double start = now_ms();
    canvas = target->beginTiming(canvas);
 
    bench->draw(loops, canvas);
 
    target->endTiming();
    double elapsed = now_ms() - start;
    bench->postDraw(canvas);
    return elapsed;
}

to_string()

static SkString to_string ( int  n )

static

Definition at line 119 of file nanobench.cpp.

                                 {
    SkString str;
    str.appendS32(n);
    return str;
}

write_canvas_png()

static bool write_canvas_png ( Target *  target, const SkString &  filename  )

static

Definition at line 441 of file nanobench.cpp.

                                                                       {
 
    if (filename.isEmpty()) {
        return false;
    }
    if (target->getCanvas() &&
        kUnknown_SkColorType == target->getCanvas()->imageInfo().colorType()) {
        return false;
    }
 
    SkBitmap bmp;
 
    if (!target->capturePixels(&bmp)) {
        return false;
    }
 
    SkString dir = SkOSPath::Dirname(filename.c_str());
    if (!sk_mkdir(dir.c_str())) {
        SkDebugf("Can't make dir %s.\n", dir.c_str());
        return false;
    }
    SkFILEWStream stream(filename.c_str());
    if (!stream.isValid()) {
        SkDebugf("Can't write %s.\n", filename.c_str());
        return false;
    }
    if (!SkPngEncoder::Encode(&stream, bmp.pixmap(), {})) {
        SkDebugf("Can't encode a PNG.\n");
        return false;
    }
    return true;
}

Variable Documentation

gForceHighPrecisionRasterPipeline

bool gForceHighPrecisionRasterPipeline

extern

Definition at line 29 of file SkRasterPipeline.cpp.

grContextOpts

GrContextOptions grContextOpts

Definition at line 107 of file nanobench.cpp.

gSkForceRasterPipelineBlitter

bool gSkForceRasterPipelineBlitter

extern

Definition at line 44 of file SkBlitter.cpp.

{false};

kAutoTuneLoops

const int kAutoTuneLoops = 0

static

Definition at line 109 of file nanobench.cpp.

kFailedLoops

int kFailedLoops = -2

static

Definition at line 474 of file nanobench.cpp.