GitLab

created by assign wrapper for linktrace.

Seems more intuitive that taking a snapshot does overwrite previous snapshots.
Does admit the possibility of excessive logfile buildup.

Nit-picky cleanups.

(i.e. not one for each direction).  Creates a single ".both" file rather
than ".recv" and ".xmit"

stopping!

creating masses of duplicates that are probably confusing the hell
out of the event scheduler.

Modify the monitor to use the event system directly via the python SWIG
wrapper object (requested by Rob).  The monitor no longer forks and execs
tevc for set_link operations.  Tested the additional code here by transplanting
it into a test script.  Works as expected there, but has not been tested
in situ.

Rob added code to let you put plab nodes in a LAN (with protocol "ipv4")
so that the LAN could be traced.

Meanwhile, Leigh has been adding completion events for various event types
and creating various combo event groups for addressing all elements of a LAN,
all LANs, etc.

For pelab we have a link "reset" event which is sent to the "__all_lans"
event group to reset the shaping of all links/lans.  Unfortunately, plab
nodes don't run a delay agent, so link events sent there fall on deaf ears.

Ergo, the event scheduler waits for completions from all agents it send
the "reset" to, but the plab nodes will never respond since there are no
link agents.

event groups, not an implicit group handled by the agent.

LeastSquaresThroughput now stores the last reported measurement to the monitor. It will send an authoritative report if the slope indicates saturation and the new measurement is different from the old. And it will send a tentative report of the slope indicates no saturation and the new measurement is greater than the old. Moderately tested(only in replay).

* generate the initial conditions for monitors to pass into the stubs
  (must use -i to start-experiment to do this)

* make sure install-tarball does not return til tarballs are installed!
  (or til timeout)

* move ip mapping and initial conditions files to /local/logs so they
  become part of the record

* fix up exit status' returned by auto-* stubs so program-agent
  can detect real failures

script will work on nodes and not just ops.

Add the -r option for calling from a remote (non-ops) node.

command-line.

elab nodes for the simple model - when no real plab nodes are being
used.

reload and halt events send proper completion events. This is required
for stoprun and startrun to work correctly. On stoprun the logs are
not collected until the programs have stopped, and on startrun we do
not want to proceed until all the agents have reloaded their
environments.

to wait for the completion event.

to tevc to wait for the reset to complete:

	tevc -w -e testbed/TT now link0 reset
or
	tevc -w -e testbed/TT now __all_lans reset

where __all_lans in another internally created event group.

knows when the logfiles are actually rolled.

Event groups complicated things a bit. To make this work properly, we
no longer subscribe to the link-tracemon event, but instead use a
real event group, created by assign wrapper for all of the linktrace
agents. So, you can know do things like this:

	tevc -w -e testbed/TT now link0_tracemon snapshot
or
	tevc -w -e testbed/TT now __all_tracemon snapshot

where __all_tracemon is a group of all tracemon agents for all links and
lans. I plan to change loghole to use this.

Make a single call to delaysetup with the new -r (restart) option.
Only subscribe to the lan-reset event if there are lan objects.

* sync the are-we-running-the-right-kernel? code with rc.<whateveritis>
  so that it behaves with a 5.x delay kernel

* modify to support a -r "restart" option so we don't have to invoke twice

Added better monitoring of replay save/load format. Changed census function to reduce the possibility of future size errors. New monitoring is hierarchical and should be essentially free as long as the #define in saveload.cc is commented out. Added LeastSquaresThroughput to the sensorlist and the definitions in monitor.py. A couple of miscellaneous fixes.

prompting will just fail anyway.

so they can be used in sequences.

/*
 * This check is for something I have, believe it or not, actually
 * seen - the SACK is for a range also being ACKed by the packet's
 * ACK field. It looks like the Linux stack can do this after a
 * retransmitted packet (possibly to tell the sender it has recieved
 * two copies?)
 * Anyway, I *think* we don't want to double count these bytes.
 */

Minor bug fix.

the Show Experiment menu to see if anyone uses it.

structure. SACK handling should now be fixed.

to make stoprun waiting work correctly.

When tevc is invoked with the -w (wait for completion) option, tevc
generates a token to put into the notification. The event scheduler will
not generate a new token if there is already on in the notification, but
instead pass it on.

For the specific case of stoprun, the simulator agent has to pass that
token along to boss and template_exprun, which generates the completion
event (for reasons discussed in prior commit message).

an int in twice.

Also fix another bug (masked by the previous) I introduced into
census()

Added secondary logging for node setup/teardown success/failure.  Also log
node pool membership changes in this log.

it got more complicated as it progressed.

The bulk of the change was changing template_exprun so that it can take a
pid/eid as an alternative to eid/guid. This is a big convenience since its
easy to find the template from a running experiment, and it makes it
possible to invoke from the event scheduler, which has never heard of a
template before (and its not something I wanted to teach it about).  Its
also easier on users.

Anyway, back to the stoprun event. You can now do this:

	$ns at 100 "$ns stoprun"
or
	tevc -e pid/eid now ns stoprun

You can add the -w option to wait for the completion event that is sent,
but this brings me to the glaring problems with this whole thing.

* First, the scheduler has to fire off the stoprun in the background,
  since if it waits, we get deadlock. Why? Cause the implementation of
  stoprun uses the event system (SNAPSHOT event, other things), and if
  the scheduler is sitting and waiting, nothing...