test: Add test using GLX with dlopen and dlsym to find symbols

Gradually building out the test suite to something useful here.

fips: Add the beginning of a test suite

So far, there's just one test program. It links against libGL.so and
uses GLX to render a few solid frames. The test suite ensures that it
can be run and that "fips --verbose" actually prints a message.

fips: Add a -v/--verbose flag.

The only real purpose imagined for this for now is to be able to
verify that fips is actually doing something, (for example, if a
program renders less than 60 frames and exits then previous fips would
exit silently).

The --verbose flag will be useful with the upcoming test suite and its
short-lived programs.

configure: Add pkg-config-based check for libX11

Nothing in fips itself needs to link against libX11, but we'll soon be
adding a test-suite program that needs to be able to.

configure: Set GL_LDFLAGS and EGL_LDFLAGS in configure script

The libfips library doesn't link directly to libGL nor libEGL so
didn't need these flags. But we're adding test programs that do link
to these, so the test's Makefile needs access to these flags.

Push final collection of CFLAGS/LDFLAGS from Makefile.config to Makefile.local

This makes the final decision more explicit closer to where the flags
are actually being used. This will be helpful as we add other
programs, which can now easily mimic the style of flags collection as
is done for fips.

This also eliminates any potential confusion of FIPS_FLAGS
vs. FINAL_FIPS_FLAGS, etc. The use of "FINAL_" has now been entirely
eliminated.

Stop processing command-line options at first non-option argument

This makes it much easier to pass options to the program being
executed by fips. The options can be passed directly, such as:

fips glxgears -fullscreen

Previous, to this commit, one would have to use a syntax such as:

fips -- glxgears -fullscreen

to prevent fips from trying to interpret the "-fullscreen" argument as
options to fips itself.

eglwrap: Add comment describing why we don't lookup into libGLESv2.so

A user recently asked me why we didn't perform lookups in
libGLESv2.so, (instead of just libEGL.so). I actually made the mistake
of writing code to do that before I realized the answer.

Adding the answer in a comment here should help me avoid making that
mistake again.

EGL: Add wrapper for eglGetProcAddress

If an EGL-using program uses eglGetProcAddress to locate functions, we
want to intercept that to return our own versions of the functions,
(to add out metrics timings, etc.).

If the requested function is not implemented in our library, just
defer to the real, underlying eglGetProcAddress function to find the
symbol.

configure: Fix configure check to look for egl.h in the correct directory

This configure check was broken by looking for GL/egl.h instead of
EGL/egl.h as it should. This failure was masked on any system with an
EGL implementation providing a pkg-config file (egl.pc).

Push glBeginQuery/glEndQuery down into metrics.c

The code in metrics.c was already using dynamic dispatch for OpenGL functions.

But the code in glwrap is now, (and cannot since it relies on "real" OpenGL
header files to ensure the wrapped functions have the correct prototypes).

This resulted in link failures since these functions were not called via
dynamic dispatch.

Gix by adding new metrics_counter_start and metrics_counter_stop functions which
call the glBeginQuery/glEndQuery functions via dynamic dispatch.

fips-dispatch: Completely separate fips-dispatch GL prototypes from GL/gl.h

Move the OpenGL prototypes previously in fips-dispatch.h to a new
fips-dispatch-gl.h. The idea here is that any given file should
include only one of GL/gl.h or fips-dispatch-gl.h.

Files that implement libfips wrappers for OpenGL functions include
GL/gl.h to ensure that they implement functions with the correct
prototypes.

Meanwhile, files that call into OpenGL functions at run-time, (such as
metrics.c which calls the various OpenGL query-related functions),
instead include fips-dispatch-gl.h and do not include GL/gl.h. With
this approach, any new calls to OpenGL functions will cause
compilation warnings if the stubs are not also added to
fips-dispatch-gl.h.

Add dynamic dispatch for any calls to OpenGL functions.

