History

OMF Main Page » OMF User Guide »

1. Overview of OML, the OMF Measurement Library

OMF uses the OMF Measurement Library (OML) for collecting experiment results.

OML enables real-time collection of data from the various applications being run during an experiment. It provides a Measurement Library, which enables experimenters to define measurement points inside their application source code. OML also allows experimenters to define and configure filters to apply some pre-processing function to the data collected from a measurement points.

Furthermore, in case the source code of an application is not available, OML provide a simple scheme to "wrap" around such an application, and collect its outputs as measurements.

The following Figure 1 provides a schematic view of OML interaction with OMF


Figure 1: OML interaction with OMF

OML is based on a client/server architecture, and comprises an OML Collection Server and an OML Measurement Library (Client). The Collection Server constantly runs as a daemon on a testbed server (e.g. the server running the AM). It collects results from the various resources specified in the experiment. The OML Client is available as a library on each resources used by an experiment. The applications running on a given resources forward the required measurements to their OML Client. The OML Client applies any defined pre-processing filters on this data and sends the result to the OML Collection Server.

Once an experiment is complete, the stored measurements or results can be accessed for further analysis. Currently, these measurements are stored in an SQLite database by default. However, more database backend are being added to OML. User can then manipulate these data using SQL queries or export them in some other format for further processing and analysis.

For detailed information on using OML with OMF, refer to the OMF_User_Guide. For more information on OML, its advanced usage, and available features, refer to the OML Project pages.

Note: OMF can be used without OML, i.e. as long as your experiment or applications are not using OML measurement points, OMF will run your experiment happily. However, you will then need to deploy your own measurement collection scheme.

2. How to Instrument your Application

By "instrumenting your application", we mean adding OML Measurement Points to it, in order to use OML to automatically collect and store measurements from your application, while your experiment is running.

Two possible cases are supported:

  • You have the source code of your application in C/C++
  • You do not have the source code of the application in C/C++, but you have its executable binary

Note: if you have the source code in another language, then follow the 2nd case, considering only your application binary.

2.1. First Case: C/C++ source code available

2.2. Second Case: Source code not available, but an executable binary is available

  • Assuming the application you are interested in has the executable binary called "foo"
  • In this case, you will have to develop a wrapper application, which will launch the executable "foo", captures its output, formats it, and passes it on to OML
  • Currently we provide a Ruby module, oml4r, that makes writing OML wrappers in Ruby easy; however it is also possible to write wrappers in C or C++ that read output from a program, parse it, and record it directly using liboml2. It is also possible to write a wrapper in almost any language by implementing the simple OML Text Protocol, but we do not provide support for that directly.
  • Note: this case currently does not allow the use of OML's pre-processing measurement filters

3. How to use your instrumented Application with OMF

  • Once your application has been instrumented with OML, do not forget that to be able to use it with OMF you will also need to write an OMF definition for it!