GitLab

clr_hwmon was also merging sampling data generation and formatting that
data into a json string. This patch removes the formatting, for the same
reason than the previous patch.

Also removes __main__ code from module.

clr_rapl was merging sampling data generation and formatting that same
data into a json string. This patch removes the json formatting, to let
users of the module use the data in a python structure.

The patch also removes __main__ code from clr_rapl, as it is unnecessary
here. We might end up reusing some of this code in unit tests later, but
not right now.

This a partial import of github.com/coolr-hpc/pycoolr from
master branch, commit id: 67e7aa4b89b67744922b5926cd1459adf650013b

Coolr will provide us the capability to read power, topology and
msr-based sensors.

This patch links the sensor module with the coolr code as it is, which
doesn't really work. The core issue is that the current coolr code is
meant to be stand-alone, and the main functions to both sampling and
formatting of the data in json, by hand.

We will solve that in the next commit, removing the json-specific code
from the sample function to create a dict of values instead.

Create a `sensor` module that will handle the interaction with coolr and
return updated machine information regularly.

The code code is as dumb as the previous one, but the structure is
improved, which should help for the next round of updates with coolr.

Giving the deadlines we have, it's probably a good idea to keep things
simple and keep the application facing protocol exactly as it is, and
restrict it to just applications. This way we can keep using the argobots
tests as valid benchmarks, and at the same start building a decent
communication protocol on a different socket, with a better interface.

To clarify that, the daemon now use the word application to refer to
clients connecting on the "legacy" interface.

We'll add a different socket and start building a real protocol in
future commits.

The previous code was entirely inside the bin directory, which is not a
good idea in the long term.

This patch move everything inside the nrm package, so that we can start
building a proper code.

We chose to rewrite the entire thing in python. The language should make
it easy to interact will all the moving parts of the Argo landscape, and
easy to prototype various control schemes.

The communication protocol is exactly the same, but implemented with
ZeroMQ + tornado.

Power readings are not integrated yet, we are targeting using the Coolr
project for that.

This is a rough draft, all the code is in binary scripts instead of
the package, and there are no unit tests. Nevertheless, it should be
a decent starting point for future development.

The SC15/Chameleon experiments were based on a simple power management
scheme built with the help of beacon for transport, RAPL for monitoring,
and socket-based communications between the NRM and the argobots
runtime.

This is an import of the working code we had, in the state it was at the
time. It is quite obvious that this kind of one time hack, and it
probably doesn't work without the exact Chameleon setup.