Previously, fips code was making direct calls to OpenGL functions,
(such as glGenQueries, glBeinQuery, etc. within metrics.c). Some
OpenGL implementations do not export these symbols directly,
(expecting the application to instead look the symbols up via a call
to glXGetProcAddressARB or eglGetProcAddress).

The new fips-dispatch code added here does precisely that, (and adds
wrapper for both glXMakeCurrent and eglMakeCurrent in order to know
which GetProcAddress function should be called).

The dispatch code follows the model of piglit-dispatch, (available
under the same license as fips). Thanks to Eric Anholt for suggesting
following the same approach as piglit.

configure: Fix to have compiler warnings enabled while building libfips

In commit e42d9f224a4ef2784f8fd43f9f4f5c593a7ddd57 , when the flags
were split between fips and libfips, the warnings flags were
mistakenly applied to both CFLAGS and LDFLAGS of fips. (What was
actually intended was to have the warnings applied to the CFLAGS of
both fips and libfips).

TODO: Add some additional items suggested by Eero.

Again, simply trying to ensure that good ideas that come in via email
don't get dropped on the floor.

 Report shader compilation time.

+Report elapsed time per frame.
+
+Add options to control which metrics should be collected.
+
 Add Eric's tiny hash table for collecting per-shader statistics

  people.freedesktop.org:~anholt/hash_table
@@ -45,6 +49,9 @@ Infrastructure (larger-scale things, more future-looking items)

 Use ncurses for a better top-like display.

+Report timestamps and CPU time durations for operations causing
+CPU/GPU syncs.
+
 Emit per-frame data in a format for external timeline viewer.

 Allow enabling/disabling of tracing at run-time
@@ -61,10 +68,16 @@ should automatically collect:

 Audit exisiting visualization tools before writing one from scratch

- Eero suggested that pytimechart might be well-suited:
+ Eero suggested two possibilities:

+ pytimechart
+ -----------
  http://pythonhosted.org/pytimechart/index.html

+ e-graph
+ -------
+ https://gitorious.org/e-graph
+
  Others?

 Explore using perf/LTTng probing instead of LD_PRELOAD wrapper

TODO: Remove bug causing libfips-32.so to not build.

The configure script now checks for this problem and won't attempt to
build a non-native-arch libfips if the toolchain pieces, (such as the
gcc-multilib package), are not in place.

configure: Fully separate CFLAGS/LDFLAGS between fips and libfips

The top-level program and the underlying library have fundamentally
different requirements. For example, the top-level program needs to
link against libtalloc and libelf but the library does not.

Previously, the necessary flags for both were mixed together in
CONFIGURE_CFLAGS and CONFIGURE_LDFLAGS. This caused the library to
unnecessarily link against libtalloc and libelf, (which in turn caused
problems since the library is compiled as both 32-bit and 64-bit but
the system may not provide both 32- and 64-bit versions of these
libraries).

By splitting things up into separate FIPS_LDFLAGS vs. LIBFIPS_LDFLAGS,
etc. we can keep the dependencies down to what is really required and
eliminate several sprious failure cases.

Add more detailed warning if libfips binary could not be found.

Since we now may not compile a non-native bit-size libfips, (such as
not compiling libfips-32.so on a native 64-bit install), then fips can
fail when trying to wrap a 32-bit application.

So be kind and suggest that the user install gcc-multilib and
re-compile fips as one potential solution for this problem.

configure: Test whether compiler can create both 32 and 64-bit binaries

If not, tell the user and recommend installing gcc-multilib. Then simply
don't attempt to compile the unspoorted library.

configure: Move the code which detects compiler warning options

For no good reason, this code was previously stuck right in the middle
of code reporting the final results of previous checks, (after the
case reporting that errors were found and before the case reporting
that no errors were found).

It's more clean to have the warning-option detection happen before any
of that reporting.

configure: Switch from 4 spaces to tabs for some messages

Another cosmetic improvement to simply align the output more cleanly.

configure: Add an early check for a functional C compiler

Without this, later compiler-based checks for header files, etc. would
falsely claim that libraries were not installed, (when in fact, the
libraries were installed but the compiler-based checks were failing
because no compiler is available).

