|
DUECA/DUSIME
|
Much of the flexibility of DUECA stems from the fact that it has an interface to a script language, Python in this case, and that a simulation can be specified in a script. The scripting language used to be Scheme, but DUECA has grown a Python interface that is more flexible and also more popular.
This page describes how to create the "big" dueca permanent objects (Environment, Packers, Transporters etc.) from a script, usually the dueca_cnf.py script.
If you create a new DUECA project, or add nodes to an existing project, the dueca-project script will create dueca_cnf.py and dueca_mod.py files for you. Modification of the dueca_cnf.py file is usually by editing the variables in the start of the file. In rare cases, it is useful to modify the Environment object, with specific options for the GL graphics, or with customized priority levels for the different activity managers.
If you want to know the options you can supply to the Environment, or any other object, carefully inspect the start-up blurp produced by DUECA, for example the following piece:
This is from a test project, with loads of ways to stress-test DUECA. The first lines are a bunch of "Adding module" statements. These are all the modules in the project itself.
After that, there are "Init from ... " statements. These are from different DUECA libraries, adding various modules and objects. As one of the last, the objects for starting DUECA are given. All configuration options for such an object can be retrieved, if you have a DUECA executable. For example, you can type:
This runs the executable with the DUECA_SCRIPTINSTRUCTIONS environment variable set. When that is detected, the creation command for the given module or object, in this case Environment, is spit out. This is the result:
dueca.Environment().param(
multi_thread = <boolean>,
# (#t or #f), determines whether to use multi-threading (deprecated)!
highest_priority = <integer>,
# >=0, highest-priority activity manager (also deprecated)
dummy_value = <integer>,
# dummy, for compatibility with old .cnf files
graphic_interface = <string>,
# "none", "gtk", "glut", "fltk", "gtk+fltk-gl", "gtk2", "gtk3"
# determines which graphic interface code is run. Note that the
# availability of graphic interfaces can depend on your link options.
graphic_use_depth_buffer = <boolean>,
# take a depth buffer with default size (16bits)
graphic_depth_buffer_size = <integer>,
# required size of the depth buffer, default=16
graphic_stencil_buffer_size = <integer>,
# required size of the stencil buffer, default=4
run_mode = <string>,
# specify run mode of DUECA, either "single" for single thread,
# "multi" for multi-thread or "fast" for a fast-time simulation
priority_nice = <array of integers>,
# Add activity priority level with nice value, values should be between
# -20 (not very nice, eat up most of the processor), through 0 (deflt)
# to 20 (very nice, do not impose at all. Note that priority level 0 is
# include by default.
priority_rr = <array of integers>,
# Add activity priority level with round-robin scheduling
# Linux priority levels currently go from 1 to 100
priority_fifo = <array of integers>,
# Add activity priority level with first-in, first-out scheduling
# See above for explanation on priority levels
x_multithread_lock = <boolean>,
# initialise the Xlib lock, to allow for multi-threaded access to X
# with this, you might be able to run an Ogre or SDL window in another
# thread. Don't count on mixing threads in gtk or glut windows
share_gl_contexts = <boolean>,
# share the gl context between the different GL windows. Note that this
# capability may not be present for certain windowing toolkits
command_interval = <double>,
# Interval (in sec) for rounding off module start and stop commands,
# default is 0.1.
command_lead = <double>,
# Lead time (in sec) needed for module start and stop commands,
# default is 0.1.
locale = <string>,
# If you want to use a non standard (. <> decimal point) locale, this
# needs to be specified in the configuration. Careful with datafiles!
)
'''Description:
The Environment manages the control logic of dueca.'''
You can see there are some options for depth buffers, stencil buffers, gl contexts, etc., however, in most projects these are not needed.
TODO: complete and modernize description
There are two ways to provide arguments to the created objects. The preferred one for the big objects - especially those with many arguments - is to use label and data pairs. The label is given as a scheme literal, and one or a number of data items of the proper type follow it, for example:
You can also give all arguments in a single list, just in the order in which they are defined in this file. This is often appropriate for smallish, simple objects, such as a priorityspec:
Currently (version 0.11.27) work has progressed considerably to make DUECA script calls self-documented. If you start dueca with the environment variable DUECA_SCRIPTINSTRUCTIONS set, then dueca will, for those parts that have been converted, spit out the scheme commands to create these, e.g. do:
Note that you do not need dueca.cnf or dueca.mod files to get the instructions. The following sections give a reference for all scheme-creatable objects.
The Environment is a basic object in DUECA, and it controls the flow of the program. It also creates the ActivityManager objects.
dueca.Environment().param(
multi_thread = <boolean>,
# (#t or #f), determines whether to use multi-threading (deprecated)!
highest_priority = <integer>,
# >=0, highest-priority activity manager (also deprecated)
dummy_value = <integer>,
# dummy, for compatibility with old .cnf files
graphic_interface = <string>,
# "none", "gtk", "glut", "fltk", "gtk+fltk-gl", "gtk2", "gtk3"
# determines which graphic interface code is run. Note that the
# availability of graphic interfaces can depend on your link options.
graphic_use_depth_buffer = <boolean>,
# take a depth buffer with default size (16bits)
graphic_depth_buffer_size = <integer>,
# required size of the depth buffer, default=16
graphic_stencil_buffer_size = <integer>,
# required size of the stencil buffer, default=4
run_mode = <string>,
# specify run mode of DUECA, either "single" for single thread,
# "multi" for multi-thread or "fast" for a fast-time simulation
priority_nice = <array of integers>,
# Add activity priority level with nice value, values should be between
# -20 (not very nice, eat up most of the processor), through 0 (deflt)
# to 20 (very nice, do not impose at all. Note that priority level 0 is
# include by default.
priority_rr = <array of integers>,
# Add activity priority level with round-robin scheduling
# Linux priority levels currently go from 1 to 100
priority_fifo = <array of integers>,
# Add activity priority level with first-in, first-out scheduling
# See above for explanation on priority levels
x_multithread_lock = <boolean>,
# initialise the Xlib lock, to allow for multi-threaded access to X
# with this, you might be able to run an Ogre or SDL window in another
# thread. Don't count on mixing threads in gtk or glut windows
share_gl_contexts = <boolean>,
# share the gl context between the different GL windows. Note that this
# capability may not be present for certain windowing toolkits
command_interval = <double>,
# Interval (in sec) for rounding off module start and stop commands,
# default is 0.1.
command_lead = <double>,
# Lead time (in sec) needed for module start and stop commands,
# default is 0.1.
locale = <string>,
# If you want to use a non standard (. <> decimal point) locale, this
# needs to be specified in the configuration. Careful with datafiles!
)
'''Description:
The Environment manages the control logic of dueca.'''
Having no graphical interface is useful on machines that need no window interface. Machines with the dueca control windows (node 0), need the gtk or gtk2 graphical interface (depending on the options you chose for linking). For presenting displays full-screen, glut is often best.
The Ticker is the basic clock in DUECA. It takes care that real-time processes get scheduled at the proper times, and implements the "waiting method", to keep the program running at the pace of the real-time clock
dueca.Ticker().param(
base_increment = <integer>,
# value by which integer time is incremented at each tick
compatible_increment = <integer>,
# increment at start-up of dueca. Must be the same for all nodes
time_step = <double>,
# tick interval, in [s], for the ticker
priority = <integer>,
# priority for the ticker process, defaults to highest available
sync_mode = <integer>,
# method used for synchronizing with wall-clock time
# 0=sigwait, this is a good mechanism for a master node on Linux
# 1=select. Very portable, but when available, use another method
# 2=nanosleep. This method works well on a QNX node slaving to
# another node, provided clock rates are not above 500 Hz.
# it is also the best mode for Linux with a high-precision timer.
# 3=real-time clock (Linux only). Obsolete, use nanosleep.
# 4=MsgReceivePulse (QNX only). Uses QNX timers and communication
# to implement a precise wait, ideal for high-frequency masters.
#
aim_ahead = <integer>,
# number of microseconds to aim ahead (negative) or after the clock time.
# set to a small negative number for high-precision timer systems, set to a
# (negative) fraction of the tick period to correct waiting with a high
# rate clock
)
'''Description:
The Ticker can trigger activities based on elapsed wall clock time.
Note that the ticker will block in a thread to wait on the clock,
meaning that you probably don't want to add other activities to that
thread/priority level'''
Note that the RTAI modes are usually not available.
DUECA keeps an integer time counter, to count the simulation program steps. The time step for the tickers in different nodes in a single DUECA system may be different, but the integer time counters must all run at the same pace. So you may have a 100 Hz (0.01 s time step) clock in one node, and specify that the basic increment per time step is 10, Each second, the time counter is advanced by 1000 (100 * 10). In another node, you might specify a 1000 Hz clock, time step 0.001. Its basic increment is then set to 1, to get the same advance in the time counter (1000 * 1).
A PrioritySpec object defines the priority of a module's activity.
dueca.PrioritySpec(<integer>,
<integer>).param(
priority = <integer>,
# Priority level, >= 0, determines the thread in which, and the
# ActivityManager by which, an activity is run
order = <integer>,
# Determines relative importance of activities in one prio level
# a smaller number means to come first, a larger one comes later.
# Logical time of an activity also plays a role. A difference of 100 in
# order is equivalent to one time granule.
)
'''Description:
Defines the priority of an Activity'''
When DUECA runs with multi-threading (see Environment ), different activities can be started in parallel. The "priority" determines the thread that will handle the activity, and the order determines which of the activities with the same priority gets handled first.
Packers are the components in DUECA that take data from channels that has to be transported to another node. They "pack" the data into a transportable format, and offer it to the transporter that has a communication link with the appropriate node.
A packer set is a combination of three packers, one for low-priority, "bulk" data, that will be sent when spare capacity is available, one for normal-priority data, that will be sent quickly and efficiently, and one for high-priority data. Note that the packer set does not always need three truely independent packers, in a simple solution it may contain three times the same packer.
You have to create a packer set for each of the other nodes in the system. In most cases, the packer sets all looks the same, but in this way the flexibility is built in to have different transport mechanisms for different priority levels of data and to the different nodes in the system.
The command to make a PackerSet is make-packer-set, and its arguments are:
dueca.PackerSet(<GenericPacker>,
<GenericPacker>,
<GenericPacker>).param(
low_prio = <object derived from ScriptCreatable>,
# A packer-compatible object, that does the bulk, low prority packing
# to another node
regular = <object derived from ScriptCreatable>,
# A packer for regular priority messages to another node
high_prio = <object derived from ScriptCreatable>,
# A packer for high-priority, urgent messages to another node
)
'''Description:
A PackerSet defines which set of packers (for low, regular and high)
priority messages channels data for a specific other node.
With a table of packer sets in the PackerManager, messages are
routed.'''
Note that you can have all kinds of packers in a PackerSet, as long as they are derived from the GenericPacker class.
The PackerManager maintains a table, one entry for each node, with a PackerSet in each entry. If data from a channel has to be sent to other nodes, the PackerManager table is consulted to determine which Packer(s) are used to route the data so that it is communicated to the other node.
dueca.PackerManager().param(
add_set = <object derived from ScriptCreatable>,
# A PackerSet. Repeat as necessary, one set for each node.
)
'''Description:
The PackerManager maintains an index of packer sets, each of these
packer sets contains three packer objects, for routing data to a
node at bulk, normal and high priority respectively. Specify a packer
set for each node in the DUECA process. The set of the 'own' node
will be ignored'''
The old way of specifying packer sets is with a vector of packer sets. Please note that the new method, repeated calls of 'add-set, each call for a new packer set, is preferred.
dueca.TimeSpec([<integer>],
[<integer>]).param(
validity_start = <integer>,
# start at which the time specification will be valid
period = <integer>,
# time span for which the specification will be valid
)
'''Description:
A periodic time specification.'''
The time specifications created from the script are in fact periodic time specifications. However, the can be used as a normal time specification also.
These cooperate with the IPBroadcastAccessor, the IPMulticastAccessor and the IPTwoWayAccessor.
dueca.Packer( ) '''Description: A Packer assembles data from channels that have ends on other nodes and offers this data to the IP accessor serving those nodes. Enter it in the appropriate PackerSets to indicate how data is routed, and supply it to an IP Accessor'''
dueca.Unpacker().param(
priority_spec = <PrioritySpec>,
# priority at which the unpacker will run
)
'''Description:
Unpacks data sent over IP accessors.'''
dueca.FillPacker().param(
buffer_size = <integer>,
# size of buffer for packing objects into = max size of sent objects
)
'''Description:
A FillPacker packs the bulk channel data, and offers these to an
IP accessor for transmission whenever there is spare capacity.'''
dueca.FillUnpacker().param(
priority_spec = <PrioritySpec>,
# priority at which the unpacker will run
buffer_size = <uint32_t>,
# size of unpack buffer, must be large enough to handle largest object.
# Match this size to the size you specify in the FillPackers. Size is
# in bytes
)
'''Description:
A FillUnPacker unpacks the bulk channel data.'''
The TransportDelayEstimator helps an IP Accessor to estimate round-trip and single-trip times for data messages.
dueca.TransportDelayEstimator().param(
const_delay = <double>,
# constant/offset delay, for setting up the message + overhead [us]
delay_per_byte = <double>,
# Amount of additional delay per byte, [us]
s_v = <double>,
# observation noise, standard deviation in [us]
s_const_delay = <double>,
# Process noise standard deviation constant delay [us]
s_delay_per_byte = <double>,
# process noise standard deviation per-byte delay [us]
innov_max = <double>,
# maximum on innovation step [us]
)
'''Description:
Helper class for media accessors that need to estimate a roundtrip time for the data transport.'''
These cooperate with the ScramnetAccessor and the ShmAccessor.
dueca.ReflectivePacker().param(
buffer_size = <integer>,
# size of buffer for packing objects into = max size of sent objects.
# size is in 4-byte words
priority_spec = <PrioritySpec>,
# priority at which the packing process will run
)
'''Description:
The reflective-packer prepares channel data for sending over SCRAMNet
or other devices with reflective/shared memory capability. Create
one or more reflective packers and add these to a packer set to
define which nodes communicate in what way, and supply the packers
to their corresponding media accessor'''
dueca.ReflectiveUnpacker().param(
buffer_size = <integer>,
# size of buffer for unpacking objects that "wrap-around" the
# communication buffer. Default is the size of the comm buffer itself.
# size is given in 4-byte words.
priority_spec = <PrioritySpec>,
# priority at which the unpacker will run
)
'''Description:
A DUECA helper object that will unpack and distribute the channel
data that comes in over a memory interface, currently SCRAMNet or
shared memory'''
dueca.ReflectiveFillPacker().param(
buffer_size = <integer>,
# size of buffer for packing objects into = max size of sent objects,
# size is in bytes.
packet_size = <integer>,
# size of chunks in which information is sent
set_timing = <PeriodicTimeSpec>,
# Supply a time specification to define the update rate of the main activity
)
'''Description:
Packs bulk priority data for sending over reflective/shared memory
accessors.'''
dueca.ReflectiveFillUnpacker().param(
buffer_size = <integer>,
# size of unpack buffer, must be large enough to handle largest object.
# Size is given in bytes
priority_spec = <PrioritySpec>,
# priority at which the unpacker will run
)
'''Description:
Unpacks bulk data sent over reflective/shared memory accessors.'''
To connect DUECA nodes together, the modern way is to use a DuecaNetMaster in one node and one or more DuecaNetPeer accessors in the other nodes. Almost all configuration settings are performed in the DuecaNetMaster, message size, frequency, communication protocol. The DuecaNetPeer accessors only need information on how to connect to the DuecaNetMaster.
If your simulation set-up uses multiple Ethernet networks, it is important to specify which interface you use to connect to the rest of the simulation; failing to do so will result in an initial connection, because the WebSocket protocol used for initial connection is fairly resistant to this, but when the simulation transitions to real-time running this leads to communication errors.
dueca.NetMaster().param(
packer = <object derived from ScriptCreatable>,
# packer that compacts to-be-transported data
unpacker = <object derived from ScriptCreatable>,
# unpacker that extracts data
fill_packer = <object derived from ScriptCreatable>,
# packer that compacts low-priority (excess bw) data
fill_unpacker = <object derived from ScriptCreatable>,
# fill-unpacker that extracts low-prio data
port_reuse = <boolean>,
# Enable port re-use, only necessary in specific configurations where
# multiple DUECA nodes run on one physical computer
lowdelay = <boolean>,
# Set lowdelay TOS on the sent packets. Default true.
socket_priority = <integer>,
# Set socket priority on send socket. Default 6. Suggestion
# 6, or 7 with root access / CAP_NET_ADMIN capability, -1 to disable.
if_address = <string>,
# IP address of the interface to use here
data_url = <string>,
# URL of the data connection, for both UDP and WebSocket connections
# UDP example: "udp://hostname-or-ipaddress:data-port"
# WS example: "ws://hostname-or-ipaddress:data-port/data". If you are
# using websockets for data communication, these must be on the same
# port as the configuration URL, but at a different endpoint.
public_data_url = <string>,
# Override the information on the data connection, in case clients
# connect through a firewall with port mapping. Provide a different
# client-side view of the connection.
config_url = <string>,
# URL of the configuration connection. Must be Websocket (start with ws)
# includes port, and path, e.g., "ws://myhost:8888/config"
timeout = <double>,
# timeout value [s]
packet_size = <uint32_t>,
# data packet size
n_logpoints = <uint32_t>,
# Number of cycles to assemble for for histogram logs of timing
# and capacity.
node_list = <array of integers>,
# List of nodes to connect
set_priority = <PrioritySpec>,
# Priority for communication
set_timing = <TimeSpec>,
# Time interval
)
'''Description:
DUECA net communicator server, master. Will open a server port on the
setup-port specified. Then waits for the nodes to join, in the
specified order, and establishes a communication over UDP; multicast,
broadcast or point-to-point, depending on the address specified'''
dueca.NetPeer().param(
packer = <object derived from ScriptCreatable>,
# Packer that assembles and compacts to-be-transported data.
unpacker = <object derived from ScriptCreatable>,
# Unpacker that extracts and distributed data coming in.
fill_packer = <object derived from ScriptCreatable>,
# Packer that compacts low-priority (possibly bulk sized) data.
fill_unpacker = <object derived from ScriptCreatable>,
# Unpacker that extracts low-priority data.
port_reuse = <boolean>,
# Enable port re-use, only necessary in specific configurations where
# multiple DUECA nodes run on one physical computer and use UDP comm.
lowdelay = <boolean>,
# Set lowdelay TOS on the sent packets. Default true.
socket_priority = <integer>,
# Set socket priority on send socket. Default 6. Suggestion
# 6, or 7 with root access / CAP_NET_ADMIN capability, -1 to disable.
if_address = <string>,
# IP address of the interface to use here. It is imperative to specify
# this when the computer has multiple options for Ethernet connection.
timeout = <double>,
# Timeout value [s], by default a high (2.0s) value is used, and the
# timeout setting is generally not critical for a peer.
config_url = <string>,
# URL of the configuration connection. Must be Websocket (start with ws
# includes port, and path, e.g., "ws://myhost:8888/config"
override_data_url = <string>,
# Option to override the data url sent by the master, in case network
# port translation is applied.
config_buffer_size = <uint32_t>,
# Configuration buffer size. This is the buffer used for initial
# connection to the master. The default (1024) is usually correct.
set_priority = <PrioritySpec>,
# Priority for communication. Note no other activities can use this
# priority level on a peer.
#
set_timing = <TimeSpec>,
# Time interval, needed when not running multi-threaded.
)
'''Description:
DUECA net communicator server, peer. Will connect to a server port
on the setup-port specified. Then waits for instructions to connect
data link and establishes a communication over UDP; multicast,
broadcast or point-to-point, depending on the address configured in
the server. Alternatively a websocket connection can be used.'''
Several different objects are available to access communication with IP protocols, normally over ethernet. For two-way communication, so two dueca nodes, the IPTwoWayAccessor is most appropriate. It is configured with the ip numbers of the two computers that need to communicate.
dueca.IPTwoWay().param(
packer = <object derived from ScriptCreatable>,
# packer that compacts to-be-transported data
unpacker = <object derived from ScriptCreatable>,
# unpacker that extracts data
output_buffer_size = <integer>,
# maximum size, in bytes, of the send buffer
no_output_buffers = <integer>,
# number of buffers for output. Minumum is 2, packer can fill one
# and the accessor can send the other
input_buffer_size = <integer>,
# maximum size, in bytes, of the send buffer
no_input_buffers = <integer>,
# number of buffers for input. Note that you may need quite a few
# e.g. with ten nodes, you fill nine buffers in one send cycle
# if bulk unpacking takes place at a low priority, you might want
# buffering for ten cycles, so 90 buffers
ip_address = <string>,
# IP address of the host at the other end
port = <integer>,
# base port number for the communication. Note that 2 ports are needed
if_address = <string>,
# IP address of the interface to use here
timeout = <integer>,
# timeout, in us, for the communication wait.
send_first = <boolean>,
# if true, this node sends first
one_way = <boolean>,
# if true, only sending, not receiving
time_spec = <PeriodicTimeSpec>,
# time specification for the send cycle
priority = <PrioritySpec>,
# Priority specification for the send/wait/receive activity
delay_estimator = <object derived from ScriptCreatable>,
# supply an estimator for set-up and per-byte transmit delay
fill_packer = <object derived from ScriptCreatable>,
# packer that compacts low-priority (excess bw) data
fill_unpacker = <object derived from ScriptCreatable>,
# fill-unpacker that extracts low-prio data
n_senders = <integer>,
# number of senders, alternative formulation to one-way
send_order = <integer>,
# order of this node in the send cycle, alternative formulation to
# one-way parameter
)
'''Description:
This is a DUECA communication media accessor, using point-to-point
IP communication with another DUECA node'''
If you have more than two computers, the best option, if all computers and your network switch support it, is to use multicast for communicating between these computers. A multicast address is configured, (which must not interfere with other multicast groups). A range of IP ports is used, if n computers are communicating, then 2n ports are needed. Consider this if you have trouble with firewalls!
dueca.IPMulticastAccessor().param(
packer = <object derived from ScriptCreatable>,
# packer that compacts to-be-transported data
unpacker = <object derived from ScriptCreatable>,
# unpacker that extracts data
output_buffer_size = <integer>,
# maximum size, in bytes, of the send buffer
no_output_buffers = <integer>,
# number of buffers for output. Minumum is 2, packer can fill one
# and the accessor can send the other
input_buffer_size = <integer>,
# maximum size, in bytes, of the send buffer
no_input_buffers = <integer>,
# number of buffers for input. Note that you may need quite a few
# e.g. with ten nodes, you fill nine buffers in one send cycle
# if bulk unpacking takes place at a low priority, you might want
# buffering for ten cycles, so 90 buffers
mc_address = <string>,
# Multicast address to be used, e.g. 224.0.0.1
port = <integer>,
# base port number for the communication. Note that 2*n port numbers
# are needed, with n = number of parties
if_address = <string>,
# IP address of the interface to use here
timeout = <integer>,
# timeout, in us, for the communication wait.
n_senders = <integer>,
# number of senders
send_order = <integer>,
# order of this node in the send cycle
time_spec = <PeriodicTimeSpec>,
# time specification for the send cycle
priority = <PrioritySpec>,
# Priority specification for the send/wait/receive activity
delay_estimator = <object derived from ScriptCreatable>,
# supply an estimator for set-up and per-byte transmit delay
fill_packer = <object derived from ScriptCreatable>,
# packer that compacts low-priority (excess bw) data
fill_unpacker = <object derived from ScriptCreatable>,
# fill-unpacker that extracts low-prio data
port_re_use = <boolean>,
# Enable port re-use, only necessary in specific configurations where
# multiple DUECA nodes run on one physical computer
)
'''Description:
This is a DUECA communication media accessor, multicast
IP communication with several other DUECA nodes'''
If for some reason multicast does not work, broadcast can be used.
dueca.IPBroadcastAccessor().param(
packer = <object derived from ScriptCreatable>,
# packer that compacts to-be-transported data
unpacker = <object derived from ScriptCreatable>,
# unpacker that extracts data
output_buffer_size = <integer>,
# maximum size, in bytes, of the send buffer
no_output_buffers = <integer>,
# number of buffers for output. Minumum is 2, packer can fill one
# and the accessor can send the other
input_buffer_size = <integer>,
# maximum size, in bytes, of the send buffer
no_input_buffers = <integer>,
# number of buffers for input. Note that you may need quite a few
# e.g. with ten nodes, you fill nine buffers in one send cycle
# if bulk unpacking takes place at a low priority, you might want
# buffering for ten cycles, so 90 buffers
mc_address = <string>,
# Broadcast address to be used, e.g. 192.168.2.255
port = <integer>,
# base port number for the communication. Note that 2*n port numbers
# are needed, with n = number of parties
if_address = <string>,
# IP address of the interface to use here
timeout = <integer>,
# timeout, in us, for the communication wait.
n_senders = <integer>,
# number of senders
send_order = <integer>,
# order of this node in the send cycle
time_spec = <PeriodicTimeSpec>,
# time specification for the send cycle
priority = <PrioritySpec>,
# Priority specification for the send/wait/receive activity
delay_estimator = <object derived from ScriptCreatable>,
# supply an estimator for set-up and per-byte transmit delay
fill_packer = <object derived from ScriptCreatable>,
# packer that compacts low-priority (excess bw) data
fill_unpacker = <object derived from ScriptCreatable>,
# fill-unpacker that extracts low-prio data
)
'''Description:
This is a DUECA communication media accessor, broadcast
IP communication with several other DUECA nodes'''