X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=cli%2Fcli_trim.cpp;h=c5b018856d692c5bf08673bf066d2c7a956c822b;hb=54300ebabd931085b2ef12edfef2e8ddd8c709dc;hp=3fc3803cc4b2f5afeb13d84e7330105a2422fd35;hpb=42249019f6ac3453c2244bc8aab343a86e48c4d2;p=apitrace diff --git a/cli/cli_trim.cpp b/cli/cli_trim.cpp index 3fc3803..c5b0188 100644 --- a/cli/cli_trim.cpp +++ b/cli/cli_trim.cpp @@ -24,19 +24,18 @@ * **************************************************************************/ +#include #include #include // for CHAR_MAX #include -#include -#include - #include #include "cli.hpp" #include "os_string.hpp" +#include "trace_analyzer.hpp" #include "trace_callset.hpp" #include "trace_parser.hpp" #include "trace_writer.hpp" @@ -52,12 +51,12 @@ usage(void) "\n" " -h, --help Show detailed help for trim options and exit\n" " --calls=CALLSET Include specified calls in the trimmed output.\n" + " --frames=FRAMESET Include specified frames in the trimmed output.\n" " --deps Include additional calls to satisfy dependencies\n" - " --no-deps Do not include calls from dependency analysis\n" " --prune Omit uninteresting calls from the trace output\n" - " --no-prune Do not prune uninteresting calls from the trace.\n" - " -x, --exact Include exactly the calls specified in --calls\n" - " Equivalent to both --no-deps and --no-prune\n" + " -a, --auto Trim automatically to calls specified in --calls/--frames\n" + " Equivalent to both --deps and --prune\n" + " --print-callset Print the final set of calls included in output\n" " --thread=THREAD_ID Only retain calls from specified thread\n" " -o, --output=TRACE_FILE Output trace file\n" ; @@ -73,32 +72,26 @@ help() " -h, --help Show this help message and exit\n" "\n" " --calls=CALLSET Include specified calls in the trimmed output.\n" - " Note that due to dependency analysis and pruning\n" - " of uninteresting calls the resulting trace may\n" - " include more and less calls than specified.\n" - " See --no-deps, --no-prune, and --exact to change\n" - " this behavior.\n" + " --frames=FRAMESET Include specified frames in the trimmed output.\n" "\n" " --deps Perform dependency analysis and include dependent\n" " calls as needed, (even if those calls were not\n" - " explicitly requested with --calls). This is the\n" - " default behavior. See --no-deps and --exact.\n" - "\n" - " --no-deps Do not perform dependency analysis. In this mode\n" - " the trimmed trace will never include calls from\n" - " outside the range specified in --calls.\n" + " explicitly requested with --calls or --frames).\n" "\n" - " --prune Omit calls that have no side effects, even if the\n" - " call is within the range specified by --calls.\n" - " This is the default behavior. See --no-prune\n" + " --prune Omit calls with no side effects, even if the call\n" + " is within the range specified by --calls/--frames.\n" "\n" - " --no-prune Do not prune uninteresting calls from the trace.\n" - " In this mode the trimmed trace will never omit\n" - " any calls within the range specified in --calls.\n" + " -a, --auto Use dependency analysis and pruning\n" + " of uninteresting calls the resulting trace may\n" + " include more and less calls than specified.\n" + " This option is equivalent\n" + " to passing both --deps and --prune.\n" "\n" - " -x, --exact Trim the trace to exactly the calls specified in\n" - " --calls. This option is equivalent to passing\n" - " both --no-deps and --no-prune.\n" + " --print-callset Print to stdout the final set of calls included\n" + " in the trim output. This can be useful for\n" + " tweaking trimmed callset from --auto on the\n" + " command-line.\n" + " Use --calls=@FILE to read callset from a file.\n" "\n" " --thread=THREAD_ID Only retain calls from specified thread\n" "\n" @@ -109,27 +102,27 @@ help() enum { CALLS_OPT = CHAR_MAX + 1, + FRAMES_OPT, DEPS_OPT, - NO_DEPS_OPT, PRUNE_OPT, - NO_PRUNE_OPT, THREAD_OPT, + PRINT_CALLSET_OPT, }; const static char * -shortOptions = "ho:x"; +shortOptions = "aho:x"; const static struct option longOptions[] = { {"help", no_argument, 0, 'h'}, {"calls", required_argument, 0, CALLS_OPT}, + {"frames", required_argument, 0, FRAMES_OPT}, {"deps", no_argument, 0, DEPS_OPT}, - {"no-deps", no_argument, 0, NO_DEPS_OPT}, {"prune", no_argument, 0, PRUNE_OPT}, - {"no-prune", no_argument, 0, NO_PRUNE_OPT}, - {"exact", no_argument, 0, 'x'}, + {"auto", no_argument, 0, 'a'}, {"thread", required_argument, 0, THREAD_OPT}, {"output", required_argument, 0, 'o'}, + {"print-callset", no_argument, 0, PRINT_CALLSET_OPT}, {0, 0, 0, 0} }; @@ -139,187 +132,13 @@ struct stringCompare { } }; -class TraceAnalyzer { - /* Map for tracking resource dependencies between calls. */ - std::map, stringCompare > resources; - - /* The final set of calls required. This consists of calls added - * explicitly with the require() method as well as all calls - * implicitly required by those through resource dependencies. */ - std::set required; - - bool transformFeedbackActive; - bool framebufferObjectActive; - bool insideBeginEnd; - - /* Rendering often has no side effects, but it can in some cases, - * (such as when transform feedback is active, or when rendering - * targets a framebuffer object). */ - bool renderingHasSideEffect() { - return transformFeedbackActive || framebufferObjectActive; - } - - /* Provide: Record that the given call affects the given resource - * as a side effect. */ - void provide(const char *resource, trace::CallNo call_no) { - resources[resource].insert(call_no); - } - - /* Consume: Add all calls that provide the given resource to the - * required list, then clear the list for this resource. */ - void consume(const char *resource) { - - std::set *calls; - std::set::iterator call; - - /* Insert as required all calls that provide 'resource', - * then clear these calls. */ - if (resources.count(resource)) { - calls = &resources[resource]; - for (call = calls->begin(); call != calls->end(); call++) { - required.insert(*call); - } - resources.erase(resource); - } - } - - void stateTrackPreCall(trace::Call *call) { - - if (strcmp(call->name(), "glBegin") == 0) { - insideBeginEnd = true; - return; - } - - if (strcmp(call->name(), "glBeginTransformFeedback") == 0) { - transformFeedbackActive = true; - return; - } - - if (strcmp(call->name(), "glBindFramebuffer") == 0) { - GLenum target; - GLuint framebuffer; - - target = static_cast(call->arg(0).toSInt()); - framebuffer = call->arg(1).toUInt(); - - if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER) { - if (framebuffer == 0) { - framebufferObjectActive = false; - } else { - framebufferObjectActive = true; - } - } - return; - } - } - - void stateTrackPostCall(trace::Call *call) { - - if (strcmp(call->name(), "glEnd") == 0) { - insideBeginEnd = false; - return; - } - - if (strcmp(call->name(), "glEndTransformFeedback") == 0) { - transformFeedbackActive = false; - return; - } - - if (call->flags & trace::CALL_FLAG_SWAP_RENDERTARGET && - call->flags & trace::CALL_FLAG_END_FRAME) { - resources.erase("framebuffer"); - return; - } - } - - void recordSideEffects(trace::Call *call) { - /* If call is flagged as no side effects, then we are done here. */ - if (call->flags & trace::CALL_FLAG_NO_SIDE_EFFECTS) { - return; - } - - /* Similarly, swap-buffers calls don't have interesting side effects. */ - if (call->flags & trace::CALL_FLAG_SWAP_RENDERTARGET && - call->flags & trace::CALL_FLAG_END_FRAME) { - return; - } - - /* Handle all rendering operations, (even though only glEnd is - * flagged as a rendering operation we treat everything from - * glBegin through glEnd as a rendering operation). */ - if (call->flags & trace::CALL_FLAG_RENDER || - insideBeginEnd) { - - provide("framebuffer", call->no); - - /* In some cases, rendering has side effects beyond the - * framebuffer update. */ - if (renderingHasSideEffect()) { - provide("state", call->no); - } - - return; - } - - /* By default, assume this call affects the state somehow. */ - resources["state"].insert(call->no); - } - - void requireDependencies(trace::Call *call) { - - /* Swap-buffers calls depend on framebuffer state. */ - if (call->flags & trace::CALL_FLAG_SWAP_RENDERTARGET && - call->flags & trace::CALL_FLAG_END_FRAME) { - consume("framebuffer"); - } - - /* By default, just assume this call depends on generic state. */ - consume("state"); - } - - -public: - TraceAnalyzer(): transformFeedbackActive(false), - framebufferObjectActive(false), - insideBeginEnd(false) - {} - - ~TraceAnalyzer() {} - - /* Analyze this call by tracking state and recording all the - * resources provided by this call as side effects.. */ - void analyze(trace::Call *call) { - - stateTrackPreCall(call); - - recordSideEffects(call); - - stateTrackPostCall(call); - } - - /* Require this call and all of its dependencies to be included in - * the final trace. */ - void require(trace::Call *call) { - - /* First, find and insert all calls that this call depends on. */ - requireDependencies(call); - - /* Then insert this call itself. */ - required.insert(call->no); - } - - /* Return a set of all the required calls, (both those calls added - * explicitly with require() and those implicitly depended - * upon. */ - std::set *get_required(void) { - return &required; - } -}; - struct trim_options { /* Calls to be included in trace. */ trace::CallSet calls; + /* Frames to be included in trace. */ + trace::CallSet frames; + /* Whether dependency analysis should be performed. */ bool dependency_analysis; @@ -331,6 +150,9 @@ struct trim_options { /* Emit only calls from this thread (-1 == all threads) */ int thread; + + /* Print resulting callset */ + int print_callset; }; static int @@ -340,6 +162,8 @@ trim_trace(const char *filename, struct trim_options *options) trace::Parser p; TraceAnalyzer analyzer; std::set *required; + unsigned frame; + int call_range_first, call_range_last; if (!p.open(filename)) { std::cerr << "error: failed to open " << filename << "\n"; @@ -350,32 +174,35 @@ trim_trace(const char *filename, struct trim_options *options) p.getBookmark(beginning); /* In pass 1, analyze which calls are needed. */ + frame = 0; trace::Call *call; while ((call = p.parse_call())) { - /* There's no use doing any work past the last call requested - * by the user. */ - if (call->no > options->calls.getLast()) { + /* There's no use doing any work past the last call or frame + * requested by the user. */ + if (call->no > options->calls.getLast() || + frame > options->frames.getLast()) { + delete call; break; } /* If requested, ignore all calls not belonging to the specified thread. */ if (options->thread != -1 && call->thread_id != options->thread) { - delete call; - continue; + goto NEXT; } /* Also, prune if uninteresting (unless the user asked for no pruning. */ - if (options->prune_uninteresting && call->flags & trace::CALL_FLAG_UNINTERESTING) { - delete call; - continue; + if (options->prune_uninteresting && call->flags & trace::CALL_FLAG_VERBOSE) { + goto NEXT; } /* If this call is included in the user-specified call set, * then require it (and all dependencies) in the trimmed * output. */ - if (options->calls.contains(*call)) { + if (options->calls.contains(*call) || + options->frames.contains(frame, call->flags)) { + analyzer.require(call); } @@ -387,6 +214,10 @@ trim_trace(const char *filename, struct trim_options *options) analyzer.analyze(call); } + NEXT: + if (call->flags & trace::CALL_FLAG_END_FRAME) + frame++; + delete call; } @@ -410,20 +241,49 @@ trim_trace(const char *filename, struct trim_options *options) /* In pass 2, emit the calls that are required. */ required = analyzer.get_required(); + frame = 0; + call_range_first = -1; + call_range_last = -1; while ((call = p.parse_call())) { - /* There's no use doing any work past the last call requested - * by the user. */ - if (call->no > options->calls.getLast()) + /* There's no use doing any work past the last call or frame + * requested by the user. */ + if (call->no > options->calls.getLast() || + frame > options->frames.getLast()) { + break; + } if (required->find(call->no) != required->end()) { writer.writeCall(call); + + if (options->print_callset) { + if (call_range_first < 0) { + call_range_first = call->no; + printf ("%d", call_range_first); + } else if (call->no != call_range_last + 1) { + if (call_range_last != call_range_first) + printf ("-%d", call_range_last); + call_range_first = call->no; + printf (",%d", call_range_first); + } + call_range_last = call->no; + } } + + if (call->flags & trace::CALL_FLAG_END_FRAME) { + frame++; + } + delete call; } - std::cout << "Trimmed trace is available as " << options->output << "\n"; + if (options->print_callset) { + if (call_range_last != call_range_first) + printf ("-%d\n", call_range_last); + } + + std::cerr << "Trimmed trace is available as " << options->output << "\n"; return 0; } @@ -433,11 +293,13 @@ command(int argc, char *argv[]) { struct trim_options options; - options.calls = trace::CallSet(trace::FREQUENCY_ALL); - options.dependency_analysis = true; - options.prune_uninteresting = true; + options.calls = trace::CallSet(trace::FREQUENCY_NONE); + options.frames = trace::CallSet(trace::FREQUENCY_NONE); + options.dependency_analysis = false; + options.prune_uninteresting = false; options.output = ""; options.thread = -1; + options.print_callset = 0; int opt; while ((opt = getopt_long(argc, argv, shortOptions, longOptions, NULL)) != -1) { @@ -448,21 +310,18 @@ command(int argc, char *argv[]) case CALLS_OPT: options.calls = trace::CallSet(optarg); break; + case FRAMES_OPT: + options.frames = trace::CallSet(optarg); + break; case DEPS_OPT: options.dependency_analysis = true; break; - case NO_DEPS_OPT: - options.dependency_analysis = false; - break; case PRUNE_OPT: options.prune_uninteresting = true; break; - case NO_PRUNE_OPT: - options.prune_uninteresting = false; - break; - case 'x': - options.dependency_analysis = false; - options.prune_uninteresting = false; + case 'a': + options.dependency_analysis = true; + options.prune_uninteresting = true; break; case THREAD_OPT: options.thread = atoi(optarg); @@ -470,6 +329,9 @@ command(int argc, char *argv[]) case 'o': options.output = optarg; break; + case PRINT_CALLSET_OPT: + options.print_callset = 1; + break; default: std::cerr << "error: unexpected option `" << opt << "`\n"; usage(); @@ -477,6 +339,12 @@ command(int argc, char *argv[]) } } + /* If neither of --calls nor --frames was set, default to the + * entire set of calls. */ + if (options.calls.empty() && options.frames.empty()) { + options.calls = trace::CallSet(trace::FREQUENCY_ALL); + } + if (optind >= argc) { std::cerr << "error: apitrace trim requires a trace file as an argument.\n"; usage(); @@ -493,6 +361,14 @@ command(int argc, char *argv[]) return 1; } + if (options.dependency_analysis) { + std::cerr << + "Note: The dependency analysis in \"apitrace trim\" is still experimental.\n" + " We hope that it will be useful, but it may lead to incorrect results.\n" + " If you find a trace that misbehaves while trimming, please share that\n" + " by sending email to apitrace@lists.freedesktop.org, cworth@cworth.org\n"; + } + return trim_trace(argv[optind], &options); }