configure: Tighten up the text on a couple of messages

Just a cosmetic thing to make the column of Yes/No messages align more
closely.

configure: Move the error message for pkg-config earlier

Once pkg-config cannot be found, there's no point in running the rest
of the configure script since it will just spew a bunch of errors due
to missing pkg-config.

So, stop early and let the user know that pkg-config needs to be
installed.

Add a TODO file

This captures known bugs, planned (near-term) features, planned
(longer-term) infrastructure changes, and some ideas for other things
to investigate.

Many thanks to Eero Tamminen whose recent discussions and ideas
prompted the creation of this file, (and much of the content).

eglwrap: Add EGLWRAP_DEFER and EGLWRAP_DEFER_WITH_RETURN macros

There are parallel to GLWRAP_DEFER and GLWRAP_DEFER_WITH_RETURN, (differing
only in calling eglwrap_lookup rathern than glwrap_lookup).

Having these macros around will avoid some code duplication as we start
adding more functions to the eglwrap.c file.

Fix to actually load the real libGL.so when the application asks for it.

Our wrapper library intercepts calls to dlopen "libGL.so" and returns
a handle to itself. That's correct, and as intended.

Before doing this, however, it's essential to actual dlopen "libGL.so"
for real even though we won't be returning a handle to it. This
ensures that any side effects from that dlopen are taken care of.

This fixes a bug where "fips apitrace replay foo.trace" would cause
Mesa to fail to load its driver as follows (with LIBGL_DEBUG=verbose):

libGL: OpenDriver: trying .../lib/dri/i965_dri.so
libGL error: dlopen .../lib/dri/i965_dri.so failed (.../lib/libdricore9.2.0.so.1: undefined symbol: _glapi_tls_Context)

dlwrap: Don't resolve libfips_handle on every call to dlopen.

Instead, call dladdr and the real dlopen on the first call to dlopen
then save the libfips_handle result for all future calls.

Switch from glGetQueryObjectiv to glGetQueryObjectuiv

The latter is available in OpenGL ES 3 while the former is not.

We don't really care about the signedness either way, (we're fetching
a Boolean), so sticking consistently to the unsigned version provides
better portability with no downside.

Add a new GLWRAP_DEFER_WITH_RETURN macro.

This allows for the elimination of some code duplication from our
implementation of glXGetPrcAddressARB. The previous implementation
duplicated code from glwrap_lookup simply because the GLWRAP_DEFER
macro did not provide access to the return value of the wrapped
function.

With the new macro, (very much like GLWRAP_DEFER but accepting a
parameter for a variable to accept the return value), we can eliminate
this code duplication.

Of course, our symbol-extraction script is now a bit more complicated
since it has to find occurrences of DEFER_WITH_RETURN in addition to
occurrences of DEFER, and pull out the function name as the second
argument rather than the first.

Remove typedef for fips_glXGetProcAddressARB_t

