GitLab

You can look at the error code to figure out if it will ever be
possible to map this experiment onto the testbed.

the getbandwidth() call on them (which finds the closest matching
physical interface speed).

This is in addition to the normal bandwidth, and the difference is
that the estimated bandwidth is not enforced. It's just fed to assign
for mapping decisions. The idea is to allow for more efficient
packings by doing non-conservative bandwidth allocation.

Not documented yet, because it might change a little after I made it
work properly with asymmetric links.

agent was created for each link,link-vnode in a link/lan only when
that link has a delay/linkdelay. Well, with the link-agent that will
be used on wireless lans, lets just stick those agents into the table
for all links/lans in the experiment; its harmless. Might revisit this
at some point.

In the ptop file, put the specific protocol (ie. 80211a) on the link
line.

In the ptop file, there is now only one fake airswitch. It can take
on all wireless types. We now only print one link line for each
physical wireless interface - it has the maximum bandwidth supported
by the interface, and is able to take on any protocol supported by the
interface.

match what ptopgen puts into to ptop file.

and ptopgen.

Add link typing to assign. Each virtual link is given a single type.
Each physical link is given one or more types. A virtual link will
only be mapped to a physical link which can satisfy its type. In both
the top and ptop files, the link types are now mandatory, and they
fall at the end of the mandatory link arguments.

This differers from the 'regular' type system in two ways. First, a
plink is not constrained to filling only one type at a time. If we are
using emulated links, a plink could satisfy, say, an 'ethernet' link
and an 'fxp' link at the same time. This seems to more naturally match
the way we'll use link types.  Second, there are no counts assoicated
with link types, as there are for node types. ie. a link is not an
'ethernet:1' link, it's an 'ethernet' link. Presumably, when
multiplexing virtual links onto a physical one, it's bandwidth that's
the factor that limits the multiplexing.

The link type is now taken into account when constructing pclasses,
and in the mapping precheck.

As a side-effect of these changes, the silly 'count' argument on the
end of link lines in the ptop file, which was used for the fake LAN
nodes, is no longer supported.

The implementation could be a bit more efficient, but that would mean
tossing more of the stuff we do with boost's graph library. I think
this should happen, but today is not the day.

Modify assign_wrapper and ptopgen to spit out top and ptop files in
the new format.

Changed the constant LINK_UKNOWN to LINK_UNMAPPED - the new name more
accurately reflects the way this constant is used.

Add a new '-n' flag that tells assign not to do annealing, just exit
after the type precheck.

Clarify the usage message for the -c flag.

Removed some dead code for dealing with LAN nodes.

assign exits (exit codes).

* in assign_wrapper, no longer return any status from assign to the
  caller. This was pointless. Instead, return 0 on success, 1 on
  controlled error, and -1 on uncontrolled error (die() called
  someplace). Add in CANRECOVER bit whenever the wrapper exits, even
  if uncontrolled, by putting in an END block to catch the die. This
  should prevent certain cases where a swapmod error would be flagged
  as not recoverable.

* Remove most of the assign output processing since we no longer
  return its codes. Still print a portion of it to the log though.

* Change call to fatal() in assign_wrapper; do not pass an exitcode
  since in every case it was the same damn thing!

* Change tbswap to no longer carry assign_wrapper exit code to its
  exit.

* Change the batch daemon to treat all errors as continuable (keep
  batch queued) unless exit code is -1. We will need to revisit this a
  bit perhaps, when Rob adds precheck code.

moment if its not "ethernet" its marked as wireless. We will need some
extra info if we ever branch out into non-ethernet, non-wireless lans.
Might also want to record what kind of wireless lans at some point?

links.

* ptopgen:

   1. Change to using interface_capabilities table to get the default
      speed for an interface type.

   2. The wrinkle is that an interface can have multiple speeds,
      depending on the protocol that is requested. In the wireless case the
      table looks like:

	| type             | capkey            | capval               |
	+------------------+-------------------+----------------------+
	| ath              | protocols         | 80211a,80211b,80211g |
	| ath              | 80211a_defspeed   | 54000                |
	| ath              | 80211b_defspeed   | 11000                |
	| ath              | 80211g_defspeed   | 54000                |

   3. We use the above info to tell us the default speed for links, based
      on the particular protocol.

   4. And lastly, create "air" switches for each of 80211a, 80211b, 80211g,
      and specify links from the switches to the nodes that have interfaces
      that support those protocols. At the moment, there is a hardwired
      list of 80211a, 80211b, 80211g in ptopgen, so create 3 new air
      switches and links from each of the nodes to each of the switches.
      Rob says that assign can handle this just fine (using the same
      interface on a node to connect to three different air switches, at
      different speeds).

