Status update of a couple issues

[Carl Worth]

José Fonseca <jose.r.fonseca at gmail.com> writes:
> Carl Worth has been working on a tool for automatically trimming a
> subset of calls (OpenGL only), which effectively does what you want:
> trim all calls that are irrelevant for a given range of interest. I
> have not integrated his work on master yet. Please look into the
> mailing list archive for further details.

Jose, the "for-upstream" branch of my repository should still be in a
good state according to the last review you did of the code. Is there
anything more I should do to help get that merged upstream?

Beyond that, my "master" branch has some significant performance
improvements, but I do want to clean those up before they get merged.

Meanwhile, here's a status update of the trim code for Tony's benefit:

Tony, Yes, I've been implementing support for "apitrace trim" to
automatically detect dependencies between calls so that you can do
things like:

	apitrace trim --frames=123 huge-file.trace

This will result in huge-file-trim.trace with all calls from frame #123
of the original trace as well as all previously calls that were detected
as required in order to make things work.

The code can be obtained here:

	git clone git://git.cworth.org/git/apitrace

The dependency tracking still has some bugs. It works on several
non-trivial programs that I've thrown at it, but it fails on others.

I would be happy to hear of any success or failure that you have with
the tool, (and for any failure, I'd love it if you could send me the
trace that fails).

Going forward, here are several things I want to do:

1. Add support for fine-grained specification of what gets trimmed,
   (such as dead shaders only, dead textures only, etc.). This is
   primarily a debugging tool while the dependency-tracking code is
   still imperfect. This will allow you to still trim some things when
   others are buggy. It will also help to identify where the bugs are so
   we can find them more easily.

2. Fix dependency-tracking bugs.

3. Improve performance of the dependency-tracking code.

4. Add support to discard all calls before the first call requested,
   (without the performance cost of the dependency tracking).

   The idea here is to actually replay the trace up until the first call
   that is requested, then query all of the OpenGL state from the
   implementation, and finally emit new calls to recreate that state.

   And once we have that working we can also do "on-demand tracing"
   where, instead of tracing all calls from the beginning of the
   application, the user can start tracing at some point of
   interest. That will be very beneficial and will likely obviate a
   bunch of the need for trimming in the first place.

Anyway, that's maybe more than you were looking for already. I will be
interested to hear how things fare for you.

-Carl
-------------- next part --------------
A non-text attachment was scrubbed...
Name: not available
Type: application/pgp-signature
Size: 197 bytes
Desc: not available
URL: <http://lists.freedesktop.org/archives/apitrace/attachments/20121004/0a9ec729/attachment.pgp>