There were two problems with this typedef. First, we don't actually
need it, (we define it here and then use it exactly once on the next
line---it's simpler to have the direct syntax for a function returning
a pointer to a function accepting void and returning void.

More importantly, the typedef was relying on the type __GLXextFuncPtr
being defined. This happens to work with Mesa on my system but is
inherently fragile. So the code is more robust not relying on this.

Makefile: Automatically generate libfips.sym symbol map

Previously, we had to manually maintain this table of symbols, (hence
it was too easy for the list to be stale). Instead, we now generate
the list automatically by examining the source code for symbols that
are wrapped.

libfips.sym: Sort list in symbol map alphabetically.

Where sort order is determined by "sort" utility.

This is to prepare for eventually generating this list automatically
from the source.

Add some *wrap_ prefixes to real_foo symbols.

The intent here is to allow automated extraction of wrapper names by
grepping for symbols matching *wrap_real_<wrapper>.

Add two missing GL draw wrappers

The following two functions are now added:

glMultiDrawArraysIndirect
glMultiDrawElementsIndirect

These were previously commented out with a "FIXME" comment. I don't
recall now what original problem I ran into when trying to add these,
but they seem to work fine now.

metrics: Collect new timer-query results before report

The timers from the most-recently-completed frame may not yet be
complete, but still, for the most accurate reports, we now collect all
available timer values before printing the report.

dlwrap: Fix dlwrap_real_dlopen to only perform dlsym-lookup once

Making the real_dlopen variable static means that we perform the dlysm
lookup only once and then re-use the result for later calls. This is
what was always intended for this code.

Avoid inserting timer queries while constructing a display list

We only want to time actual drawing operations. When between glNewList
and glEndList, calls that look like drawing operations are not really,
instead these are just calls that are being recorded to be later
executed with glCallList. (And it won't work to put our timer queries
inside the display list.)

So, track when we are within glNewList/glEndList and don't add timer
queries.  Instead, we will time these operations as a whole with a
timer query around the glCallList call itself.

Avoid trying to start a timer query within glBegin/glEnd

Instead, treat the entire sequence from glBegin..glEnd as a single drawing
operation and execute the timer query around the whole thing.

Add several missing symbols to the libfips symbol map.

I'm not sure why these weren't added before, but without these in the
map, these calls were not being successfully wrapped, so these calls
were not being timed as they should have been.

In the future we should automatically generate the symbol list to
avoid any similar problems.

Remove useless fork before executing wrapped program.

The fork did nothing for us since the parent simply waited on the child
and then exited. It's simpler to simply exec the wrapped program, (which
simplifies running fips within a debugger, etc.).

Add support for OpenGL ES by conditionally compiling wrapper for eglSwapBuffers

The configure script now looks for EGL/egl.h, (via pkg-config or directly),
and if present, will compile a wrapper for eglSwapBuffers.

This allows fips to report metrics for OpenGL ES programs.

Move metrics-tracking code from glwrap.c to new metrics.c

We're moving toward having separate *wrap.c files for each flavor of GL,
(glwrap.c, glxwrap.c, and eglwrap.c). But this metrics-tracking code is
generic to all of those so belongs in a separate module.

Reduce code duplication with with new 'glwrap_lookup' function.

We already had two copies of 'lookup', (and were anticipating additional
modules which needed it as well). The DEFER macro is now also exported
as GLWRAP_DEFER for use in additional modules.

configure: Add checks for GL/gl.h

Previously, the compile would just forge ahead assuming GL/gl.h was present.