* assign_wrapper:

   1. First off, I had to increase the bogousity factor of how we determine
      that a delay node is required (requires_delay() routine) on a link or
      lan. Using the interface_capabilities table, I determine the default
      speed for each protocol on each interface type.

   2. When calling requires_delay() I now the pass the lan so that we can
      get the "protocol" of the link/lan and use that to find the default
      speed. The main reason for all this crud is that if a user specifies
      a bandwidth of 54Mb on a wired ethernet, we want to make sure we
      insert a delay node, but not if the user is using 80211g. As it was,
      delay nodes would be skipped cause there are now nodes with
      interfaces that support those speeds. This change also allows to know
      that a delay node should be inserted on a wireless link, if we ever
      wanted to do something as silly as that!

   3. Okay, so now onto the actual wireless support!  Whenever the protocol
      for a lan is not "ethernet" spit out links to fake lan nodes, sorta
      like we used to do with ethernet lans before Rob made all those great
      changes to assign. So, a lan with protocol 80211a will get fake links
      to the 80211a air switch that ptopgen spits out (see above).  We
      currently bypass all delay node processing on wireless lans, and in
      fact we avoid most post-processing (after assign) of wireless lans
      (no vlans, veths, etc). At some point we can bring certain things
      back in (like emulated links) but that will be some time! See
      comments above about ptopgen.

   4. Added a section to copy over the virt_lan_settings and
      virt_lan_member_settings to the interface_settings table, for each
      node's interfaces in the mapped experiment. I also make up the ssid
      for the lan, and add the protocol to the settings so that the client
      side knows what it is supposed to do. I also set the acesspoint since
      that requires MAC addresses, and this is easiest place to get and set
      the MAC (all of the nodes in a lan need to know the MAC of the node
      acting as the access point). In the virtual topology, the accesspoint
      is specified as a node name.

* tbsetup/ns2ir:

   1. Add tb-set-lan-protocol(lan, protocol) to set the protocol to one of
      ethernet, 80211a, 80211b, 80211g. Defaults to ethernet.

   2. Add tb-set-lan-accesspoint(lan, accesspoint) to set the name of the
      access point for a lan. Obviously this makes sense for only wireless
      links; ignored for wired links.

   3. Add tb-set-lan-setting(lan, setting, value) to specify a setting that
      applies to the entire lan. At present, these are ignored for wired
      lans. Both setting and value are strings.

   4. Add tb-set-node-lan-setting(lan, node, setting, value) to specify a
      setting that applies to a particular node in a lan. At present, these
      are ignored for wired lans. Both setting and value are strings.

parameter the virtual node it is being called for, and considers only
bandwidths that can be supported by physical nodes that virtual node
can be mapped to.

This fixes some cases where we were mistakenly setting interfaces
on slow links to 10Mbps, which does not work reliably.

Not surpisingly, tracking down problems with vtypes was half the
trouble with making this change.

of the interfaces table from bps (which they are in the
interface_types table) into Mbps.

Units for bandwidths in assign_wrapper are a total mess!

tbswap is doing a swapretry (this happens during a normal swapin, when
a node fails). In this case, we want to fix all the nodes (overriding
user setting) when replacing failed nodes!

a 100Mb link is mapped to a trivial link, a linkdelay has to be
inserted since the actual loopback bandwidth is much higher. The
problem is that unlike other delays where requires_delay() will return
true, this decision has to wait until after assign does the mapping
and we find out that a link was mapped to a trivial link. When this
happens, I insert a linkdelay "on the fly" when processing the link
statements from assign.

hash.

This means we have to call LoadVirtTypes() from a slightly different
place, so that we have the virt types before calling LoadPhysInfo(),
where %node_type_linkbw is built.

from commvirtsig-branch into main trunk

Two testsuite tests fail: tbcmd and vtypes . Need to fix.

node type, but allow it to be overridden with tb-set-jail-os().

other changes to the commvirtsig branch.

* Run assign with nice; when assign is cranking (or when two are
  cranking!) boss gets really sluggish (web, DB).

* Minor change to "impotent" option; run a little longer and print out
  what the vlan table would look like.

* Two trivial grammer changes.

parser with new functions tb-set-jail-os() and tb-set-delay-os()).
Prefer these over anything in the node_types table. Makes it easier to
test new images in the various configurations.

pnode. Used to no be allowed, but with multiple routing tables this is
now possible. My code to construct link names on the fly when delay
nodes are inserted, was generating non-unique names which was causing
vlans to be dropped.

vnode and a PC node, under normal circumstances, a real physical link
is used. However, a user can use tb-set-multiplexed on the link that
allows assign to map multiple vlinks over the same physical link.
This is fine when the PC is running FBSD-STD which can use veth
interfaces. Not so if it is running Linux or a non-standard BSD.
This fix forces EMULATED links and VETH devices when the PC is running
FBSD-STD and turns those attributes off otherwise so that assign
will not give a mapping that cannot be realized on the client side.
For the gory details of this problem, look at testbed-ops email thread
"pcvm route problem" dated 29th Jan 2004.

