X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=cli%2Fcli_trim.cpp;h=1a1608447f5c0b0befcc34338b482ba32235e02c;hb=619a0bea1a05ff5cff126863d9415f3e030a4f4d;hp=69ff4e8621136a4deb9175ae0c25144f0988fb2b;hpb=cc6e51c012f447a30072d8e4c3cdd453c361a3c0;p=apitrace diff --git a/cli/cli_trim.cpp b/cli/cli_trim.cpp index 69ff4e8..1a16084 100644 --- a/cli/cli_trim.cpp +++ b/cli/cli_trim.cpp @@ -24,6 +24,7 @@ * **************************************************************************/ +#include #include #include // for CHAR_MAX #include @@ -41,6 +42,8 @@ #include "trace_parser.hpp" #include "trace_writer.hpp" +#define STRNCMP_LITERAL(var, literal) strncmp((var), (literal), sizeof (literal) -1) + static const char *synopsis = "Create a new trace by trimming an existing trace."; static void @@ -140,8 +143,12 @@ struct stringCompare { }; class TraceAnalyzer { - /* Map for tracking resource dependencies between calls. */ - std::map, stringCompare > resources; + /* Maps for tracking resource dependencies between calls. */ + std::map > resources; + std::map > dependencies; + + /* Maps for tracking OpenGL state. */ + std::map texture_map; /* The final set of calls required. This consists of calls added * explicitly with the require() method as well as all calls @@ -151,6 +158,7 @@ class TraceAnalyzer { bool transformFeedbackActive; bool framebufferObjectActive; bool insideBeginEnd; + GLuint activeProgram; /* Rendering often has no side effects, but it can in some cases, * (such as when transform feedback is active, or when rendering @@ -161,41 +169,146 @@ class TraceAnalyzer { /* Provide: Record that the given call affects the given resource * as a side effect. */ - void provide(const char *resource, trace::CallNo call_no) { + void provide(std::string 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) { + /* Like provide, but with a simply-formatted string, (appending an + * integer to the given string). */ + void providef(std::string resource, int resource_no, trace::CallNo call_no) { + std::stringstream ss; + ss << resource << resource_no; + provide(ss.str(), call_no); + } + + /* Link: Establish a dependency between resource 'resource' and + * resource 'dependency'. This dependency is captured by name so + * that if the list of calls that provide 'dependency' grows + * before 'resource' is consumed, those calls will still be + * captured. */ + void link(std::string resource, std::string dependency) { + dependencies[resource].insert(dependency); + } + + /* Like link, but with a simply-formatted string, (appending an + * integer to the given string). */ + void linkf(std::string resource, std::string dependency, int dep_no) { + + std::stringstream ss; + ss << dependency << dep_no; + link(resource, ss.str()); + } + + /* Unlink: Remove dependency from 'resource' on 'dependency'. */ + void unlink(std::string resource, std::string dependency) { + dependencies[resource].erase(dependency); + if (dependencies[resource].size() == 0) { + dependencies.erase(resource); + } + } + + /* Like unlink, but with a simply-formated string, (appending an + * integer to the given string). */ + void unlinkf(std::string resource, std::string dependency, int dep_no) { + + std::stringstream ss; + ss << dependency << dep_no; + unlink(resource, ss.str()); + } + + /* Unlink all: Remove dependencies from 'resource' to all other + * resources. */ + void unlinkAll(std::string resource) { + dependencies.erase(resource); + } + + /* Resolve: Recursively compute all calls providing 'resource', + * (including linked dependencies of 'resource' on other + * resources). */ + std::set resolve(std::string resource) { + std::set *deps; + std::set::iterator dep; std::set *calls; std::set::iterator call; - /* Insert as required all calls that provide 'resource', - * then clear these calls. */ + std::set result, deps_set; + + /* Recursively chase dependencies. */ + if (dependencies.count(resource)) { + deps = &dependencies[resource]; + for (dep = deps->begin(); dep != deps->end(); dep++) { + deps_set = resolve(*dep); + for (call = deps_set.begin(); call != deps_set.end(); call++) { + result.insert(*call); + } + } + } + + /* Also look for calls that directly provide 'resource' */ if (resources.count(resource)) { calls = &resources[resource]; for (call = calls->begin(); call != calls->end(); call++) { - required.insert(*call); + result.insert(*call); } - resources.erase(resource); + } + + return result; + } + + /* Consume: Resolve all calls that provide the given resource, and + * add them to the required list. Then clear the call list for + * 'resource' along with any dependencies. */ + void consume(std::string resource) { + + std::set calls; + std::set::iterator call; + + calls = resolve(resource); + + dependencies.erase(resource); + resources.erase(resource); + + for (call = calls.begin(); call != calls.end(); call++) { + required.insert(*call); } } void stateTrackPreCall(trace::Call *call) { - if (strcmp(call->name(), "glBegin") == 0) { + const char *name = call->name(); + + if (strcmp(name, "glBegin") == 0) { insideBeginEnd = true; return; } - if (strcmp(call->name(), "glBeginTransformFeedback") == 0) { + if (strcmp(name, "glBeginTransformFeedback") == 0) { transformFeedbackActive = true; return; } - if (strcmp(call->name(), "glBindFramebuffer") == 0) { + if (strcmp(name, "glBindTexture") == 0) { + GLenum target; + GLuint texture; + + target = static_cast(call->arg(0).toSInt()); + texture = call->arg(1).toUInt(); + + if (texture == 0) { + texture_map.erase(target); + } else { + texture_map[target] = texture; + } + + return; + } + + if (strcmp(name, "glUseProgram") == 0) { + activeProgram = call->arg(0).toUInt(); + } + + if (strcmp(name, "glBindFramebuffer") == 0) { GLenum target; GLuint framebuffer; @@ -215,24 +328,34 @@ class TraceAnalyzer { void stateTrackPostCall(trace::Call *call) { - if (strcmp(call->name(), "glEnd") == 0) { + const char *name = call->name(); + + if (strcmp(name, "glEnd") == 0) { insideBeginEnd = false; return; } - if (strcmp(call->name(), "glEndTransformFeedback") == 0) { + if (strcmp(name, "glEndTransformFeedback") == 0) { transformFeedbackActive = false; return; } + /* If this swapbuffers was included in the trace then it will + * have already consumed all framebuffer dependencies. If not, + * then clear them now so that they don't carry over into the + * next frame. */ if (call->flags & trace::CALL_FLAG_SWAP_RENDERTARGET && call->flags & trace::CALL_FLAG_END_FRAME) { + dependencies.erase("framebuffer"); resources.erase("framebuffer"); return; } } void recordSideEffects(trace::Call *call) { + + const char *name = call->name(); + /* If call is flagged as no side effects, then we are done here. */ if (call->flags & trace::CALL_FLAG_NO_SIDE_EFFECTS) { return; @@ -244,18 +367,267 @@ class TraceAnalyzer { return; } + if (strcmp(name, "glGenTextures") == 0) { + const trace::Array *textures = dynamic_cast(&call->arg(1)); + size_t i; + GLuint texture; + + if (textures) { + for (i = 0; i < textures->size(); i++) { + texture = textures->values[i]->toUInt(); + providef("texture-", texture, call->no); + } + } + return; + } + + if (strcmp(name, "glBindTexture") == 0) { + GLenum target; + GLuint texture; + + std::stringstream ss_target, ss_texture; + + target = static_cast(call->arg(0).toSInt()); + texture = call->arg(1).toUInt(); + + ss_target << "texture-target-" << target; + ss_texture << "texture-" << texture; + + resources.erase(ss_target.str()); + provide(ss_target.str(), call->no); + + unlinkAll(ss_target.str()); + link(ss_target.str(), ss_texture.str()); + + return; + } + + /* FIXME: Need to handle glMultTexImage and friends. */ + if (STRNCMP_LITERAL(name, "glTexImage") == 0 || + STRNCMP_LITERAL(name, "glTexSubImage") == 0 || + STRNCMP_LITERAL(name, "glCopyTexImage") == 0 || + STRNCMP_LITERAL(name, "glCopyTexSubImage") == 0 || + STRNCMP_LITERAL(name, "glCompressedTexImage") == 0 || + STRNCMP_LITERAL(name, "glCompressedTexSubImage") == 0 || + strcmp(name, "glInvalidateTexImage") == 0 || + strcmp(name, "glInvalidateTexSubImage") == 0) { + + std::set *calls; + std::set::iterator c; + std::stringstream ss_target, ss_texture; + + GLenum target = static_cast(call->arg(0).toSInt()); + + ss_target << "texture-target-" << target; + ss_texture << "texture-" << texture_map[target]; + + /* The texture resource depends on this call and any calls + * providing the given texture target. */ + provide(ss_texture.str(), call->no); + + if (resources.count(ss_target.str())) { + calls = &resources[ss_target.str()]; + for (c = calls->begin(); c != calls->end(); c++) { + provide(ss_texture.str(), *c); + } + } + + return; + } + + if (strcmp(name, "glEnable") == 0) { + GLenum cap; + + cap = static_cast(call->arg(0).toSInt()); + + if (cap == GL_TEXTURE_1D || + cap == GL_TEXTURE_2D || + cap == GL_TEXTURE_3D || + cap == GL_TEXTURE_CUBE_MAP) + { + linkf("render-state", "texture-target-", cap); + } + + provide("state", call->no); + return; + } + + if (strcmp(name, "glDisable") == 0) { + GLenum cap; + + cap = static_cast(call->arg(0).toSInt()); + + if (cap == GL_TEXTURE_1D || + cap == GL_TEXTURE_2D || + cap == GL_TEXTURE_3D || + cap == GL_TEXTURE_CUBE_MAP) + { + unlinkf("render-state", "texture-target-", cap); + } + + provide("state", call->no); + return; + } + + if (strcmp(name, "glCreateShader") == 0 || + strcmp(name, "glCreateShaderObjectARB") == 0) { + + GLuint shader = call->ret->toUInt(); + providef("shader-", shader, call->no); + return; + } + + if (strcmp(name, "glShaderSource") == 0 || + strcmp(name, "glShaderSourceARB") == 0 || + strcmp(name, "glCompileShader") == 0 || + strcmp(name, "glCompileShaderARB") == 0 || + strcmp(name, "glGetShaderiv") == 0 || + strcmp(name, "glGetShaderInfoLog") == 0) { + + GLuint shader = call->arg(0).toUInt(); + providef("shader-", shader, call->no); + return; + } + + if (strcmp(name, "glCreateProgram") == 0 || + strcmp(name, "glCreateProgramObjectARB") == 0) { + + GLuint program = call->ret->toUInt(); + providef("program-", program, call->no); + return; + } + + if (strcmp(name, "glAttachShader") == 0 || + strcmp(name, "glAttachObjectARB") == 0) { + + GLuint program, shader; + std::stringstream ss_program, ss_shader; + + program = call->arg(0).toUInt(); + shader = call->arg(1).toUInt(); + + ss_program << "program-" << program; + ss_shader << "shader-" << shader; + + link(ss_program.str(), ss_shader.str()); + provide(ss_program.str(), call->no); + + return; + } + + if (strcmp(name, "glDetachShader") == 0 || + strcmp(name, "glDetachObjectARB") == 0) { + + GLuint program, shader; + std::stringstream ss_program, ss_shader; + + program = call->arg(0).toUInt(); + shader = call->arg(1).toUInt(); + + ss_program << "program-" << program; + ss_shader << "shader-" << shader; + + unlink(ss_program.str(), ss_shader.str()); + + return; + } + + if (strcmp(name, "glUseProgram") == 0 || + strcmp(name, "glUseProgramObjectARB") == 0) { + + GLuint program; + + program = call->arg(0).toUInt(); + + unlinkAll("render-program-state"); + + if (program == 0) { + unlink("render-state", "render-program-state"); + provide("state", call->no); + } else { + std::stringstream ss; + + ss << "program-" << program; + + link("render-state", "render-program-state"); + link("render-program-state", ss.str()); + + provide(ss.str(), call->no); + } + + return; + } + + if (strcmp(name, "glGetUniformLocation") == 0 || + strcmp(name, "glGetUniformLocationARB") == 0 || + strcmp(name, "glGetFragDataLocation") == 0 || + strcmp(name, "glGetFragDataLocationEXT") == 0 || + strcmp(name, "glGetSubroutineUniformLocation") == 0 || + strcmp(name, "glGetProgramResourceLocation") == 0 || + strcmp(name, "glGetProgramResourceLocationIndex") == 0 || + strcmp(name, "glGetVaryingLocationNV") == 0) { + + GLuint program = call->arg(0).toUInt(); + + providef("program-", program, call->no); + + return; + } + + /* For any call that accepts 'location' as its first argument, + * perform a lookup in our location->program map and add a + * dependence on the program we find there. */ + if (call->sig->num_args > 0 && + strcmp(call->sig->arg_names[0], "location") == 0) { + + providef("program-", activeProgram, call->no); + return; + } + + /* FIXME: We cut a huge swath by assuming that any unhandled + * call that has a first argument named "program" should not + * be included in the trimmed output unless the program of + * that number is also included. + * + * This heuristic is correct for many cases, but we should + * actually carefully verify if this includes some calls + * inappropriately, or if it misses some. + */ + if (strcmp(name, "glLinkProgram") == 0 || + strcmp(name, "glLinkProgramARB") == 0 || + (call->sig->num_args > 0 && + (strcmp(call->sig->arg_names[0], "program") == 0 || + strcmp(call->sig->arg_names[0], "programObj") == 0))) { + + GLuint program = call->arg(0).toUInt(); + providef("program-", program, call->no); + 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) { + std::set calls; + std::set::iterator c; + provide("framebuffer", call->no); + calls = resolve("render-state"); + + for (c = calls.begin(); c != calls.end(); c++) { + provide("framebuffer", *c); + } + /* In some cases, rendering has side effects beyond the * framebuffer update. */ if (renderingHasSideEffect()) { provide("state", call->no); + for (c = calls.begin(); c != calls.end(); c++) { + provide("state", *c); + } } return; @@ -355,15 +727,20 @@ trim_trace(const char *filename, struct trim_options *options) /* There's no use doing any work past the last call requested * by the user. */ - if (call->no > options->calls.getLast()) + if (call->no > options->calls.getLast()) { + delete call; break; + } /* If requested, ignore all calls not belonging to the specified thread. */ - if (options->thread != -1 && call->thread_id != options->thread) + if (options->thread != -1 && call->thread_id != options->thread) { + delete call; continue; + } /* Also, prune if uninteresting (unless the user asked for no pruning. */ if (options->prune_uninteresting && call->flags & trace::CALL_FLAG_UNINTERESTING) { + delete call; continue; } @@ -381,6 +758,8 @@ trim_trace(const char *filename, struct trim_options *options) if (options->dependency_analysis) { analyzer.analyze(call); } + + delete call; } /* Prepare output file and writer for output. */