FDDA - Programming an algorithm

Algorithm = Nodes

When you're about to program an algorithm you want to demonstrate using FDDA, the main thing is to implement the node types that participate. Many algorithms don't need more than one type of node, but you can have as many as you want, of course. A node type distinguishes itself mostly by what it does when the algorithm is started and what it does when it receives a message. Each node type is implemented in a class which must be a subtype of fdda.algorithm.Node (though you may use NodeAdapter as a superclass for your convenience). You should implement one or more of the following methods, which are defined in Node and will be called during the demonstration:


A node may send messages to its neighbours using the methods provided in Node, e.g. sendMessage(Node, Object). You may also create the Message first (using createMessage(Node), e.g.) and send it later. A message can carry any payload, and you can let it have a special border color or a short label to show what kind of message it is. Each message sending operation returns whether it was successful: if a connection doesn't work, you can't send messages over it.

Active nodes

You may activate a node either in its start or its messageReceived method. The method run() of an active node is called by the framework once per cycle (which may be very often). It's probably better, though, to call the sleepTime(long) method, where you can specify a time in milliseconds after which the node will become active automatically. If you do this at the end of the run() method, it will become active periodically. While there are active nodes or nodes waiting to become active, the algorithm doesn't count as terminated. If you want to deactivate a node completely (only reacting to received messages), call the sleep() method.

Other Node methods

There are still a few other more or less important methods of Node that should be mentioned. You can change the color of the node and its label. And there's the method initialize. It is called after the node has been created and initialized by the framework. Only here - not in the constructor - is it allowed to use framework methods for the node initialization, e.g. to add or change properties.


If you like, you can add special properties to your node that the user may edit in FDDA. These Properties can be of type Boolean, Integer, Double or String (for your own types, read the advanced topics). You can configure them by setting so-called facets, e.g. to specify minimum or maximum values (see the API documentation for more information). You add or change properties by calling getModelNode() which returns the model Node that contains the algorithmic node. This model node is a PropertyHolder. You may also implement the PropertyListener interface if you like to react to changes immediately. A good example for the use of properties is the class for the Token Ring election algorithm.

The algorithm description file

Finally, you have to tell FDDA that there's a new algorithm. You do this by creating a small XML file that lists the node types and names the algorithm (the DTD is in the installation directory of FDDA, in the subdirectory DTDs; you can look at an example file here). Then you either create a subdirectory of the directory fdda/algorithms in your home directory and put the algorithm class files and the description file there, or you may bundle them into a jar file and place that in fdda/algorithms or a subdirectory. You can also change the top search directory for algorithms using the options dialog of FDDA.


There are two example algorithms to demonstrate how the framework should be used. The first is the echo flooding algorithm in a simple variant, the second one is the election algorithm for token rings with message extinction. The second one also uses an abstract superclass for nodes in a token ring.

URL dieser Seite: http://www.joerg-ruedenauer.de/Software/fdda/programming.html
Autor dieser Seite: Jörg Rüdenauer
Letzte Änderung am: 17.02.2004

L-Space now!     Valid XHTML 1.0!     Valid CSS!