Some Assembly Required

ProtoCollum™ makes it quick and easy to create a protocol model by providing a collection of objects that make up the essential components of a communicating system. By "connecting up" the objects, the user creates a system architecture that can be viewed in a display window, executed in a simulation window, or run in non-gui batch mode.

Connecting the objects to create a protocol model could be compared to using a tinker-toy set to create a physical model. This type of snap-together construction can be much faster than constantly crafting unique parts. It works best when the models being fashioned have many similarities, which is the case with communication protocols.

The ProtoCollum Edit sheet provides an intuitive point-and-click interface for organizing the communication objects. This small example, using the Fast-Message mode, was made with four mouse clicks.

1. The objects which do the actual sending and receiving of messages are called processing entities, their class is Pe_. So first we create a couple of Pe_ objects.
2. In the action (or result) area of a new Rule_, we add an action Event_ which can update the state of the Pe_ or can send a message.
3. In this case we connect the Event_ to a Msg_ object to indicate the sending of a message.
4. In the guard (or preconditions) area of a rule, the Msg_ arrives at a guard Event_. All guard events for a rule must be true in order for a rule to trigger (ie. do all of the action events).

Organizing Pe_, Rule_, Event_, Msg_, and Gate_ objects is all done quickly and easily by the point-and-click interface on an Edit sheet. This a large part of the work in creating a protocol.

State Your Purpose

It is often necessary for a Processing Entity to maintain state (like a transaction count for a sliding window protocol) for the proper operation of a protocol. This requires the user to write code; define state variables, assign values to the state, make decisions based on the state.

Even here ProtoCollum makes modeling easier by providing a framework where code can be added a small piece at a time. For example, a guard event will contain a single expression which can test the state of the Pe_ and/or the incoming Msg_ parameters.

The code pieces put into the objects are written in Tcl, a scripting language with a simple C-like syntax.

Here is a rule which has a guard Event which calls a function to see if the file associated with the passed in file descriptor fd is open or not. If both guards are true; the message has arrived and the file is open, then the rule named ruleClose will trigger.

The text seen in the diagram is for display purposes. The actual code in the guard Event would examine the message input parameter, as shown in the following Tcl expression:

[fops::isOpen($PmIn(fd))]