Here are some major features:
- Create a network topology that contains switches (nodes) and computers (end-points) by a user-friendly graphical interface.
- The topology can be saved to disk to later usage.
- Specify the connection metric between nodes. The metric could be in uni-direction or bi-direction.
- Able to simulate different protocols.
- Each protocol is implemented as a separated library and will be plugged into the Simulator at runtime.
- Protocol developers are able to define data structure for the internal state of each node.
- Protocol developers are able to use their own message structure to exchange data between nodes.
- Visualize simulation progress
- Show internal state of each node.
- Show the input/output messages of a node in a time line (virtual time)
- Suspend/Resume the routing progress at one or more nodes.
- Visualize protocol reaction
- Allow user to change topology at runtime to see protocol reaction.
Please goto download area for the user manual.
The simulator consists of four major parts:
- Network Topology Editor: it contains a 2D graphic engine supporting end-user interaction for creating network topology. Each graphic object in the graphic engine is associated with a network topology element. These elements capture the static view of the network. Changes in the editor are sent to the Simulator Engine. Then it, in turn, forwards to the protocol handler.
- Protocol Simulator: it includes a simulator engine which coordinates message exchange between nodes. It also captures the runtime information of the routing protocol. The Simulator interacts with the Protocol Controller in order to control the routing progress.
- Runtime Visualization Engine: it is in charge of display the simulation information, e.g., internal state, input/output message of a node.
- Routing Protocol Plug-in: it consists of two components. The first one is used to communicate with the Simulator, receive events from Simulator and forwards these events to the routing algorithm. The second component is the routing algorithm which will be run in each node of a network.
- Application Runtime Services: are a set of services provided by the application so that the other function blocks can complete their jobs easier. An application service is defined in an interface which can be accessed through the application context. For instance, IPropertyWindow service provides access to the property grid so that any module of the application is able to manipulate the property grid if it can access to the context.
Network Topology Editor
The Network Topology Editor consists of following components:
- Graphic Engine: provides basic functions for edit 2D graphic document; and supports user interaction such as select objects, drag-and-drop objects. This application employs AGE (Another Graphic Engine).
- Network Document: acts like a network item collection.
- Network Devices: represent a computer/router/switch and connection.
- Network Device Renderer: is the painter of a device. The graphic engine uses item renderer to
- Network Topology Editor: is the window form that contains the graphic engine that allow user to interact with the document.
The Application Runtime Serivces, as mentioned above, provides essential services for the GUI Topology Editor completes their jobs. The following is list of services consumed by the Topology Editor:
- IPropertyWindow: The Editor uses this to put an object on to the property grid so that user has ability to modify objectís properties.
- IAppStatus: provides access to the main status bar of the application. This status bar displays current action of application module and shows the current mouse position, related to the active document.
- IToolBox: Thank to this service, the Editor knows whenever user want to select or create some kinds of object.
- INetworkProvider: consumed by the Network Item Renderer to get the color of the network that an item belongs to.
- IDocumentManager: provides access to list of opened documents and which one is active.
Protocol Simulator & Visualization Engine
When the simulation starts, for each connectable device which is item representing a computer/node in the topology, the simulation engine creates a runtime device and associates it to the connectable device. This runtime device provides a background so that the protocol routine can operate, which includes:
- A working thread that host the protocol executable code. Thank to the Routing Protocol Controller, this runtime device creates an instance of routing protocol class; and then executes the run() method of this class
- A set of essential operations for sending data, e.g., send(), broadcast().
- A working thread for receiving data from other nodes.
Routing Protocol Plugin
The Routing Protocol Plugin is a normal .NET assembly that publishes at least two classes: one implements interface IRoutingProtocolController and one implements interface IRoutingProtocol. The detail of these interfaces could be found in the User and Developer Guide document. Here we also discuss about important operations of each interface.
- IRoutingProtocolController: is in charge of creating protocol instance with given simulation engine and runtime device.
- IRoutingProtocol: is the main implementation of the routing protocol which have some important operations:
- Run() : executes the code for the routing progress.
- ReceiveData(): is executed each time the associated runtime device received a package.
- findRoute(): is invoked the runtime device to find an appropriate route for sending package.
Click here to download ATROSIM.