What is CABLE?
Development tools provided
Novel techniques used
Example of use
Evaluation
Exploitation
Further Information
Developer Information
CABLE is a key part of the GRACE system architecture. It provides support to users in the development and running of intelligent multi-agent applications. CABLE, developed by Logica for this project, is a highly productive environment for developing large and complex distributed applications for i) intelligent decision support and ii) modelling and simulation. It is particularly well suited to distributed software development projects of the type undertaken by the GRACE consortium.
Applications developed with CABLE consist of one or more CABLE agents which may be distributed over a network of computers. Agents work together to solve a problem, each one specialising in one or more specific tasks. Agents communicate with the end user via an HCI framework, FIONA. The primary mechanism, called the Digital Overhead Projector (DOHP), enables multiple agents to share a common presentation and user interaction facility. The figure below presents the structure of a typical CABLE application and shows its relationship to FIONA.
Multi-agent, multi-user architecture
Each CABLE agent is an independent autonomous software component with the potential for re-use. Construction of applications from independent software components offers many advantages including:
managing complexity by breaking a large problem down into several smaller ones
ease of maintenance through problem decomposition and clearly defined component interfaces
re-use of generic components from one application to the next
components can be added or exchanged at application runtime without the need for recompilation (plug and play):
easy path to incremental upgrades
supports ‘what if’ analysis by allowing components implementing different strategies to be substituted in and out of an application
suitability to distributed, team-based development such as undertaken in EUCLID.
CABLE has been designed to complement and enhance the underlying CORBA based architecture and is based on open standards wherever possible. The figure below shows CABLE’s software foundations (left hand side) together with some of the tools that have been used with CABLE to develop agent based applications (right hand side).
Standards (red) and COTS hardware and software (white) used on EUCLID RTP 6.1. CABLE and FIONA (yellow) together make up the multi-agent architecture software developed by RTP 6.1
CABLE provides a set of tools to support application development and management including:
the Agent Framework encapsulates the underlying communications architecture and platform specific technology in a C++ class framework making CABLE applications portable
the Agent Scribe converts agent specifications defined in an easy to use Agent Definition Language into components of the Agent Framework, enhancing developer productivity
the Agent Manufacturer establishes connections between a service requesting agent and a service providing agent at application runtime allowing application components to be substituted and distributed without the need for recompilation
the Control Panel is a graphical tool which provides application management functionality to end users and system administrators, for example it allows end users to launch and kill, potentially large and distributed, agent applications
the Visualisation Agent provides a graphical trace of the operation of an agent application as it occurs, improving application understanding and productivity
the CABLE real-time extensions support the development of time critical applications.
For a full description of the CABLE toolkit refer to the CABLE User Guide [PD 14.2.2]
CABLE can claim many novel aspects including the mixture of technologies that it brings together: CORBA, multi-threading, agents and AI. A comprehensive technical overview of CABLE can be found in the CABLE design documentation [PD 14.2.1]. However, there are two novel aspects relating to CABLE which are especially noteworthy:
Service Interfaces
Functional UNits (FUNS), which are organisations of agents.
CABLE agents communicate with one another through service interfaces. A service defines a set of methods (or messages) which may be called by other agents together with a protocol (or acceptable ordering) for calling those methods. To illustrate this, consider a Geographer agent that provides a RouteFinder service with methods to specify the start and end locations, specify any roads to avoid, and calculate the shortest route. It does not make sense to request the route before the start and end locations have been specified, although it would not be necessary to specify any roads to avoid before a route was requested. In short, a service interface is equivalent to the public interface of a class in object-orientation, but with an associated protocol. Service interfaces are unique to CABLE.
The figure below shows how service protocol can be represented graphically by a state transition diagram
A simple protocol for a Geographer service
The addition of protocol to a standard interface specification, such as provided by Java and the CORBA Interface Definition Language, greatly enhances the potential for component re-use since it provides potential clients with the information they need to know how to use the service. Traditional interface specifications only state what an interface does but not how to use it. CABLE incorporates a number of complementary features which are designed to exploit the benefits offered by service interfaces:
Activity synchronisation mechanism
CABLE agents are autonomous software entities, each with one or more threads of control. In order for agents to communicate, they must synchronise – i.e one must be willing to listen whilst the other must be willing to talk. CABLE provides an activity synchronisation mechanism that is similar to those provided by ADA. This allows agent developers to service the protocol as defined by the service interface specification.
Agent Manufacturer
Service interfaces encapsulate agent components in such a way that they can be substituted in and out of an application without the need for any recompilation. This enables the Agent Manufacturer to assemble the agent components that make up an application at runtime. Hence components are only loosely coupled to one another giving benefits such as: ease of maintenance, support for incremental upgrades, and support for distributed team-based software development.
A FUN is a special type of agent that represents an organisation of agents [ref - CADDIE]. Typically, a FUN agent will provide high level services to other agents by utilising the services of its member agents. Each FUN defines a set of roles which are filled by one or more agents. Roles have associated joining criteria which specify the services which an agent must provide in order to fill the role. The figure below illustrates the concept of FUNs applied to a simple model of Logica.
It should be noted that the use of FUNs is not restricted to modelling human organisations. Software functions provided by member agents can be organised by FUNs into higher level software functionalities for use by other agents so as to represent a breakdown of a high-level software architecture.
FUNs are a useful concept during application analysis and development and at application runtime. The FUN concept was adapted by Logica for this project from previous Logica work.
During application development, FUNs serve as a useful analysis tool for identifying the organisations of agent components that will make up the application. In order to support application developers in the process of FUN analysis , we have produced a set of guidelines. The guidelines, amongst other things, identify a series of key questions that should be addressed by developers in defining FUNs, roles, and services, for example:
What is the purpose for the FUN and what are its reasons for existence?
Who are the clients (users, FUNs or agents) of the FUN and how should they interface with it?
Thinking of the FUN as an organisation, what roles could be present within the organisation to carry out its major functions?
For a given role, which agent services contribute to its required qualifications for membership?
The analysis results in the production of a FUN specification which is used as an input to the Agent design phase.
At application runtime, FUNs allow the independent agent components that make up an agent application to have control over which agents should service their requests without compromising the loose coupling between agent components described in Section 9.1.3. For example, in the organisation shown in the figure above, Chris Dee might want to call upon the services of an accountant for advice on preparing a quotation – however, not just any accountant will do, it is the company accountant who is required. The CABLE FUN mechanism allows agents to communicate by virtue of their positions within an organisation, giving control over which agents provide services without compromising the loose coupling between agent components.
The most significant example of the use of CABLE to date is that of the GRACE demonstrator which is described throughout this document. Therefore an example has been chosen from another domain where CABLE was applied to distributed simulation modelling.
CABLE was used to develop a distributed simulation for Operations Other Than War (OOTW). The domain that was modelled was based upon the Rwandan refugee crisis in late 1996, where the United Nations were considering a peacekeeping operation in order to keep Rwandan refugees supplied with food and medicine, as well as keeping them apart from roving Hutu militia.
The figure below shows the agents and services that were modelled and a typical distribution across a network of 3 machines.
The three main players in the Simulation (shown on ‘Computer 2’), were defined as three separate agents:
United Nations (UN). The UN agent provides services to model both the distribution of supplies and defensive support.
Enemy (the Hutu militia). The Enemy agent models the behaviour of the Hutu militia, principally carrying out raids on potential sources of food and medicine, but also engaging the Refugees and UN in combat where appropriate.
Refugees. The Refugees agent is a more passive agent which provides a service to model the resupply and theft of both food and medicine by other agents.
Each of these so-called ‘in-the-field’ agents draw upon the services of other agents, for instance:
the Combat Model agent to identify the outcome of inter-agent engagements
the Environment agent to identify the appropriate route to travel avoiding potential conflicts and routes made difficult by the weather or heavy traffic
the Simulation Controller to provide co-ordination facilities to ensure that each agent remained in step with the other players in the simulation.
The use of CABLE offered the following benefits to application developers:
A close mapping between software structure and real world organisation allowing rapid modelling and development of the key components of the players in the simulation.
Granularity of model. The CABLE architecture allows ‘plug and play of more sophisticated implementations of agents, even allowing a single agent to be represented by a collection of agents, for instance replacing the UN agent with agents for each UN battalion. It is also possible to replace the existing UN agent with an alternative interactive implementation allowing man-in-the-loop experimentation.
A mixture of conventional and AI techniques in the implementation of agent behaviour. For instance the Environment agent uses a constraint-based approach to identifying the most appropriate route for a player to take.
Easy integration of legacy code. The Combat Model already existed as a body of FORTRAN code. The developers of the OOTW simulation were able to define services for the model and wrap the code inside an agent structure, so that it could be used externally.
These benefits have combined to ensure that an initial implementation has been developed in a far shorter timescale than would normally be the case.
This section presents the main findings of an evaluation study carried out at the end of the project [PD73]. The evaluation of CABLE involved:
performing benchmarking tests to measure agent size and runtime performance
conducting a user survey (including CABLE developers in the GRACE consortium and those working on Logica exploitation projects)
obtaining an assessment of CABLE from a military expert familiar with agent technology.
The main findings of the evaluation were:
CABLE adds little performance overhead compared to the use of CORBA alone.
CORBA adds approximately 3.5ms per remote call compared to a local C++ method call. CABLE adds approximately 4ms per call. This overhead is mitigated by CABLE’s support for developer productivity and application parallelism.
Significant performance improvements were obtained through distribution and parallelism (supported by the CABLE activity synchronisation mechanism).
Performance improvements of up to 300% were observed using 4 CPUs.
The Windows NT version of CABLE gave a 30% improvement in runtime performance compared to CABLE on Solaris.
CABLE does not directly support AI ‘strong agents’ (those with beliefs, desires and intentions), rather it is an enabling architecture for developing such agents.
Most users rated the system architecture a highly productive development environment and said they would use it again.
Perhaps the most powerful testimony of all to the value of the agent-based system architecture is the successful production of a large integrated system, containing 800,000 lines of code, by 17 different companies operating from 7 different countries with no full-time integration team.
In addition to the distributed simulation modelling project described in Example of use, several other exploitation opportunities have already been realised including:
Digitisation of the Battlefield
CABLE was used to develop an agent-based data trader, able to locate the optimal source of data taking into account such factors as: requirements for data quality and granularity, network bandwidth and latency. CABLE was shown to be well suited to this type of application. In particular:
the naturally distributed architecture in which the trader will operate is easily modelled by CABLE
the flexible component architecture proved valuable for incremental team-based development.
Situation Appreciation in Joint Operations
CABLE and the GRACE HCI Framework (FIONA) are being used to develop decision support tools for use in joint force operations in the United States. These tools require continuous monitoring and revision of the situation in order to keep information up to date. CABLE provides a productive development environment for developing distributed and parallel applications and is therefore well suited for developing such tools.
Distributed Simulation
A short study was carried out which compared the CABLE architecture with the High Level Architecture in order to establish relative strengths and weaknesses of each architecture and to identify ways in which CABLE could be enhanced to better support distributed simulation. The study concluded that CABLE provided valuable support for organisational modelling whilst the High Level Architecture offered a number of, near essential, features for developing distributed simulation. Although it was recognised that the architectures were fundamentally different in their approach, a means of enhancing CABLE’s suitability to distributed simulation was identified.
Further exploitation opportunities are being identified which will ensure that CABLE continues to be developed and enhanced. Potential areas for enhancement include: Support for distributed simulation, enhanced real-time support, a library of generic AI agents.
The latest version of the CABLE software may be downloaded from the GRACE FTP server (password protected). In developing CABLE, COTS have been used wherever possible to maximise functionality and reliability. The GRACE WEB site also provides detailed information on the COTS and versions required for using CABLE on both the Solaris and Windows NT platforms.
The CABLE user guide [PD14.2.2], detailed design [PD14.2.1], and application guidelines [W205], can also be downloaded from the GRACE FTP server (under password protection).
For further information, including obtaining passwords for the FTP server and WEB site, please e-mail cablesupport@logica.com.
Download a PDF version of the CABLE Paper for a more detailed description of CABLE.
For developers and users of Cable:
HTML documentation of C++ and ADL is produced by CGull.
 |
 |
 |
| Produced by: Peter Martin / Russell Gordon /
Mike Pockney Updated: 29 March 1999 Copyright Logica 1999 |
 |