Now, at configure time, actually look for gl.h, (first, by looking for
a pkg-config "gl" package, otherwise, trying to just test-compile
something with a #include <GL/gl.h>).

If things aren't found at configure time, tell the user which packages
to install.

Fix glwrap.c to workaround 'const' changes in OpenGL headers.

Not all OpenGL headers are created equal. Some include more "const"
keywords than others, and we don't know wheter the headers we are
compiling against include the extra "const". We force all to be equal
by using the preprocessor to remove all "const" keywords altogether.

Wrap all OpenGL drawing calls, measure GPU time of each, and account to shader.

Thanks to José Fonseca, there's a nice list of OpenGL functions identified
as "drawing operations" in the apitrace source. (It's mostly glDraw* but
there are a few oddball as well.) With that list we implement a wrapper
for each draw call.

And in each wrapper we fire of a glBeginQuery/glEndQuery measurement around
the call to measure how much GPU time is consumed by the call. At the end
of each frame, we capture all available query results and accumulate those
into per-shader-program counters based on the currently active program,
(which we track by wrapping glUseProgram and glUseProgramObjectARB).

Finally, every 60 frames, we print out a simple report showing the
accumulated time for each shader program.

The report could very easily become more sophisticated. Here are some
obvious ideas:

  1. Sort the report so that the most active shaders are reported first

  2. Come up with some real units for the report values rather than mega-ticks

  3. Report relative execution time as percentages

  4. Clear the screen for each report, (with ncurses)

  5. Dump the source for the shaders themselves to a file for easy inspection

Without any of the above, things are fairly raw for now, but are
perhaps still useful.

Generalize glXGetProcAddressARB wrapper to work for all wrapper functions

The originally implementation here had a whitelist of function names for
which we would return a wrapped symbol, (a very short whitelist consisting
only of "glXSwapBuffers"). A hard-coded list here would be a maintenance
nightmare.

Instead, we now simply perform a dlsym lookup on the wrapper library itself
and if there's a function that exists in the library matching the name
being requested, we return that.

This way we can add functions to our wrapper library without needing to
change the implementation of glXGetProcAddressARB at all.

Fix 3 separate off-by-one error in as many lines of code.

This one is quite embarrassing, and is evidence that I should have
gone to bead earlier last night.

Move include of dlfcn.h to dlwrap.h

It only makes sense to make this header file pull in the underlying
dlfcn.h.

While in the area, also drop an unneeded include of GL/glext.h, (which
gets pulled in by GL/gl.h).

Add a simple fips.h file.

This pulls in a few widely-used header files, (config.h, stdio.h,
stdlib.h, and string.h), and also gives us a place to define common
macros such as unused and STRNCMP_LITERAL.

Append to, rather than replace, the LD_PRELOAD value.

This is more polite for running things such as Steam games where there
is already an LD_PRELOAD value in place. This way, both the Steam overlay
and fips can get along happily.

fixup __dlsym

Add wrappers for dlopen, dlsym, and glXGetProcAddressARB

This allows for many applications to start working with fips that would not
work before. Specifically, applications that dlopen libGL.so.1 instead of
directly linking with it would previously bypass fips' attempts to wrap
GL calls.

With these new wrappers carefully in place, many applications now work.

I've verified the following applications at least:

apitrace replay
NightSkyHD, a Humble Bundle game, both 32 and 64-bit versions
World of Goo, via Steam

I was also happy to notice that the Steam overlay does not cause fips
any difficulties.

Fix fips to work without requiring an absolute path for program to run.

With the latest commit that examines the ELF header of the program to
run fips was suddenly requiring that the absolute path of the program
be provided. This was obvisouly not desired.

It's simple enough to search through the PATH environment variable to
find the absolute path of the program to be run and examine that.

Compile both 32-bit and 64-bit versions of the wrapper library.

This is intended to make it transparent to run fips with either a
32-bit or a 64-bit program. And it does do that once you successfully
build both versions of the library.

Actually being able to build both versions of the library is a little
tricky though. Here are some of the tricks:

1. You will need to have installed both a 32-bit and a 64-bit .so file
   for each dependent library, (currently libelf and libtalloc).

   The current configure script doesn't check for both versions, so
   you don't get a lot of guidance here. And that's because...

2. On Debian, at least, one cannot currently install both
   libtalloc-dev:amd64 and libtalloc-dev:i386 at the same time.

   Contrast with libelf-dev:i386 and libelf-dev:amd64 which work just
   fine when installed simultaneously.

One can work around this by just install libtalloc-dev:amd64 and then
manually creating the link you need for the i386 package. Namely:

sudo ln -s libelf.so.1 /usr/lib/i386-linux-gnu/libelf.so

Start wrapping OpenGL, and print periodic FPS value to stdout.

In addition to the fips binary, we now also compile a libfips.so library
and LD_PRELOAD that before executing the program specified on the command-
line.

The libfips.so library wraps OpenGL calls of interest for purpose of
instrumentation. So far, the only call wrapped is glXSwapBuffers and
the only instrumentation is to compute and print out a frames-per-second
value every 60 frames.

Add the ability to execute a program.

Simply fork and exec the command-line arguments given.

(Nothing is actually changed yet about the environment in which the
program is executed.)

Move dist, release, etc. targets to new Makefile.release

The Makefile.local was getting far too cluttered with all of this
stuff mixed in.

Initial commit of fips repository

Just a build system and a stub of a main program for now, (which
doesn't do anything yet).