We are using Java byte-code as the language for active packets. In this regard, we have re-implemented our RSVP code in Java and we have also designed an execution environment (written in Java wherever possible and C otherwise). The main function of the execution environment is to accept packets, to load any code that is not available locally and to execute the code contained therein. The execution environment also provides a programming interface to active code, much like the JDK provides an interface to Java applications. The difference is that our interface contains additional functions that are useful for networking applications. The source code for the execution environment is located at http://www.isi.edu/active-signal/ARP/.
The scripts are written in 'sh' and 'awk' and have been tested on Solaris and FreeBSD. Basically, you need to create a number of command scripts (in 'sh') containing the commands for your particular simulation, and then SimScripts will start scheduling these command scripts on remote machines. Tasks will be scheduled until all command scripts have completed. Apart from scheduling, SimScripts takes care of some other things such as stdin and stderr for each command script and recording any errors.
The scheduling model is quite simple, and in particular there is no CPU load-balancing. For more information see the SimScripts home page at http://netweb.usc.edu/simscripts/. SimScripts was co-authored with Pavlin Radoslavov.
The Stanford Graph Base (SGB) topology format was used for all our topology simulations. The Stanford Graph Base package defines a file-based topology format as well as C structures. The SGB package includes various library routines for manipulating the C structures as well as SGB topology files representing data from various sources (eg. coordinates of cities in the USA).
The text "The Stanford GraphBase: A Platform for Combinatorial Computing" is available from the Addison-Wesley Publishing Company (ISBN 0-201-54275-7) and may be available in your local library. The source code as well as more information on the Stanford Graph Base can be found at ftp://labrea.stanford.edu/pub/sgb/. I suggest reading the book first because it is far more comprehensive than any documentation on the ftp site.
The advantage with using SGB is that it provides functions to convert topologies from file format to C structures and visa-versa. Another advantage is that the SGB library includes routines to find shortest distances and compute spanning trees etc., so one can reuse code. Although I recommend using the SGB topology format, the SGB C structures do have limitations. For example, one of the problems is that if you want to store per node state in the SGB C structures there are only a limited number of utility variables (see the SGB documentation). I didn't need extra state variables in my simulations, but if you do need such state then it might be better to design your own C structures (and then have code to convert from the SGB C structures to your C structures).
My recommendation is to use SGB to represent the topologies as files, but whether you use the SGB C structures or your own structures depends on the problem, and how general you want to be. You could use ns too, but ns is a more general purpose simulator and includes an event-scheduler. We have found that event-scheduling becomes burdensome for topologies greater than 50000 nodes and so our methodology has been to abstract the problem to avoid using an event-scheduler. Obviously, some accuracy is lost in this abstraction step, but much larger topologies can be studied.
The itm topology generator outputs SGB files, but some other generators, such as tiers (written by Mathew Doar) do not. In those cases where the generator does not produce SGB files, I have written converter programs to convert topology files to an intermediate form, which I call an adjacency-list form. I then use 'adj2sgb' (below) to construct the SGB topology file.
All the topology utilities listed below are bundled in sgb_utils.tar.gz. All the real and generated topologies for the above paper (as well as other topologies) are bundled in sgb_topologies.tar.gz.
adj2nam converts from an adjacency-list format to a nam format.
Nam is a Tcl/TK
based animation tool for viewing simulation traces and topologies.
adj2sgb.c converts from an adjacency-list format to SGB format.
sgb2adj.c converts from SGB format to
an adjacency-list format.
edges2adj converts a file containing a list of edges (represented
by two columns) to an adjacency-list format.
mbone2adj converts from ISI's mbone format to an adjacency-list
format.
tiers2adj converts from the Tiers topology generator output
to an adjacency-list format.
sgb2ns converts from the SGB to ns format. This utility is not
bundled in the above mentioned tar file, but is available from the
ns web site of
contributed modules.
A 'sh' script, called strrep, to replace strings, given as a 'sed' regular expression, in a list of files.
Some C++ code to implement arrays that perform bound checking at runtime. There are classes for single dimensional and two dimensional arrays. (See the README file.)