Javelina is an advanced code coverage tool that uses dynamic
instrumentation. Dynamic instrumentation allows code coverage data to be
acquired with a minimum overhead. Once a section of code has been
executed, the instrumentation for that code is removed. Thus, there is a
performance hit only the first time a section of code is executed. This
is particularly beneficial for scientific and other applications were loops are
repeatedly evaluated. Furthermore, Javelina allows one to apply advanced
logical operations to the acquired coverage data. This has allowed users
to optimize the testing of their applications by focusing the testing
effort on the sections of code that are executed by end users but are
not exercised by test cases.
Javelina obtains its line number information from the compiler-generated
debugging information. Because of this, Javelina does not need to be
ported to every compiler. In addition, any compiled language which
has debugging information can be analyzed. Mixtures of languages
and compilers in a single executable are also supported.
Javelina's advanced logical operations can accept
coverage data from many sources (currently Javelina/Dyninst and
Javelina/Atom). It is possible to convert coverage data from your
favorite format (e.g. gcov) into a form which can be used by Javelina.
With this method, it is possible to use some of Javelina's functionality
on unsupported platforms.
Javelina was designed and developed by David R. "Chip" Kent IV at
Los Alamos National Laboratory. It has
been released as open source software by the United States Department of Energy
The Javelina project aims to:
- Collect code coverage data with minimal overhead.
- Collect code coverage data with minimal impact upon build and compilation procedures.
- Be portable to standard OS/hardware combinations.
- Support massively parallel applications.
- Support mixed language programs.
- Support programs with sections complied by different compilers.
- Allow the application of complex logical operations to coverage data (e.g. find the lines run by users which are never tested).
- Be easy to use for beginners while providing complex functionality for advanced users.
- Maintain a simple, clean design which is easy to maintain, easy to debug, and just works.
- x86_64/Linux (e.g. AMD64, Opteron, EM64T)
Should work, but haven't been tested:
- PowerPC/AIX 5.1
- MIPS/IRIX 6.5
- x86/Windows 2000/XP