This documentation describes the application programmer interface of the Siena Fast Forwarding module (SFF). Technical documentation including the design of the forwarding algorithm and the general architecture of the forwarding module is available in a number of technical papers and within the source code.
The Siena Fast Forwarding module implements a generic forwarding engine for a content-based router. The engine is intended to be generic in the sense that it is intended to support multiple kinds of forwarding schemes and algorithms, and multiple data/addressing models. By forwarding scheme here we mean the way the forwarding information base (FIB) is structured as well as how the FIB is used to forward messages. An addressing/data model instead defines the form and semantics of the data/addresses used to set up the FIB, as well as the form and semantics of the data/addresses carried by messages and used as the main input in the forwarding function.
The current module implements one forwarding scheme with two particular data/addressing models. These two implementations are abstracted by the two interface classes AttributesFIB and TagsFIB. Other forwarding schemes and data models can be implemented by extending the FIB base class or even independently of that interface.
The current available forwarding scheme is one in which router interfaces are associated with predicates, and where an incoming message is forwarded to all interfaces associated with matching predicates except those indicated in a special exclusion set. This forwarding scheme can implement a simple forwarding on a tree, as well as a more general forwarding scheme such as the Combined Broadcast- and Content-Based routing (CBCB, see A. Carzaniga, M.J. Rutherford, and A.L. Wolf, A Routing Scheme for Content-Based Networking, INFOCOM 2004).
The current available data models are:
one based on attributes, where messages are described by a set of attributes and messages can be selected through combinations of constraints posed on the values of their describing attributes. In particular, a forwarding table is a one-to-one association of predicates to interfaces. A predicate is a disjunction of conjunctions of elementary constraints. The forwarding table provides essentially one match function that takes a message M and outputs the set of interfaces associated with predicates matched by M. This attribute-based data model is defined by values, attributes, messages, constraints, filters, and predicates, which are presented in the attributes.h header file.
one based on tags, where messages are described by sets and messages can be selected when their tag sets include one or more of a given list of tag sets. In particular, a forwarding table is a one-to-one association of predicates to interfaces, and a predicate is a list of sets of tags S1, S2,...,Sn such that a message M described by a set of tags SM would match the predicate if SM contains Si for some i. This data model is defined by tags, tag sets, tag-set lists , which are presented in the tags.h header file.
The API of the forwarding table is defined by the AttributesFIB and TagsFIB interfaces. Eight concrete implementations are currently available for the attribute-based model (AttributesFIB) each implementing a different matching algorithm: FwdTable, BTable, BTrieTable, SortedBTable, BXTable, BCTable, BDDBTable, and ZDDBTable. These last six implementations (BTable, SortedBTable, BXTable, BCTable, BDDBTable, and ZDDBTable) are based on encoded predicates and messages. Because of the nature of the encoding, these implementations are likely to generate false positives. Therefore, applications using these implementations should be designed to compensate for this behavior. (See BTable for more details.) The library also provides two concrete implementations of the TagsFIB interfaces with the TagsTable and TTable classes.
The SFF module is designed to operate on application data, namely on messages and predicates, regardless of the internal or external format of those messages and predicates. To make such application data accessible, SFF defines a minimal interface through which messages and predicates are read by the SFF algorithms. The application programmer must therefore implement this interface.
Specifically, the interface to application data in the attributes-based data model consists of the Value, Attribute, Message, Constraint, Filter, and Predicate interfaces and their iterators. Similarly, the tags-based data model is defined by the Tag, TagSet, and TagSetList interfaces and their iterators. A complete sample implementation of these interfaces is available from the Example Section. Specifically, see simple_attributes_types.h and simple_attributes_types.cc for the attributes-based data model, and simple_tags_types.h and simple_tags_types.cc for the tags-based data model.
In addition to its application programming interface, the Siena Fast Forwarding Module can be used through an external driver program. The command-line options of the driver program are documented here. The driver program reads commands from an input file or interactively thorugh the standard input. The commands understood by the driver include essentially all the operations of the forwarding table for both the attribute-based and tag-based data model. In particular, the driver can associate predicates to interfaces, and can request the processing of messages. Examples including the main commands accepted by the driver are available for both the attributes-based and tags-based data models from the Example Section. The syntax of the input to the driver is also documented in a separate page on the Driver Program: Input Format and Commands.