A problem still exists in the non-BSD router + jail vnodes in a delayed
LAN. VLANs table is not getting the correct entries. A fix will come
soon. Follow the testbed-ops email thread "fix for the pcvm route problem"
dated 29th Jan 2004 for the gory details.

(or more than one simhost) is unable to keep up with real-time. It includes
changes to assign_wrapper to handle swap modify for simnodes, the simple
algorithm in nseswap that bumps up the nodeweight of simnodes being hosted
on a simhost that reports "can't keep up with real-time" (aka nse violation),
ptopgen and sim.tcl to prefer nodes that already have the FBSD-NSE image.
Also, changes to other files to send out NSESWAP event.

One unrelated change: We now have per-swapin .top files and assign.log
files along with .ptop files. This helps in debugging across multiple
swapins since files remain in the form of
<pid>-<eid>-<process_id>.{top,ptop} and assign-<pid>-<eid>-<process_id>.log
Also useful for archiving.

again.

One of the fixes changes the way in which we iterate through pclasses
in find_pnode(). We used to treat the vector like a ring buffer, and
start (randomly) someplace in the middle. This turns out to give some
bad statistical properties when doing dynamic pclasses, since long
chains of disabled pclasses will cause some pclasses to be selected
more often. My old hack of just hopping around randomly in the
disabled-pclass case was bad, because it's hard to tell when you've
actually tried all the pclasses - so, we were getting false negatives
where it was looking like there was no place available where we could
map a vnode, which turned out to have worse effects than I had
thought.

So, now, we make a list of all the indices and randomize the order,
then just iterate through that list.

We also now count the number of pclasses that are enabled at every
temperature step, and adjust the neighborhood size to remove them.
This makes dynamic pclasses quite a bit faster - it cuts the time
by 30% - 50% for my test case.

Cleaned up find_pnode() by removing some #ifdef's that we don't use,
and probably will never want to again - this makes the function almost
readable!

not skipped in the case of 10Mb 0ms links.

Change ptopgen to look at the eventstate of a node; a node is not considered
free unless it is ISUP or PXEWAIT.

Add TBAvailablePCs() to libdb, removing the corresponding code from
assign_wrapper. This routine does the equiv of ptopgen, returning the
number of PCs that are available for use (looking at eventstate).

Change TBFreePCs in the web interface accordingly.

The above changes correspond to an upcoming change in stated.

now mapped to more than one PC if required. The simnode_capacity
column in the node_types table determines how many sim nodes can
be packed on one PC. The packing factor can also be controlled via
tb-set-colocate-factor to be smaller than simnode_capacity.

- No frontend code changes. To summarize:
  $ns make-simulated {
    ...
  }
  is still the easy way to put a whole bunch of Tcl code to be
  in simulation.
  One unrelated fix in the frontend code is to fix the
  xmlencode() function which prior to this would knock off
  newlines from columns in the XML output. This affected
  nseconfigs since it is one of the few columns with embedded
  newlines. Also changed the event type and event object type
  in traffic.tcl from TRAFGEN/MODIFY to NSE/NSEEVENT.

- More Tcl code in a new directory tbsetup/nseparse
  -> Runs on ops similar to the main parser. This is invoked
     from assign_wrapper in the end if there are simnodes
  -> Partitions the Tcl code into multiple Tcl specifications
     and updates the nseconfigs table via xmlconvert
  -> Comes with a lot of caveats. Arbitrary Tcl code such as user
     specified objects or procedures will not be re-generated. For
     example, if a user wanted a procedure to be included in Tcl
     code for all partitions, there is no way for code in nseparse
     to do that. Besides that, it needs to be tested more thoroughly.

- xmlconvert has a new option -s. When invoked with this option,
  the experiments table is not allowed to be modified. Also,
  virtual tables are just updated (as opposed to deleting
  all rows in the first invocation before inserting new rows)

- nse.patch has all the IP address related changes committed in
  iversion 1.11 + 2 other changes. 1) MTU discovery support in
  the ICMP agent 2) "$ns rlink" mechanism for sim node to real
  node links

- nseinput.tcl includes several client side changes to add IP
  routes in NSE and the kernel routing table for packets crossing
  pnodes. Also made the parsing of tmcc command output more robust
  to new changes. Other client side changes in libsetup.pm and other
  scripts to run nse, are also in this commit

- Besides the expected changes in assign_wrapper for simulated nodes,
  the interfaces and veth_interfaces tables are updated with
  routing table identifiers (rtabid). The tmcd changes are already
  committed. This field is used only by sim hosts on the client side.
  Of course, they can be used by jails as well if desired.

allows real PCs to run any OS instead of being constrained to FreeBSD. A
detailed discussion on this topic can be found in the testbed-dev mailing
list under the thread "links between vnodes and real PCs"

