LIP6 2000/020
- Thesis
Une approche componentielle pour la modélisation d'agents coopératifs et leur validation - M.-J. Yoo
- 168 pages - 10/29/1999- document en - http://www.lip6.fr/lip6/reports/2000/lip6.2000.020.ps.tar.gz - 2,046 Ko
- Contact : Min-Jung.Yoo (at) nullinfo.unine.ch
- Ancien Thème : OASIS
- Keywords : software component, mobile agents, agent framework, cooperation protocol, validation, colored Petri net, Java, Voyager
- Publisher : Valerie.Mangin (at) nulllip6.fr
Recently, applying the agent based technology to developping distributed cooperative applications is activated. We can mention the travel agency system within which various applications are in cooperation using a certain agent communication language and various types of cooperation protocols for the purpose of providing a composed travel service.
We analyse the characteristics of this system as follows:
1) developping and execution environment is opened.
2) agent cooperation.
3) agent mobility.
4) Validation problems
In this context, our work aimed to integrate the software developping phases : modeling, implementation and validation. Our issue contains :
1) How can a designer design, validate and implement a multi-agent system in convenient manner in considering the agent mobility ?
2) What is the best solution for using components within each developpment phase?
3) In what way, the implementiation of the same agent model under different types of platform can be achieved? To solve these problems, we have developed a mobile agent modeling and implementation environment with which the designer models agents using different types of software components which can be easily connectable and replaceable.
In this environment the agent modeling and implementation phase can be divided into three different phase:
1. In the agent modeling phase, the intelligent behavior and the collaborative aspect may be differently designed as distinctive components of the agent architecture concerning the mobility. This phase concerns only the abstract high-level agent model, that is to say, the designer does not need to directly manipulate the agent migration method which is specific to a mobile agent platform.
2. The compilation into Java source code and implementation phase makes it possible to generate automatically the operational Java code and implement the agent into a mobile agent platform, which corresponds exactly to the model specified in the 'modeling phase'. One benefit of our approach is to minimize the dependency of agent modeling and implementation environment from the mobile agent platform itself. This is shown by our experimentation with two different types of mobile agent platforms; one for JNA (JavaNet Agent) mobile agent platform [Merlat et al. 97] and the other with Voyager [Voyager 97].
3. The validation of multi-agents' cooperation protocols. In our system we also address the validation of conversation protocols before executing the agents in real world. After designing an agent model, the validation phase verifies certain basic properties of the conversation protocol (no deadlock, no livelock, etc.) through the translation of the protocol specification into a Petri net formalism. We have developed the Soft-Component Description (SCD) language in order to describe different agent parts as connectable components. The agent designer uses this language to model an agent behavior by defining component classes and then composing component instances.
The essential characteristics of SCD are that:
1. it is appropriate to describe the agent conversation protocols or the Task Controller components. SCD semantic is mainly based on the state/transition mechanisms. In case of 'Conversation protocol' components, it is pertinent to represent the conversation states and transition conditions to the next conversation state.
2. for modeling agent specific tasks the designer can encapsulate any Java programs into a connectable component using SCD syntax. This means that any Java application or Applet can be encapsulated and then composed within an agent architecture. For example, if we want to encapsulate a Java object as a connectable component;
3. SCD is able to describe a compound component which can be obtained by the composition of different types of component, i.e., the type 1 or 2 of components listed above, or the compound component itself. The translation from a componential model to a mobile agent is achieved automatically. Once the designer describes the component specification using SCD (SoftComponent Description), it is compiled into Java code which is then encapsulated within a mobile agent's execution body. We have implemented a compiler which produces Java source code from the component model specified using SCD. From one component class description, the compiler produces a component class definition in Java. One of the best benefits of our approach is that the agent modeling and code generation system is weakly dependent upon a given (Java-based) mobile agent platform. This is possible by the compilation of SCD into Java source code. There are some other agent platforms which compile their specification language in order to generate agents, namely SodaBot [Coen 94], LALO [Gauvin et al. 97]. In these cases, the compiled or interpreted information has been directly transformed into a specific agent platform. Thus it is difficult to adapt such systems to another type of environment. But in our case, the compiler generates Java source code which can be integrated into some Java-based agent platform. This has made easy the integration
We have validated the contract net protocol using a colored Petri net tools (CPN-AMI) and verified that there were no deadlock and the protocol terminated in an expented state. The model of contract net protocol was designed using SCD and translated into the colored Petri net by hands respecting some transformation rules.
We analyse the characteristics of this system as follows:
1) developping and execution environment is opened.
2) agent cooperation.
3) agent mobility.
4) Validation problems
In this context, our work aimed to integrate the software developping phases : modeling, implementation and validation. Our issue contains :
1) How can a designer design, validate and implement a multi-agent system in convenient manner in considering the agent mobility ?
2) What is the best solution for using components within each developpment phase?
3) In what way, the implementiation of the same agent model under different types of platform can be achieved? To solve these problems, we have developed a mobile agent modeling and implementation environment with which the designer models agents using different types of software components which can be easily connectable and replaceable.
In this environment the agent modeling and implementation phase can be divided into three different phase:
1. In the agent modeling phase, the intelligent behavior and the collaborative aspect may be differently designed as distinctive components of the agent architecture concerning the mobility. This phase concerns only the abstract high-level agent model, that is to say, the designer does not need to directly manipulate the agent migration method which is specific to a mobile agent platform.
2. The compilation into Java source code and implementation phase makes it possible to generate automatically the operational Java code and implement the agent into a mobile agent platform, which corresponds exactly to the model specified in the 'modeling phase'. One benefit of our approach is to minimize the dependency of agent modeling and implementation environment from the mobile agent platform itself. This is shown by our experimentation with two different types of mobile agent platforms; one for JNA (JavaNet Agent) mobile agent platform [Merlat et al. 97] and the other with Voyager [Voyager 97].
3. The validation of multi-agents' cooperation protocols. In our system we also address the validation of conversation protocols before executing the agents in real world. After designing an agent model, the validation phase verifies certain basic properties of the conversation protocol (no deadlock, no livelock, etc.) through the translation of the protocol specification into a Petri net formalism. We have developed the Soft-Component Description (SCD) language in order to describe different agent parts as connectable components. The agent designer uses this language to model an agent behavior by defining component classes and then composing component instances.
The essential characteristics of SCD are that:
1. it is appropriate to describe the agent conversation protocols or the Task Controller components. SCD semantic is mainly based on the state/transition mechanisms. In case of 'Conversation protocol' components, it is pertinent to represent the conversation states and transition conditions to the next conversation state.
2. for modeling agent specific tasks the designer can encapsulate any Java programs into a connectable component using SCD syntax. This means that any Java application or Applet can be encapsulated and then composed within an agent architecture. For example, if we want to encapsulate a Java object as a connectable component;
3. SCD is able to describe a compound component which can be obtained by the composition of different types of component, i.e., the type 1 or 2 of components listed above, or the compound component itself. The translation from a componential model to a mobile agent is achieved automatically. Once the designer describes the component specification using SCD (SoftComponent Description), it is compiled into Java code which is then encapsulated within a mobile agent's execution body. We have implemented a compiler which produces Java source code from the component model specified using SCD. From one component class description, the compiler produces a component class definition in Java. One of the best benefits of our approach is that the agent modeling and code generation system is weakly dependent upon a given (Java-based) mobile agent platform. This is possible by the compilation of SCD into Java source code. There are some other agent platforms which compile their specification language in order to generate agents, namely SodaBot [Coen 94], LALO [Gauvin et al. 97]. In these cases, the compiled or interpreted information has been directly transformed into a specific agent platform. Thus it is difficult to adapt such systems to another type of environment. But in our case, the compiler generates Java source code which can be integrated into some Java-based agent platform. This has made easy the integration
We have validated the contract net protocol using a colored Petri net tools (CPN-AMI) and verified that there were no deadlock and the protocol terminated in an expented state. The model of contract net protocol was designed using SCD and translated into the colored Petri net by hands respecting some transformation rules.