DSTC Nimrod/G Installation and Usage Instructions

On this page you can find both Nimrod/G usage and installation instruction. You can get to these by following one of these two links:

Installation

The installation of Nimrod/G should be very straightforward procedure. In the binary distribution's base directory there should be a file INSTALL . This file contains brief installation instructions which should help you get started with Nimrod/G. Prior to installation you must ensure that you are running Python 2.0, Tcl8.0.5 and Tk8.0.5. Nimrod/G doesn't work with previous version of these packages. Newer version might work but we haven't tested them. As you can find in INSTALL file Python must be built with following modules enabled: This can be done by modifying entries in Setup.in file that can be found in ./Python/Modules/ directory of the Python source distribution. Example of entries that work for us can be see below:
<cut text...>
#nis nismodule.c -lnsl # Sun yellow pages -- not everywhere
termios termios.c # Steen Lumholt's termios module
resource resource.c # Jeremy Hylton's rlimit interface

<cut text...>
#rotor rotormodule.c # enigma-inspired encryption
syslog syslogmodule.c # syslog daemon interface

<cut text...>
# Tkinter module.
#
## The TKPATH variable is always enabled, to save you the effort.
TKPATH=:lib-tk

# *** Always uncomment this (leave the leading underscore in!):
_tkinter _tkinter.c tkappinit.c -DWITH_APPINIT \
# *** Uncomment and edit to reflect where your Tcl/Tk headers are:
-I@prefix@/include \
# *** Uncomment and edit to reflect where your X11 header files are:
-I/usr/include/X11 -I/usr/X11R6/include \
# *** Or uncomment this for Solaris:
-I/usr/openwin/include \
# *** Uncomment and edit for Tix extension only:
# -DWITH_TIX -ltix4.1.8.0 \
# *** Uncomment and edit for BLT extension only:
# -DWITH_BLT -I/usr/local/blt/blt8.0-unoff/include -lBLT8.0 \
# *** Uncomment and edit for PIL (TkImaging) extension only:
# -DWITH_PIL -I../Extensions/Imaging/libImaging tkImaging.c \
# *** Uncomment and edit for TOGL extension only:
# -DWITH_TOGL togl.c \
# *** Uncomment and edit to reflect where your Tcl/Tk libraries are:
@prefix@/lib/libtk8.0.a @prefix@/lib/libtcl8.0.a \
# *** Uncomment and edit to reflect your Tcl/Tk versions:
# -ltk8.0 -ltcl8.0 \
# *** Uncomment and edit to reflect where your X11 libraries are:
-L/usr/lib/X11 -L/usr/X11R6/lib \
# *** Or uncomment this for Solaris:
-L/usr/openwin/lib \
# *** Uncomment these for TOGL extension only:
# -lGL -lGLU -lXext -lXmu \
# *** Uncomment for AIX:
# -lld \
# *** Always uncomment this; X11 libraries to link with:
-lX11

<cut text...>

Once you have you environment setup all that is left to do is to install Nimrod/G. This can be done in three steps:

This should do it.

Using Nimrod/G

The process of getting Nimrod/G to run and finish your experiment involves few steps. The first one is to create a plan file for your experiment. You can see how to do this by looking at example that can be found in test directory inside binary distribution. The better way of learning how to create a plan file is by visiting page with EnFuzion manual. After you wrote your plan file you have to create a run file from it. This can be done by using EnFuzion. If you don't have an EnFuzion on your machine, well bad luck for the time being. I have written a little script that can do this for you. If you need it please ask me for it and I'll give it to you. In the meantime I will make sure that binary distribution soon includes this little program. Little update here, this script is included in the distribution now so you can use it to generate run file from a plan file.

<installation directory>/bin/nimrodgen <plan file>

Before you can create an experiment from a run file, first you must construct a gatekeeper file. Gatekeeper contains entries which tell Nimrod/G what resources are available for this experiment, what type those resources are, e.g. globus, fork, condor, legion etc. There are few other things that can be added to a resource entry but most of them won't be of any importance to you as they were part of our research. `gatekeeper` entry would look something like this

<type> <contact> <cost> <timezone>
Few examples:
fork localhost 0
globus bezek.dstc.monash.edu.au 0
globus bezek.dstc.monash.edu.au/jobmanager-condor 1
condor hathor.csse.monash.edu.au 1
legion dummyserver.csse.monash.edu.au 2

The cost field is just used for some of our experiments. There we basically cost a CPU cycle on some resource. Higher the number more it costs. This is going to be more clear a bit later. Similar situation is with 'timezone' where we used it simulate peak and off-peak time cost for different timezones. So, for example, at some time it would be cheaper for us to use local resources where at some time it would be better to use overseas or any other non-local resource.

One thing to note here is that your gatekeeper file has to be in the same directory where your run file is. Now that we have a gatekeeper file we can create an experiment. This is done by running:

<installation directory>/bin/nimrodcreate <run file>

This will print an experiment name on the screen, which is basically going to have run file's name, unless there is an experiment with such name. What is left to do is to fire up Nimrod/G by running

<installation directory/bin/nimrod

First window that shows up gives you an option of what experiment to run (see Figure 1.). After selecting an experiment Nimrod/G window will open (see Figure 2.). Wait until it loads all jobs. When that is done you can set the time, i.e. tell Nimrod/G when you want this experiment to be finished by, set the cost, i.e. tell Nimrod/G how much money you are willing to spend on this experiment (as I said before ATM this is just our experiment). Then you can tell Nimrod/G to try to minimise either the time or cost, keeping in mind that it still needs to try to finish within the set time and cost limits. These three things can be done by opening Experiment menu and selecting Deadline option (see Figure 3.). Once this is done, tell Nimrod/G to start the experiment and let it do its job.

Figure 1. Open Experiment window



Figure 2. Nimrod/G Interface 		So basically what you need to do to have Nimrod/G run experiment is these few steps(assuming everything is running without problems):
  1. Write up a plan file
  2. Create a run file by running
    <installation directory>/bin/nimrodgen <plan file>
  3. Write up a gatekeeper file
  4. Create an experiment by running
    <installation directory>/bin/nimrodcreate <run file>
    and record the experiment name it returns.
  5. Start-up Nimrod/G by running
    <installation directory>/bin/nimrod
  6. In Open Experiment window (Figure 1) select an experiment with the name you recorded in step 4 and click on Open button (or double click on experiment name. Whichever you prefer :)).
  7. Under Experiment menu select Deadline option. In Deadline window (Figure 3) set time deadline and budget and also select the optimasation (time or cost). Click on Set button :).
  8. Under Experiment menu select Start option.
  9. Wait until everything is finished (or something goes wrong)



Figure 3. Deadline window

Plan file

More to come soon...