Introduction to FTA

The ITSimBw simulation environment is based on the Flip-Tick-Architecture (FTA) (Richter 1999), which has its roots in the JANUS project developed at the Gesellschaft für Mathematik und Datenverarbeitung (GMD)  (Beyer and Smieja 1994). At its core, FTA is a design paradigm for scalable distributed systems that exhibit a priorily unknown dynamic characteristics as well as disturbances and inaccuracies which are difficult, if not impossible, to model in a closed-form mathematical approach. As every multi-agent system, FTA is based on the concept of a society of agents (Weiss 1999). It comprises four classes of entities: actors (i.e. agents), assemblies, tags, and tag-boards.  

 

Agents and Autonomy

The aforementioned society of agents A is formed by a set of individual agents a_j, which are called actors in FTA terminology A = {a_{i, ...,} a_{j, ...} a_k}

Each actor a_j is composed of a set of typed attributes U_j, whose value assignment determines the agent’s state, together with an action function, which entails all operations that can be performed by the actor: a_{j = (}U_j=(u_1,j, ...,u_m,j),f_j).  

Structural information concerning agents, i.e. names and types of attributes, is described via agent types. Formally, we have type(a_j) = t, if and only if agent a_j is of type t.  The system supports agent templates that can be used to store prototypical value assignments. Thus, an individual agent can be created either by instantiation of its type, or by copying from a pre-defined template.

The principle of autonomy of agents forbids the direct manipulation of internal data structures and behaviors of other agents. Consequently, all interactions between agents are handled via messages. Formally, a message N_ν is comprised of a number of attributes: N_v = (u_{1,v, ...}u_l,v).

As agents, messages are typed entities. The set of all message types is given by N = { N₁, ... N_h}.

Upon receiving a request, the agent is able to analyze its content and to decide whether it wants to comply. The basic unit of execution is called a cycle. During one cycle, the agent reads its messages and triggers the appropriate actions, which might consist of writing messages to other actors.

An assembly is a set of agents sharing a common pace, i.e. all elements of an assembly have the same time resolution dt. This in turn implies that their cycles are synchronized and that the assembly switches from cycle to cycle as regularly as the tick of a clock. Hence the term Tick in FTA. It is important to note, that different agents do not necessarily share the same time resolution. Instead, the architecture supports individual running speeds for every actor. Moreover, time steps can vary from cycle to cycle. Thus, adaptive control of time increments can be realized (see below). This is particularly valuable for increasing the time resolution in the computation of dynamics equations for fast moving objects.

 

Communication

The messages used for inter-agent communication are called tags in FTA. We distinguish between three different categories of tags:

 

• Message tags are the carriers of communication between agents. Orders are embedded in message tags using XML syntax.
• Position tags contain the current position of agents. They are sent when actors change their position.
• Effect tags are used to mediate effects like weather influences, weapon impact, and the like.

 
Instead of setting up a direct communication with other actors, agents register with one ore more tag-boards, to which they send their messages. Thus, tag-boards serve as the functional units for handling messages in the FTA system. In formal terms, a tag-board forms a medium M_n for message exchange, while a FTA system is capable of supporting multiple media: M = { M₁, ... M_m}.

A tag-board consists of two sides. One is write-only and contains all tags sent to the board in time step t, whereas the other side is read-only and encompasses all tags written in time-step t-1.  Analogously to agents, each tag-board has its own time resolution and thus its own cycle time. During a board cycle, the write-only side is flipped over. Thereby, the read-only part mirrors the tag content of the write part from the previous time-step. The write-only side is deleted after flipping. In this way, the lifetime of tags is effectively controlled by the time-scale of the pertaining board. 

With this approach, fully synchronized (all agents and tag-boards share the same time resolution) as well as completely asynchronous systems (every agent and every board has its own time-scale) can be modeled in terms of the FTA.

The mathematical model of this agent architecture is a system of flexibly coupled inhomogeneous difference equations D = { D₁, ... D_k}, where each agent computes an equation from D. In this setting, the attribute list of an actor corresponds to the variable vector of the pertaining difference equation. Thus, equation D_i of  agent a_i computes U_i^t+dt = f_i(U_i^t), where dt_i denotes the time step size of agent a_i. During the iteration of  D, the society of agents runs through a set of states Z = {Z^t}, where each of these system states is the union of attribute sets from all participating agents.

 
Since the D_i are computed using potentially different dt_i , the involved agent  attribute sets U^t_i  might be undefined for certain t. In this case, either the U_i from the last time step of D_i  is used, or U_i is explicitly recomputed.  

A graphical visualization of FTA (omitting the discrimination of different tag-board sides) is shown in the figure below.