INTELLIGENT AUTOMATION INC.
Extending Rational Rose to support MAS design in UML
Intelligent Automation Inc.
2 Research Place, Suite 202
Rockville, MD 20850
http://www.i-a-i.com
presented by: Renato Levy
INTELLIGENT AUTOMATION INC.
Outline
• Introduction to IAI and its software tools
• Three-tier agent architecture
• Cybele
• Design of MAS using DIVA
• Problems and pitfalls
INTELLIGENT AUTOMATION INC.
Expertise
• Multi-agent Systems Design, Development and Simulation
• Distributed Computing• Scheduling and Logistics• Agent-based Distributed Control
INTELLIGENT AUTOMATION INC.
Software tools
• Cybele : Agent Infrastructure for distributed computing and inter-agent communication
• DIVA : A case tool with design document editing, online repository, runtime execution support service, verification and Cybele code generation
INTELLIGENT AUTOMATION INC.
Three Tier Architecture of IAI Agents
1- Role Layer:1- Role Layer: Describes the syntax and semantics of the roles this agent can perform in this application.
2- Adapter Objects:2- Adapter Objects: Makes the necessary translation between domain independent semantic of the role layer to the passive domain object expertise.
3- Domain Layer:3- Domain Layer: Represents the information content of an agent. Holds the domain expertise of the agent. Layer were existent legacy software can be easily reused.
INTELLIGENT AUTOMATION INC.
An Example of Role Interaction
Dutch Auction Art Buyer English Auction Art Buyer English Auction Car Buyer
Buyer
Buying Art
Adapter
BuyerBuyer
Adapter Adapter
Buying Art Buying Car
INTELLIGENT AUTOMATION INC.
Cybele : An Agent Infrastructure
• Provides location independent communication among agents with efficient flexible, dynamic multicasting
• Provides services for creating, migrating and terminating agents at run time
• Supports multi-threaded and shared-threaded
• Provides an activity model where an agent can work on multiple tasks concurrently
• Emphasis is on high-performance, scalability, flexibility and ease of use
• Current prototype of Cybele is implemented using the object-oriented paradigm with a Java API
INTELLIGENT AUTOMATION INC.
Cybele : Architecture Guidelines
• Cybele basics: Enforcement of the Activity-oriented programming interfaces or AOPI.
• Portability of users’ code: User-written agent code runs on any Cybele environment in which the needed services are available
• Reusability of users’ code: User’s code are re-usable even if services are modified
• Plug n play service: Encourage vendors to plug whatever service they desire into the Cybele to suite a particular platform
• Provision for addition of new services: Provide means for agent developers to add and access supplemental services without affecting the reusability and portability
INTELLIGENT AUTOMATION INC.
Cybele : Architecture
Distributed, Interactive Distributed, Interactive Computing Computing InfrastructureInfrastructure (DICI) (DICI)
Cybele KernelCybele KernelSupporting Supporting Three-tier architectureThree-tier architectureAnd AOPIAnd AOPI
Fundamental ServiceFundamental ServiceLayerLayer
Supplementary Supplementary Service LayerService Layer
Basic Service LayerBasic Service Layer
INTELLIGENT AUTOMATION INC.
DIVA
A design tool for agent based distributed system
Use an extension of UML as means for system description
Integrated with the industry leader Rational Rose 98i/2000e
Automatic code generation Maximize interaction and protocol
reusability Automatically generate
verification model from the same design document
INTELLIGENT AUTOMATION INC.
DIVA and Rose
Rose Extensibility Interface (REI)
•Model Semantics•Diagrams•Context Menus•Properties•Add-Ins
Add-In Registry
•Events•Stereotype files•Property files•Menu files•Data files
Rational Rose
Legend•Control •Data
Events•Rosescript•COM server
Stereotypes•Icons•String
Menus•Rosescript•External program
Extensible Properties•New tools/tabs•New properties
Rose Script•Code generation•Custom dialogs
•Shell•File I/O
•Web access•Environment
Add-In
COM Client/Server•Respond to events•Custom Spec Dialog
Java Bean /COM Server•Logic of Add-In•Choice of languages
Java ObjectsSource Files•Java Code•Promela Code
Java-COM Bridge
INTELLIGENT AUTOMATION INC.
Multi-agent System Design: Entities
• Physical entities of the System (MODEL)
• Agents
• Non-agent entities (such as databases, legacy classes)
• Protocols
•Roles
INTELLIGENT AUTOMATION INC.
Multi-agent System Design: Diagrams
Agents X MODEL -> Deployment Diagram
Agents X Hosts (distribution) -> Deployment Diagram
Agents X non-agent -> Class Diagrams
Agents X Protocols -> Class Diagram
Protocols X Roles -> Class Diagram
INTELLIGENT AUTOMATION INC.
Multi-agent System Design: Protocols
Protocols are defined as the description of a relation between two or more agents of the system. Any interaction between two agents are subject to a protocol ruling. The agents that play a part on the protocol perform according with the roles described on this protocol.
A protocol is described by a class diagram which depicts its roles and by a set of interaction diagrams which show the details of the exchange of information between such roles.
In Rational Rose®, protocols were created using stereotypes.
INTELLIGENT AUTOMATION INC.
Multi-agent System Design: Agents X Roles
In order to play a role on a protocol an agent has to adhere to an interface publicized by the role.
The interface required by the roles is automatically extracted by the DIVA case tool.
The agent implements the interface by means of delegation to non-agent object that conforms with the interface. (adapter objects)
INTELLIGENT AUTOMATION INC.
Multi-agent System Design: Role ClassesRoles are entities contained by protocols, that define the syntax of a protocol player.
Agents can play different roles on different protocols or even more than one role on the same protocol instance
INTELLIGENT AUTOMATION INC.
Role Design: State Diagram
Statename
entry: Delegate.EntryAction()entry: ^Recepient.M:OutgoingEventName(field1, field2)do: Delegate.DoAction()do: ^Recepient.M:OutgoingEventName(field1, field2)exit: Delegate.ExitAction()exit: ^Recepient.M:OutgoingEventName(Field1, field2)
IncomingEventName( field1, field2 )[ func() == const1 || var = const2 ] / Delegate.TransitionAction() ^Recepient.OutgoingEventName(field3, field4)
IncomingEventName( filed1, field2 )[ func() == const1 && var == const2 ] / Delegate.TransitionAction ^Recepient.OutgoingEvent(field3, field4)
A Role is defined by an enhanced state machine diagram, in which the information about the guard conditions and actions are detailed enough to extract the conversation syntax.
INTELLIGENT AUTOMATION INC.
Role Reusability
The correct extraction of the syntax of a conversation from the semantics and context that they carry is fundamental to provide role reusability across domains.
INTELLIGENT AUTOMATION INC.
DIVA: Interaction Protocol Verification
State Diagrams Of Roles and Sequence Diagrams of Interactions
Role and Adaptor Objects in Java
Concurrent Processes in PROMELA Script
Verified and Re-usable Roles and ProtocolsVerified and Re-usable Roles and Protocols
RoseScript, Java Bean/COM Server
PROMELA Translator
SPIN Tool
INTELLIGENT AUTOMATION INC.
Importing Protocols/Roles
DIVA’s repository allows validated protocols and roles to be shared and reused on several domains.
INTELLIGENT AUTOMATION INC.
Rose and UML pitfalls
• Rose is rather inconsistent on the way it can be extended by a third-party add-in. A variety of different techniques are needed to interface with Rose in order to accomplish the most simple tasks. (i.e. Rosescript, COM, ActiveX, Java beans, ….)
• Despite all the methods to interface with Rose there was no way to enhance its graphical output, forcing us to recreate some of the graphics on a separate child window.
• UML, as implemented in Rose, leaves too much room for free-form notes. In order to describe a complex system with less ambiguity, richer and more formal representation is needed.