in the dev tree. I'm tired of problems on the mini that wastes
my time.

Changes include 2 new tmcd commands: tmcc routelist returns
the routes for all the vnodes hosted on a pnode. tmcc role
returns the role of a reserved node, like 'virthost' or
'simhost.  tmcc ifconfig now reports an RTABID field which
is calculated in assign wrapper. All the new changes
in assign wrapper will be checked in after I finish testing.

All the DB changes are in: simnode_capacity in node_types, rtabid in
interfaces and veth_interfaces. New NSE event_objtype and NSEEVENT
event_eventtype. Changed the erole field in the reserved table
to have 'simhost' instead of 'simnode'. Changed the correspoding
libdb subroutines.

more liberal about which links don't need delays. Before, we were
putting delays on anything that wasn't 100Mbps.

The other change is that for delay nodes, we set virtual link
bandwidths by rounding up to the next fastest speed of interface,
instead of hardwiring 100Mbps. Similarly, we set the speed of
physical delay interfaces to the card's 'native' speed instead of
hardwiring 100Mbps.

These changes work for our nodes and links, but are still not totally
general. Really, what needs to happen is that assign needs to be the
one to insert delay nodes, because it's the only place where we really
know which interfaces of what speeds are available on which nodes.
But, that is a very big project, since both assign wrapper and assign
need to be changed.

The idea is to give us hooks for grabbing experimenters' tarballs (and
RPMs) from locations other than files on ops. Mainly, to remove
another dependance on users having shells on ops.

tarfiles_setup supports fetching files from http and ftp URLs right
now, through wget. It places them into the experiment directory, so
that they'll go away when the experiment is terminated, and the rest
of the chain (ie. downloading to clients and os_setup's checks)
remains unchaged.  It is now tarfiles_setup's job to copy tarballs and
RPMs from the virt_nodes table to the nodes table for allocated nodes.
This way, it can translate URLs into the local filenames it
constructs. It get invoked from tbswap.

Does the actual fetching over on ops, running as the user, with
fetchtar.proxy.

Should be idempotent, so we should be able to give the user a button
to run webtarfiles_setup (none exists yet) yet to 'freshen' their
tarballs. (We'd also have to somehow let the experiment's nodes know
they need to re-fetch their tarballs.)

One funny side effect of this is that the separator in
virt_nodes.tarfiles is now ';' instead of ':' like nodes.tarballs,
since we can now put URLs in the former. Making these consistent is a
project for another day.

trivial simulated links. This is coz existing sim node support that
goes on 1 pnode can't handle this. Also added a 'sim' type in the
node_types table and a issimnode column in it.

Now, the old sim node support is working and demoable.

state machine (state). All of the stuff that was previously handled by
using batchstate is now embedded into the one state machine. Of
course, these mostly overlapped, so its not that much of a change,
except that we also redid the machine, adding more states (for
example, modify phases are now explicit. To get a picture of the
actual state machine, on boss:

		stategraph -o newstates EXPTSTATE
		gv newstates.ps

Things to note:

* The "batchstate" slot of the experiments table is now used solely to
  provide a lock for batch daemon. A secondary change will be to
  change the slot name to something more appropriate, but it can
  happen anytime after this new stuff is installed.

* I have left expt_locked for now, but another later change will be to remove
  expt_locked, and change it to active_busy or some such new state name in
  the state machine. I have removed most uses of expt_locked, except those
  that were necessary until there is a new state to replace it.

* These new changes are an implementation of the new state machine,
  but I have not done anything fancy. Most of the code is the same as
  it was before.

* I suspect that there are races with the batch daemon now, but they
  are going to be rare, and the end result is probably that a
  cancelation is delayed a little bit.

contain the latest image suitable for running nse as opposed to being
tied to an old FBSD 4.5 image.

does not reduce the number of nodes required by the number of already
allocated nodes. Even so, the test is fuzzy and assign might fail
anyway cause of node type requirements.

* Remove all of the code that dealt with allocating unconnected nodes.
  It used to be assign_wrapper passed all widearea node allocation
  decisions to wanassign, those in links and those that were
  unconnected. assign_wrapper now handles all unconnected nodes since
  assign is much better with features/desires and node type stuff.

* Do not modify any database state in wanassign; It used to do the
  actual nalloc calls, but now it just returns the mapping to
  assign_wrapper so that we can more easily track "recoverability" and
  because there is existing code in assign_wrapper to allocate vnodes
  on the selected pnodes. No point in duplication.

* Switch from mapping to vnodes, to mapping to pnodes. We made this
  change for other virtual nodes; instead of "fixing" to a vnode on a
  pnode, fix to the pnode. The resulting mappings are also given as
  pnodes, and assign_wrapper does the allocation on those selected
  nodes.

Now all we need is uptodate widearea data!