From: José Fonseca Date: Wed, 14 Nov 2012 07:23:22 +0000 (+0000) Subject: Merge branch 'modules' X-Git-Url: https://git.cworth.org/git?a=commitdiff_plain;h=b35ae0df401ff22e3b2dc9b6bfacf1e23baebde0;hp=c3049663d90a7b1d57e9b0bec8a77a6e26fa0772;p=apitrace Merge branch 'modules' --- diff --git a/CMakeLists.txt b/CMakeLists.txt index 83490d5..7f75d07 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -326,6 +326,7 @@ add_library (common STATIC common/image_bmp.cpp common/image_pnm.cpp common/image_png.cpp + common/trace_option.cpp common/${os} ) diff --git a/README.markdown b/README.markdown index ab14530..af54b7f 100644 --- a/README.markdown +++ b/README.markdown @@ -51,7 +51,7 @@ Replay an OpenGL trace with glretrace application.trace -Pass the `-sb` option to use a single buffered visual. Pass `--help` to +Pass the `--sb` option to use a single buffered visual. Pass `--help` to `glretrace` for more options. EGL traces must be replayed with `eglretrace` instead of `glretrace`. @@ -341,11 +341,11 @@ Profiling a trace You can perform gpu and cpu profiling with the command line options: - * `-pgpu` record gpu times for frames and draw calls. + * `--pgpu` record gpu times for frames and draw calls. - * `-pcpu` record cpu times for frames and draw calls. + * `--pcpu` record cpu times for frames and draw calls. - * `-ppd` record pixels drawn for each draw call. + * `--ppd` record pixels drawn for each draw call. The results from this can then be read by hand or analysed with a script. @@ -354,7 +354,7 @@ table which displays profiling results per shader. For example, to record all profiling data and utilise the per shader script: - ./glretrace -pgpu -pcpu -ppd foo.trace | ./scripts/profileshader.py + ./glretrace --pgpu --pcpu --ppd foo.trace | ./scripts/profileshader.py Advanced usage for OpenGL implementors diff --git a/cli/cli_dump.cpp b/cli/cli_dump.cpp index f52b83c..f959568 100644 --- a/cli/cli_dump.cpp +++ b/cli/cli_dump.cpp @@ -38,6 +38,7 @@ #include "trace_parser.hpp" #include "trace_dump.hpp" #include "trace_callset.hpp" +#include "trace_option.hpp" enum ColorOption { @@ -98,25 +99,6 @@ longOptions[] = { {0, 0, 0, 0} }; -static bool -boolOption(const char *option, bool default_ = true) { - if (!option) { - return default_; - } - if (strcmp(option, "0") == 0 || - strcmp(option, "no") == 0 || - strcmp(option, "false") == 0) { - return false; - } - if (strcmp(option, "0") == 0 || - strcmp(option, "yes") == 0 || - strcmp(option, "true") == 0) { - return true; - } - std::cerr << "error: unexpected bool " << option << "\n"; - return default_; -} - static int command(int argc, char *argv[]) { @@ -149,17 +131,17 @@ command(int argc, char *argv[]) } break; case THREAD_IDS_OPT: - dumpThreadIds = boolOption(optarg); + dumpThreadIds = trace::boolOption(optarg); break; case CALL_NOS_OPT: - if (boolOption(optarg)) { + if (trace::boolOption(optarg)) { dumpFlags &= ~trace::DUMP_FLAG_NO_CALL_NO; } else { dumpFlags |= trace::DUMP_FLAG_NO_CALL_NO; } break; case ARG_NAMES_OPT: - if (boolOption(optarg)) { + if (trace::boolOption(optarg)) { dumpFlags &= ~trace::DUMP_FLAG_NO_ARG_NAMES; } else { dumpFlags |= trace::DUMP_FLAG_NO_ARG_NAMES; diff --git a/common/trace_option.cpp b/common/trace_option.cpp new file mode 100644 index 0000000..5c4563f --- /dev/null +++ b/common/trace_option.cpp @@ -0,0 +1,53 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#include "trace_option.hpp" + +#include +#include + +namespace trace { + +bool +boolOption(const char *option, bool default_) { + if (!option) { + return default_; + } + if (strcmp(option, "0") == 0 || + strcmp(option, "no") == 0 || + strcmp(option, "false") == 0) { + return false; + } + if (strcmp(option, "0") == 0 || + strcmp(option, "yes") == 0 || + strcmp(option, "true") == 0) { + return true; + } + std::cerr << "error: unexpected bool " << option << "\n"; + return default_; +} + +} /* namespace trace */ diff --git a/common/trace_option.hpp b/common/trace_option.hpp new file mode 100644 index 0000000..e22a422 --- /dev/null +++ b/common/trace_option.hpp @@ -0,0 +1,37 @@ +/************************************************************************** + * + * Copyright 2011 Jose Fonseca + * Copyright 2010 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#ifndef _TRACE_OPTION_HPP_ +#define _TRACE_OPTION_HPP_ + +namespace trace { + +bool +boolOption(const char *option, bool default_ = true); + +} /* namespace trace */ + +#endif /* _TRACE_CALLSET_HPP_ */ diff --git a/gui/retracer.cpp b/gui/retracer.cpp index 6d743f7..8a766fa 100644 --- a/gui/retracer.cpp +++ b/gui/retracer.cpp @@ -294,21 +294,21 @@ void Retracer::run() arguments << QLatin1String("-"); // emit to stdout } else if (isProfiling()) { if (m_profileGpu) { - arguments << QLatin1String("-pgpu"); + arguments << QLatin1String("--pgpu"); } if (m_profileCpu) { - arguments << QLatin1String("-pcpu"); + arguments << QLatin1String("--pcpu"); } if (m_profilePixels) { - arguments << QLatin1String("-ppd"); + arguments << QLatin1String("--ppd"); } } else { if (m_doubleBuffered) { - arguments << QLatin1String("-db"); + arguments << QLatin1String("--db"); } else { - arguments << QLatin1String("-sb"); + arguments << QLatin1String("--sb"); } if (m_benchmarking) { diff --git a/retrace/retrace_main.cpp b/retrace/retrace_main.cpp index 7e171e6..e3e74f8 100644 --- a/retrace/retrace_main.cpp +++ b/retrace/retrace_main.cpp @@ -25,7 +25,9 @@ #include +#include // for CHAR_MAX #include +#include #include "os_binary.hpp" #include "os_time.hpp" @@ -490,69 +492,101 @@ usage(const char *argv0) { "Usage: " << argv0 << " [OPTION] TRACE [...]\n" "Replay TRACE.\n" "\n" - " -b benchmark mode (no error checking or warning messages)\n" - " -pcpu cpu profiling (cpu times per call)\n" - " -pgpu gpu profiling (gpu times per draw call)\n" - " -ppd pixels drawn profiling (pixels drawn per draw call)\n" - " -c PREFIX compare against snapshots\n" - " -C CALLSET calls to compare (default is every frame)\n" - " -core use core profile\n" - " -db use a double buffer visual (default)\n" - " -sb use a single buffer visual\n" - " -s PREFIX take snapshots; `-` for PNM stdout output\n" - " -S CALLSET calls to snapshot (default is every frame)\n" - " -v increase output verbosity\n" - " -D CALLNO dump state at specific call no\n" - " -w waitOnFinish on final frame\n"; + " -b, --benchmark benchmark mode (no error checking or warning messages)\n" + " --pcpu cpu profiling (cpu times per call)\n" + " --pgpu gpu profiling (gpu times per draw call)\n" + " --ppd pixels drawn profiling (pixels drawn per draw call)\n" + " -c, --compare=PREFIX compare against snapshots with given PREFIX\n" + " -C, --calls=CALLSET calls to compare (default is every frame)\n" + " --core use core profile\n" + " --db use a double buffer visual (default)\n" + " --sb use a single buffer visual\n" + " -s, --snapshot-prefix=PREFIX take snapshots; `-` for PNM stdout output\n" + " -S, --snapshot=CALLSET calls to snapshot (default is every frame)\n" + " -v, --verbose increase output verbosity\n" + " -D, --dump-state=CALL dump state at specific call no\n" + " -w, --wait waitOnFinish on final frame\n"; } +enum { + CORE_OPT = CHAR_MAX + 1, + DB_OPT, + PCPU_OPT, + PGPU_OPT, + PPD_OPT, + SB_OPT, +}; + +const static char * +shortOptions = "bc:C:D:hs:S:vw"; + +const static struct option +longOptions[] = { + {"benchmark", no_argument, 0, 'b'}, + {"calls", required_argument, 0, 'C'}, + {"compare", required_argument, 0, 'c'}, + {"core", no_argument, 0, CORE_OPT}, + {"db", no_argument, 0, DB_OPT}, + {"dump-state", required_argument, 0, 'D'}, + {"help", no_argument, 0, 'h'}, + {"pcpu", no_argument, 0, PCPU_OPT}, + {"pgpu", no_argument, 0, PGPU_OPT}, + {"ppd", no_argument, 0, PPD_OPT}, + {"sb", no_argument, 0, SB_OPT}, + {"snapshot-prefix", required_argument, 0, 's'}, + {"snapshot", required_argument, 0, 'S'}, + {"verbose", no_argument, 0, 'v'}, + {"wait", no_argument, 0, 'w'}, + {0, 0, 0, 0} +}; extern "C" int main(int argc, char **argv) { using namespace retrace; + int i; assert(compareFrequency.empty()); assert(snapshotFrequency.empty()); - int i; - for (i = 1; i < argc; ++i) { - const char *arg = argv[i]; - - if (arg[0] != '-') { - break; - } - - if (!strcmp(arg, "--")) { - break; - } else if (!strcmp(arg, "-b")) { + int opt; + while ((opt = getopt_long_only(argc, argv, shortOptions, longOptions, NULL)) != -1) { + switch (opt) { + case 'h': + usage(argv[0]); + return 0; + case 'b': retrace::debug = false; retrace::verbosity = -1; - } else if (!strcmp(arg, "-c")) { - comparePrefix = argv[++i]; + break; + case 'c': + comparePrefix = optarg; if (compareFrequency.empty()) { compareFrequency = trace::CallSet(trace::FREQUENCY_FRAME); } - } else if (!strcmp(arg, "-C")) { - compareFrequency = trace::CallSet(argv[++i]); + break; + case 'C': + compareFrequency = trace::CallSet(optarg); if (comparePrefix == NULL) { comparePrefix = ""; } - } else if (!strcmp(arg, "-D")) { - dumpStateCallNo = atoi(argv[++i]); + break; + case 'D': + dumpStateCallNo = atoi(optarg); dumpingState = true; retrace::verbosity = -2; - } else if (!strcmp(arg, "-core")) { + break; + case CORE_OPT: retrace::coreProfile = true; - } else if (!strcmp(arg, "-db")) { + break; + case DB_OPT: retrace::doubleBuffer = true; - } else if (!strcmp(arg, "-sb")) { + break; + case SB_OPT: retrace::doubleBuffer = false; - } else if (!strcmp(arg, "--help")) { - usage(argv[0]); - return 0; - } else if (!strcmp(arg, "-s")) { - snapshotPrefix = argv[++i]; + break; + case 's': + snapshotPrefix = optarg; if (snapshotFrequency.empty()) { snapshotFrequency = trace::CallSet(trace::FREQUENCY_FRAME); } @@ -560,29 +594,42 @@ int main(int argc, char **argv) os::setBinaryMode(stdout); retrace::verbosity = -2; } - } else if (!strcmp(arg, "-S")) { - snapshotFrequency = trace::CallSet(argv[++i]); + break; + case 'S': + snapshotFrequency = trace::CallSet(optarg); if (snapshotPrefix == NULL) { snapshotPrefix = ""; } - } else if (!strcmp(arg, "-v")) { + break; + case 'v': ++retrace::verbosity; - } else if (!strcmp(arg, "-w")) { + break; + case 'w': waitOnFinish = true; - } else if (arg[1] == 'p') { + break; + case PGPU_OPT: retrace::debug = false; retrace::profiling = true; retrace::verbosity = -1; - if (!strcmp(arg, "-pcpu")) { - retrace::profilingCpuTimes = true; - } else if (!strcmp(arg, "-pgpu")) { - retrace::profilingGpuTimes = true; - } else if (!strcmp(arg, "-ppd")) { - retrace::profilingPixelsDrawn = true; - } - } else { - std::cerr << "error: unknown option " << arg << "\n"; + retrace::profilingGpuTimes = true; + break; + case PCPU_OPT: + retrace::debug = false; + retrace::profiling = true; + retrace::verbosity = -1; + + retrace::profilingCpuTimes = true; + break; + case PPD_OPT: + retrace::debug = false; + retrace::profiling = true; + retrace::verbosity = -1; + + retrace::profilingPixelsDrawn = true; + break; + default: + std::cerr << "error: unknown option " << opt << "\n"; usage(argv[0]); return 1; } @@ -593,7 +640,7 @@ int main(int argc, char **argv) retrace::profiler.setup(retrace::profilingCpuTimes, retrace::profilingGpuTimes, retrace::profilingPixelsDrawn); } - for ( ; i < argc; ++i) { + for (i = optind; i < argc; ++i) { if (!retrace::parser.open(argv[i])) { std::cerr << "error: failed to open " << argv[i] << "\n"; return 1; diff --git a/wrappers/trace.py b/wrappers/trace.py index 79156ac..e35108b 100644 --- a/wrappers/trace.py +++ b/wrappers/trace.py @@ -541,7 +541,7 @@ class Tracer: return 'true' if str(function.type) == 'HRESULT': return 'SUCCEEDED(_result)' - return 'false' + return 'true' def serializeArg(self, function, arg): print ' trace::localWriter.beginArg(%u);' % (arg.index,)