coordination and communication issues in multi-agent ... - CiteSeerX

COORDINATION AND COMMUNICATION ISSUES IN MULTI-AGENT EXPERT SYSTEM: CONCURRENT CONFIGURATION DESIGN ADVISOR Anatoli S. Koulinitch

Leonid B. Sheremetov

Universidad Tecnológica de la Mixtéca, Km. 2.5 carretera a Acatlima, Huajuapan de Leon, Oaxaca, CP 69000, México Tel. +52-953-20214 Fax. +52-953-20399 e-mail: [email protected]

Centro de Investigación en Computación, Instituto Politécnico Nacional, Unidad Profesional Adolfo López Mateos, Apdo# 75476, México, D.F., C.P. 07738 Tel. +52 - 5-7296000 ext.56576 Fax. +52 - 5-7296000 ext.56593 e-mail: [email protected]

CONCURRENT CONFIGURATION DESIGN ADVISOR

Acknowledgments - The Ministry of Science and Technology of Russia initially supported the work described under the grant N236/132. The experiments never would have succeeded without the contribution of the group of researchers and programmers of the laboratory of computer integrated systems of St. Petersburg Institute of Informatics and Automation of the Russian Academy of Sciences (SPIIRAS). Support for this work has been also provided by the CONACYT, Mexico, within the projects: “Development of methods, algorithms, and system for process modeling based on graph grammars” (N 3923P-A) and by the National Technical Institute, Mexico, within the project: “Development of autonomous agents for virtual multiagent environments".

COORDINATION AND COMMUNICATION ISSUES IN MULTI-AGENT EXPERT SYSTEM: CONCURRENT CONFIGURATION DESIGN ADVISOR Abstract

The model of concurrent configuration design and the architecture of Concurrent Configuration Design Advisor (CCDA) are considered. The CCDA is developed as an open dynamic expert system of interacting agents. In the context of this article a configuration problem is defined as a decision-making procedure performed by concurrent processes (agents). The analysis of concurrent and sequential activities in this system is based on structural transformations (in the form of graph grammars) that permits to define correct criteria for data integrity and consistency of configured project data model and to model conveniently any dynamic changes in the project. This approach also makes it possible to handle complex hierarchical data structures of real configured objects and to model communication and synchronization of decision making in distributed expert system in a common formalism. The system to be configured is decomposed into structured objects, called fragments. The proposed model consists of 3 types of agents. D-agents are those, capable of the object configuration design within the constraints on their attributes. To cope with agents' coordination, objects' consistency and data integrity problems, a special type of agents, facilitator or F-agent, is introduced. Finally, project assistants or A-agents are responsible for the user interface at the stage of object model definition. The discussion is illustrated with the examples from the application domain of flexible manufacturing systems. Experimental results, current and future work on the expert system implementation are considered.

1. INTRODUCTION Since the first commercial success of XCON and XSAL (originally titled R1), developed in collaboration between the Carnegue Mellon University and the Digital Equipment Corporation for the configuration of VAX computers (McDerrmott, 1982), configuration design forms one of the problem domains of constant interest for the expert systems (ES) technology. Complex systems of different nature can be configured in an enormous number of ways according to the specific requirements of each customer. The later becomes the core design point for a number of application domains from Application Specific Integrated Circuits (ASICs) to Flexible Manufacturing Systems (FMS), to mention just few of them (Smirnov et al. 1995b, 1996). The combinatorial complexity of this problem is enormous and, as such, certain models of problem domain knowledge representation and heuristic rules are to be employed to reach an acceptable configuration within a reasonable time frame. It implies a need for new algorithms and program structures able to perform simultaneously configuring procedures. Distributed knowledge processing and concurrency becomes a fundamental requirement, providing cooperation between expert systems in engineering (Klein 1991, Frost and Cutkosky, 1996; Jennings et al., 1993; Jennings, 1994). A new way of programming and understanding of complex systems by means of interaction between agents was first realized by Hewitt (Hewitt, 1977). Later these ideas were developed within a number of frameworks as, for instance, distributed problem solving (Durfee, 1988). Now agent technology radically alters the way in which we conceptualize and build software systems (Genesereth and Ketchpel, 1994; Müller et al., 1997; Singh, 1994; Wooldridge et al., 1996). The notion of an open expert system as a dynamic system of interacting agents means the necessity to place coordination and concurrency issues in the center of investigation (Werner, 1996). In this work graphs and graph transformations is used to model different aspects of open, concurrent and distributed expert systems. Graph transformations are common formalism for specification of states, flexible changes in structure and properties of configuring objects, coordination and synchronization of agents’ concurrent activities (Ehrig and Mahr, 1990; Rosenberg, 1997). Analysis of concurrent and sequential activities in distributed expert system based on structural transformations (in the form of graph grammars) permits to define correct criteria for data integrity and consistency of configured project data model and to model conveniently any dynamic changes of its

structure. Moreover using this approach it is possible to handle complex hierarchical data structures, which real configured objects usually have, and to model communication and synchronization of decision making in distributed ES in a common formalism using dependencies among concurrent hierarchical activities. In our approach the ES is represented as a collection of loosely coupled autonomous agents that organize communication among them by passing messages based on project model specifications. This paper describes the algorithm of concurrent configuring, discusses the agents' coordination based on graph transformation specification of agents' interfaces and considers the multiagent architecture of Concurrent Configuration Design Advisor (CCDA) the multiagent expert system prototype, which has been developed. In Section 2 the algorithm of concurrent configuring is proposed. Three types of agents are introduced supporting the algorithm execution. In Section 3 we describe a two-level object model developed for the objects with hierarchical dynamic structure. In Section 4 the declarative Pattern presentation of the object model described in Section 3 is presented as a high level graph model and the use of graph transformations for agents' coordination is described. In Section 5 the layered communication architecture of CCDA is analyzed. Finally we discuss the results of the provided experiments and future work directions. Illustrations are made from the FMS configuration design domain.

2. CONCURRENT CONFIGURING: A PROBLEM STATEMENT Configuring is the construction of technical system according to the requirements of a specification by selecting, parameterizing and positioning instances of suitable types from a given catalogue (Serrano, 1991). In the context of this article a configuring problem is defined as a decision-making procedure performed by a number of concurrent processes (design agents), each of them solving a local configuring task for one part of the technical system. These parts are called fragments. Fragment is a unit of decision making in configuring task. The system to be configured is represented in the form of multi–level, hierarchical structured objects. The later can be assumed for the applications we have analyzed. Configuring of a project in the CCDA is based on multi-level decomposition and concurrent fragment design. An agent is associated with each task of fragment configuring. We call this agent a ‘design agent’ or D-agent. Each D-agent is oriented to solve a fragment configuring problem on its level organizing a solution search. A template is a structured model of a

fragment (object model). It can define an atomic type, as a machine tool, for example in the case of the FMS configuring, or be a complex model (FMS cell). A component is an instance of a template. It has valued attributes and can be considered as a solution. So the problem of configuring is considered as a concurrent decision making at different levels of design tree with fragments denoting the solutions. A parallel algorithm for this problem can be structured as follows. Initially, a single D-agent, responsible for the entire project configuring, is created for the root of the tree. The agent evaluates its node and then, if that node has no solution, creates a new agent for each fragment of the current fragment template (sub-tree). Each sub-tree consists of a community of Dagents. These agents play the role of virtual fragment server (predecessor node) and clients (successor nodes) respectively. This community of D-agents forms a region. A D-agent captures its fragment for configuring and each time, when called to expand a node, checks the components database (CDB) to see whether the node in question has a solution. If not, the algorithm searches the pattern database (PDB) to find a new structural model of a fragment, which has the nearest functional characteristics to the captured one. A channel created for each new task is used to return to the new task's parent all the solutions located in its subtree. Hence, new agents and channels are created in a wavefront as the search progresses down the search tree. This process is applied recursively to find a solution set from CDB or to produce a set of fragments that cannot be subdivided further. Figure 1 depicts the process of top-down configuration design. All the relations between components are described in terms of constraints. The solution of constraint satisfaction problems (CSPs) is the assignment of values for each attribute of the object model in such a way that all the constraints are satisfied. These constraints can change dynamically during the constraint relaxation procedure, so the model can be defined as a dynamic network of constraints (DNC). (Insert Figure 1 about here) Dashed ellipses represent project fragments, for which a solution can’t be found in the CDB, and then the process of logical fragment decomposition begins (fragment f n , sub-levels n1 and n2 ). Each D-agent associated with f n at the n level (server), uses different heuristics to create M fragments of the configuring task by activating M agents (clients) at level n+1 to configure the fragment.

DNC on each level is created by sub-fragment constraints, generated by means of constraint propagation and the rules of compatibility of components, because concurrently created solutions can’t be independent. Each rule of compatibility is represented by first order predicate language and has a set of attributes, which are considered by the algorithm of fragment definition. A D-agent utilizes inferencing techniques to reason about feasible D-agent operations over a project and so can be conceptually viewed as a virtual project server. To have an opportunity to choose the best solution from the possible solution set for different templates, a set of clients for the same task can be generated, as shown in Fig. 1 for the component m at the level n+1. Finally, if no template is found, an agent of another type - a ‘project assistant’ or A-agent - is generated to create a template. Template generation can be viewed as a knowledge acquisition procedure, performed by domain experts and supported by an Aagent. A project server (an arbitrary decomposable Dagent) receives an expert assignation query from one of its clients (from n+1 level) and generates an A-agent for the selected expert. CCDA contains the database with the expert’s experience, professional level and problem domain. Unfortunately in many cases a deadlock is reached, i.e. an agent can’t decompose its fragment or find appropriate solution. In this case D-agent transmits a message to the upper level, asking for the relaxation of constraints. In the case a solution can’t be found for the fragment, an agent can try to transform a part of the template into a new structure, using new component models. This query can be transmitted in a wavefront to the upper levels, trying to transform n-level template. So, the main problems to be solved in this case, are how to coordinate D-agent activities and where this coordination can take place to maintain the project data consistency and integrity. Only two alternatives are possible: a supervised control and distributed decentralized coordination. The first solution, as the experience of distributed systems development has shown, can be rather expensive to the system performance. The second one is more difficult to realize but it is more natural for multi-agent systems. The solution we propose is to utilize the internal hierarchy of the problem domain (hierarchically structured objects) and to include the coordination mechanisms directly into the model of the structured object. To cope with coordination, consistency and data integrity problems, a special type of agents, facilitator or F-agent, is used. It has the functions of local (between the D-agents of the same level within one fragment) and global coordination (i.e., between the

facilitators of the adjoining fragments or regions). To accomplish the later task, facilitators of the adjoining fragments need to share common knowledge, stored in the KB in the form of the interface graphs (IG). Also they need to possess the inferencing capabilities, based on the analysis of the rules of fragment consistency, and be able to coordinate their activity. So, the proposed configuration design strategy exploits inherent parallelism in the configuration design process for structured objects and supports the search of the effective solution within the existing design decision space.

CDB contains knowledge about fragments and components available for configurations. The ideal representation paradigm for the component is an object-oriented hierarchical model, where the similarities between component types are used to construct taxonomy with the components as leaves of the class tree. An atomic component is an object of a given type with a set of attributes formed according to the subject domain knowledge. Figure 2 shows an excerpt from a component definition for a prototype that configures FMS on the cell level. (Insert Figure 2 about here)

3. KNOWLEDGE REPRESENTATION MODEL OF HIERARCHICAL OBJECTS WITH DYNAMICALLY CHANGING STRUCTURE As we've mentioned in the previous Section, the process of configuring in CCDA consists of three main stages: 1. 2. 3.

A component search in CDB for each fragment, A template search in PDB for each fragment, A fragment template design, supported by an Aagent.

During the first stages D-agent defines new characteristics of existing component or pattern model of a fragment. At the last stage D- and A-agents have to deal with the objects with dynamically changing structure and a model supporting this feature has to be designed. The main focus of this Section is to discuss the model of structured objects, employing semantic data structure and flexible mechanisms for the configuration design support. A two-level Object Model is proposed that defines a uniform and coherent specification of both the information about current object state, and of object behavior, with the state transitions represented by the finite set of rules.

3.1 Representation of a Fragment In a DNC formalism, a fragment is represented by a graph G = {N , A} , where N is a set of nodes (components), A is a set of edges (relations between components). A set of consistency constraints is associated with every edge, the edge (i , j ) existing only if Qkm ( Tik , Tjm ) succeeds for all objects i and j, where

Qkm

is a set of constraints to make consistent

attributes belonging to k-th and m-th types, Tik , Tjm sets of attributes for nodes i and j respectively.

The attributes are specified according to the following structure, providing an example of requirements specification for the ‘payload capacity’ attribute: Name (a pointer): Attribute (project feature): An object type: Operator (comparison): Goal (required attribute value): Precision (acceptable deviation):

M_payload_capacity payload capacity Machine = (is equal to) [10.000 14.000] 5 (%)

The exception knowledge is attributed to the component types or classes it applies to, with different possible levels of expressiveness. Knowledge about simple incompatibility between components may be attached to a component as (i) a list of incompatible components checked against when a new component is selected or (ii) predicate logic expressions about unacceptable partial configurations, which form a checking procedure.

3.2 Two-level Object Model To support a fragment model with flexible structure we had analyzed various methods using the object approach to information representation of components with changing behavior to take advantages of object oriented formalism. Finally, we have developed an approach based on the use of two level object representation. At the first level, the object model has a fixed structure, which can not be changed in configuration process. For example a model of each machine tool for the purposes of the FMS configuration is usually fixed. Each object at this level pertains to its own class in the classical object oriented model sense and possess all general mechanisms, such as encapsulation, inheritance, and polymorphism through functions interfaces.

At the second level, the object model has a flexible structure and can be changed during configuration process. This object model description is called Pattern or Template and is presented in a script format. To maintain the persistent property of this kind of objects we have developed the PDB management system. This system has flexible mechanism for versioning to maintain a register of all the changes produced during a configuration process. A template definition has the following structure: Pattern Name _Of_ Pattern (model name of the second level is fixed by &P ) {ObjectID: object identification code; Parts: slots for sub-object with a name of each object type (class name of objects is specified by &C prefix for objects of the first level of the representation scheme supporting object-valued attribute model); Patterns: slots for other patterns used in current one (these patterns are used as template objects at the second level of the model supporting pattern-valued attribute model without the recursive mode definition); Attributes: slots for attributes supporting basic variable types such as int, float, string and structures generated by them. Rules: an open set of pattern transformation activities presented in the form of a rulebased configuration operation (graph transformation rules within the single pushout algebraic approach model); Constraints: a graph structure of property compatibility for sub-objects and patterbased objects contained in the model of the object } Patterns section forms the interface to other templates providing hierarchical structure of configuration process, Attributes section describes static template structure and Rules section describes dynamic properties of object model. We can not fix in advance all design configuration operations, so we define this set as open. A designer has a flexible tool for rule construction with integrity and consistency control of results (see the next Subsection). These controls are based on high-level graph transformation mechanisms, which will be discussed later. Constraints section defines property compatibility conditions on object states, which are used as pre/post conditions in rule-based transformations. As an example, we give the pattern &PCell of object type FMS cell, which has been used in the experiments, described in Section 6:

Pattern &PCell { ObjectID: ; Parts: &CMachineK A: NK, &CMachineI: Q, NI ; &CRobots: Z,NP; Patterns: &PConfiguration Conf1; &PTransport_System G; &PStore SCl-2Vert Attributes: : float Gen_Length, Gen_Width; float Efficient; Rules: Constructor, Update-Position(Item, X, Y); Select_Robot( &CMachineK, ), Insert_Machine(&CMachineI) Constraints: Graph_C1; } In Parts section we don't fix the number of elements, which can be changed in a dialog fashion by some rulebased transformation. At the same time, this transformation will change current configuration and graph_C1, which has been presented in Constraints section. Nodes of graph_C1, are references to the objects in Parts and Patterns sections (see the next Section for details). To organize integrity support of all related parts of Pattern representation, a special graphic tool supports the designer, permitting him to control the property integrity. The Patterns section with TConfiguration for &Tcell describes configuration property for the object model. Two levels of the object model are supported independently, so the Master Tool specially designed for A-agent has the mechanisms to make transformations between the levels of object representation. If a designer has a fixed model of an object at the second level, this model can be transformed to the first level by the operation of rewriting of CDB to PDB. To define a new configuration structure, which doesn't have the first level model, two options are available for a designer. First, he can define a new class. It requires OO programming, while there are no evidences yet that this particular structure will be useful. So we propose the use of templates with less developed mechanisms of object orientation, but more easy to support. In the case of being useful, later on, this template is converted into the object model of the first level. It should be mentioned that all the objects and their class models are independent from the Pattern model.

3.3. Project Assistant A project assistant is an agent that supports expert knowledge acquisition for a template design. A Dagent tries to find a template in the KB, corresponding to its level of abstraction. If it does not exist, an Aagent is generated. It is associated with an expert to perform the functional fragment representation

mapping into the agent’s structural model described above, i.e. a new template generation. To perform the expert assignation task, the expert’s KB is revised and the appropriate expert is selected. In order to supply an expert with the facilities of the object model, Master Tools are implemented. A Project Expert Tool is a compiler that processes the rules defining integrated constraints. The following types of integrated constraints are supported: • global constraint, applied to all components, • global additive constraint, processed as an addition of all attribute values belonging to the selected type, • group constraint, applied only to the components of the selected type. Conjunctive and disjunctive functions are supported for all the types of constraints. Figure 3 depicts the Master Function tool interface of an Aagent. As shown in this figure the taxonomic structure of the component and resource type catalogues is exploited best with the familiar GUI allowing the definition of rules of compatibility of components. Functional constraints are organized as a DLL library for functions, defined for object classes. (Insert Figure 3 about here) The Master Function mode is used to define specific functional constraints for selected components by associating component attributes with function arguments. These constraints are used by the checking procedure during the template design. It is possible to create a link between two components (e.g. mru and tpk-125b in Fig. 3) only if the appropriate predicate expression checks that all the constraints are satisfied. Any component type description can be removed together with all the knowledge pertaining to it without consequence for the rest of the PDB.

4. AGENT'S COORDINATION: SYNCHRONOUS AND ASYNCHRONOUS DISTRIBUTED GRAPH TRANSFORMATION The algebraic methods of graph transformations (GTs) approach based on graph grammar for computing, i.e. for specification, implementation and efficient coding of concurrent and distributed D-agent (client) actions are used (Korff, 1994; Ehrig and Mahr 1990). The coordination mechanisms of these actions directly follow from equationally axiomatized specification in the form of GTs. In our approach, attribute graph grammars provide the theoretical background for

structural and informational modeling of fragment properties (Lowe et al., 1993).

4.1 Graph Transformation Mechanism GT mechanism specifies a rule-based system, because its operations are presented in the form of implications, in which both the precedent and the consequent parts are graphs, defining a previous and a new state of a fragment. In the case of the use of preconditions for the values of attributes, we have conditional rule-based design. A distributed current project state is modeled by splitting a project state graph into a local and a global interface graphs (IGs). A configuration problem for F-agent, analyzing all the appropriate fragments for the region of the project is considered as a virtual dynamic framework (VDF), represented by a graph. An F-agent uses VDF as a basic model for amalgamation of concurrent productions, coordination and control of concurrent transformation process. Operations on a VDF are represented by conditional graph productions. Updating actions specify formally Create, Delete, Insert, and Modify operations over the fragments. A VDF is used to obtain external constraints on the captured fragments. These constraints can be built upon the arcs through the external or internal interface elements of the local DNC maintained by a D-agent. The splitting of the project graph into a set of local graphs for each node of the distributed project model with global IGs, which are represented by replication elements of project state, is described in (Ehrig and Lowe, 1993). This splitting is based on conditional graph grammar for single-pushout approach that we use in our model. One way to calculate dynamic constraints for captured fragment is to process the local IG using only D-agent's local knowledge base (LKB). Another way is to process also the global IG, if the replication of another part of distributed KB is used. Direct concurrent GT of two simultaneous fragment updates is either independent (asynchronous) GT or amalgamated (synchronized) GT. An F-agent can produce a fragment model gluing the distributed local graphs along with their IGs for the fragment updating. In this work a normal form of distributed GT is used. Interval constraint-satisfaction problem (ICSP) algorithms based on interval arithmetic are developed in order to find the consistent states of VDF supported by F-agents. These states correspond to the feasible solutions of fragment configuring. The ICSP assumes that domain values are intervals and uses standard interval arithmetic to evaluate node- and arcconsistency.

Satisfaction of application conditions of GT implies VDF structure integrity (e.g., the absence of dangling edges, those that have lost their source and/or their target nodes) and consistency of data model of a fragment. Application conditions include context conditions like certain embedded restrictions concerning constraints (Csuhaj-Varjú, 1993). These application conditions provide intermediate level of expressive power between context-free and contextsensitive graph grammars. Using the second level of the declarative Pattern presentation of object model described above, we have a single unit for all the relevant information concerning one object. This model is presented as a high level graph model equipped with object-valued and patternvalued data types (attributed graph).

4.2 Pattern-based Object Definition Let us consider the example of FMS cell object definition (PCell-A) using Pattern model: &PCell PCell-A { ObjectID: ID_Pcell-A; Parts: &CMachineK ID_CMash-St; &CMachineI: ID_CMash-Tok; &CRobots: ID_CRobot-Usi; Patterns: &PConfiguration PConf1 {ID_CMash-St: 200; 1300; ID_CMash-Tok: 450, 2500; ID_CRobot-Usi: X, Y;} &PTransport_System ID_PTS-Hor2; Attributes: Gen_Length: 1400; Gen_Width: 2900; float Efficient: X1; Rules: Update-Position(&CX, float X, float Y); Select_Robot( &CMachineK S), Insert_Machine(&CMachineI V) Constraints: Graph_G1; } The Pattern-based object definition permits to create an object with undefined values of attributes, which later can be defined or redefined at any stage of the configuration process. We can create many objects from the given Pattern, but if we change some type in the Pattern, we need to define a new Pattern with a new name. For example, if we insert in the FMS cell a new type of machine tool - &CMachineZ, the CCDA will ask to define a new Pattern for this new object. Implementation of Pattern member functions is defined outside the Pattern definition: &PCell:: Update-Position(&CA, float new_X, float new_Y) {&CA.X = new_X; &CA.Y = new_Y;}

This operation can be used to change the coordinates of the element &CA in the cell PCell-A: PCell-A.Update-Position (ID_Robot-U, 350, 1850) In our approach graph grammars are used as a computational model of concurrent configuration process for objects with the flexible structure. All rulebased operations on graphs are performed in the following fashion: • a transformation for the graphical part - gluing of production subgraphs to the graph-structure of fragment containing Constraints specification Graph_ C1, • change of the data values associated with the nodes for the same Pattern, • and finally, the attribute compatibility between the Graph_C1 and the object in Parts and Patterns sections are verified. This model supports concurrent Pattern model manipulation, where the access to the Pattern description is done by naming, using Term Graph Rewriting Systems (Papandopouls, 1996). This approach is also capable of supporting imperative techniques such as destructive assignment, which is applied for modeling of object behavior with dynamically changing states. As an example of graph-grammars-based FMS cell configuration design, we describe an operation in which a number of robots supplying machine tools has changed (fig. 4). (Insert Figure 4 about here) The production P is represented in the form of P =&CX → &CX, &CX, where &CX defines the type of an object, containing in the Pattern. Application of production P to the Pattern &TCell is represented in the form of configuration process as P(&CRobot ID_Crobot-U) PCell-A. The problem is that direct application of the production P to the object PCell-A will generate redundante arcs between &CMachineI and &CRobot object types. These arcs are shown in Fig. 4 with dotted lines. To reduce the complexity of arc representation in the Pattern model a number of problem domain heuristics are applied in CCDA. One of them, for example, defines that “if equal number of service elements are used with equal number of production elements then each service element is to be assigned to one production element". This rule will remove dashed arcs after the analysis of the obtained graph, notifying an F-agent about it.

5. CCDA ARCHITECTURE The CCDA architecture is composed of a collection of agents of different nature that communicate through abstract interfaces. In the following subsections we'll consider the role of facilitators incorporating mechanisms, described above, and the layered communication architecture of CCDA.

5.1 The Role of Facilitators In the CCDA architecture F-agents perform the main coordinating role in the system performance. From the communication point of view, each facilitator (also called mediator or information agent) is responsible for providing an interface between a local collection of agents and data sources or/and remote agents. Traditionally, facilitators use to serve four purposes (Wiederhold, 1992): 1. 2. 3.

4.

Providing a layer of reliable message-passing, Routing outgoing messages to the appropriate destination(s), Translating incoming/outgoing messages for consumption by agents or/and data management system, and Initializing and monitoring the execution of its agents.

In CCDA the functions of facilitators are much more sophisticated (Fig. 5). They are responsible for coordination and conflict resolution during a fragment configuring. To cope with this task each F-agent (facilitator) has two types of additional facilities: 1. 2.

Means for graph transformations to coordinate and synchronize concurrent fragment configuring, Constraint propagation inference engine to propagate constraints to all the sub-fragments in the case of constraint relaxation query from one of D-agents. (Insert Figure 5 about here)

Communication and coordination, therefore occur between D-agents, D-agents and facilitators, A-agents and facilitators and among facilitators, depending upon the fact, to what region communicating agents belong. This arrangement of agents and facilitators is called federation architecture. Each D-agent client tries to find fragment solutions based on its own criteria and send it to the D-agent of the next level in the form of a proposal. All these concurrent proposals are evaluated. If they satisfy interval constraints then D-agent sends the

confirmation message and writes these proposals to the KB & DB. If agreement can not be reached, the conflict occurs and F-agent is activated. It sends messages to relax some constrains, consistently decreasing their restrictive power to the D-agents participated in each conflict. These messages also can contain some recomendations on constraint relaxation. These steps are repeated until a satisfactory decision is achieved or it is recognized that conflict can not be solved due to the over-constraintness. In order to be supplied with or/and store the relevant information about templates and components D-agents and A-agents generate KQML queries (see next Subsection) for the appropriate F-agent, responsible for KQML/SQL conversion. When the answer is transmitted, these data are converted into the agent’s internal representation model. Really our Fagent integrates functions of business and data access levels of Modern Three-Tier Application Architecture, so that distributed model implemented in CCDA can be considered as two-tier.

5.2 CCDA Layered Communication Architecture In order to reduce the impact of complexity of software systems we need to define an architecture which outlines distributed application components and allows easy integration of CCDA into Distributed Enterprise Computing Environments. We think that currently there are two concepts, "objects/components" and "agents", which could be considered as a necessary and sufficient enabler of software component reusability in the distributed environments. The problem is that only few applications are able to use the advantadges of both paradigms (Benech et al., 1997). Current implementations of multi-agent systems, for example, generally use Knowledge Query and Manipulation Language (KQML) specifications of common Agent Communication Language (ACL) to solve communication and cooperation problems (Shoham, 1993; Gauvin, 1995; Frost and Cutkosky, 1996; Mayfield at al., 1996). Unfortunately the use of KQML does not solve the problem of component interoperability in complex distributed environments, composed of a number of applications, not all of which support the agent framework, such as CAD systems. Distributed object computing proposes an architecture, which treats each element of the system as a reusable software component. These objects are encapsulated using a single, well-defined, abstract interface, which insulates the user from the languages and tools used to implement it (CORBA, 1991; DCOM, 1996). However, this concept also has well

known limits being applied to the knowledge-based tasks or for the applications that do not support it. In CCDA we have proposed a layered agent communication architecture that can be considered as another alternative to component integration based on ACL and Distributed Component Object Model (DCOM), taking advantages of the both paradigms (Fig. 6). (Insert Figure 6 about here) CCDA architecture provides a homogeneous framework of interoperation of agents and contains a number of levels. The concept level supports attributed graph grammar representation of a problem domain and reflects objects, their properties, and relations between them, including ICSP model of their adjustment and graph grammar model of their structural properties. The next level is used to map GT structures accepted by GT operations to KQML content data structures and operations and visa versa. D-agent actions are the KQML messages that include constraints, properties of objects, and other user defined primitives. The following list of KQML performatives is supported: achieve, ask-if, ask-all, broadcast, broker-all, broker-one, forward, register, reply, sorry, tell, transport-address, unregister, untell. The ActiveX mechanisms take KQML expressions and transmit them as semantic events. This level is used to map data and operation by converting events and messages to the set of KQML performatives. It also maps events data structure to the data structure accepted by Object Linking and Embedding (OLE) servers (Chappell, 1996). We use ActiveX methods of COM architecture to support automation-compatible data types with Universal marshaling method call. ActiveX components support automation client/server mechanisms for D-agent communication. There are several reasons why we use Automation over custom interfaces, where client uses VBScript to add functionality dynamically instead of client programming (interface can be called at compile time). Each function call must read the type library whenever it wants to marshal the method request. This approach is more slower than a proxy-stub DLL, but we need to realize access to Pattern objects, where the methods simply do not know about the flexible structure of this kind of objects at the moment of their creating. VBScript-based client/server interpretation does checking at rune-time without knowing in advance what the types of those parameters are. We use dual interface method allowing access by Idispatch interface (slower but more flexible for a new

Pattern object access) as custom COM interface (by virtual table of public functions). A dispinterface is used to support a collection of methods and properties of KQML messages that are called through Idispatch::Invoke() method and are described in object type library. A not formated text in KQML messages is used. All data passing through interfaces are self-describing, using a data type called a VARIANT_BOOL, which is used by Universal marshaling technique in its implementation. Invoke method contains a structure of parameters in DispPars and its content in pVar. The important part of Invoke() definition contains the following: HRESULT Invoke(… .[in, out] DispPars, [in. out] VARIANT_BOOL* pVar,… ..), where DispPars are described as structures with cstring typed elements for all KQML performatives, such as, for example Receiver, InReplyTo, Language, Content, etc. All parameters are transmitted as named parameters so that a receiver knows how to interpret all the information in KQML messages. For this reason we use special symbols &P and &C as prefixes for class and Pattern description of object models. After the compilation, we have interface description, edited part of which is presented below: interface IKQML; dispinterface _KQMLEvent ; [ uuid ( B3AF924C-4278-21D1-8B9300FC76604726A3 ) , helpstring ( "IKQML Interface" ) , dual , // is a dual interface. Oleautomation // is compatible with COM automation. ] interface IKQML : IDispatch { [id ( 1 ) , helpstring ( "KQML messages" ) ] HRESULT KQML ( [in] BSTR bstrText ) ; HRESULT PresContents ( [out , retval ] VARIANT_BOOL *pVarB ) ; [ propput, id ( 2 ), helpstring("KQML message was interpreted by the server .") ] ………. } Finally, Transmission Control Protocol/Internet Protocol (TCP/IP) protocol stack is used to implement low level communications. This level is responsible for serialization and recompilation of messages and is not accessible to the programmer. In the case other mechanisms then ActiveX are used, KQML messages

can be transmitted directly by communication Application Programming Interfaces (API). This model also provides a number of design or decision-making services that enable a client to find a reference to a D-agent (server) at runtime. This reduces the complexity of client implementation and aggregates flexibility by means of runtime binding.

6. EXPERIMENTAL RESULTS This section presents some experimental results on the CCDA evaluation. We have provided a number of experiments on the FMS re-engineering on the shopfloor level. The goals of these experiments were: • to evaluate distributed multi-agent algorithm for configuration design with CCDA, and • to establish a reliable communication within a team of cooperating agents and users to evaluate the proposed communication model. To accomplish with the first objective, a sequence of experiments was performed, where D-agents were incrementally added and assigned to the fragment configuration tasks as the FMS was decomposed into fragments. It was possible to do since we have used a special flag, permitting or not an agent to generate successive agents. We analyzed performance in terms of time required to solve the problems in uni-agent and multi-agent fashions. For the obvious reasons we didn't consider a new template design (i.e. an A-agent and expert intervention). To make the comparisons fair we have distributed physically the D-agents for the level of FMS cells between the Pentium PCs with Windows95, though at the level of equipment configuring they were executing in parallel. Figure 7 shows visualized results of a typical configuring task for 6 FMS cells. For the illustrative purposes, only 3 D-agents are presented, executed in a parallel fashion: D-agent project server AgentFMS1, D-agent client 11b164 (fragment decomposition of the first level - FMS shop-floor fragment, served by a separate AGV), D-agent client la_155f3 - level of the FMS cell.

Different solution evaluation criteria were applied, such as 'total cost', 'maximum performance', etc., but it was up to the supervising designer to select the best solution from the set of possible ones, provided by the system. A separate specialized agent supports the general system interface. This provides the designer with one entry point to the system facilities, such as master function tools for template definition, and makes him an active member of the agent community. Each D-agent has also editing facilities, which makes it possible to a designer to correct the results, proposed by agents. In this case the results of any designer intervention are passed to all the interesting agents through the facilitator, so they are subject to the overall constraint satisfaction. Figure 8 plots the problem solving time against the number of the D-agents (including network establishment time) for different configuration design conditions and without direct designer intervention. (Insert Figure 8 about here) Traditional cooperative distributed problem solving applications involve having agents work on large, nearly independent subproblems. As a result, agents spend considerable time for local computation between sending messages. By having agents work on large-grained problems, the communication delays in a loosely-coupled network no longer dominate performance. We were giving our agents tasks that were too small. In this case the system was supposed to have an optimum in the agent population, because of the negative impact of agents communication on the overall performance, reported, for example in (Yokoo et al., 1992). In our experiments it was not the case. When comparing with the uni-agent problem solving time, the algorithm shows the constant decrease of total computational time with respect to the increase of number of agents. We can explain it in the following way: by using fragment templates as the model for agents generation, CCDA defines all necessary communication paths a priori and minimize the amount of information communicated.

(Insert Figure 7 about here) 7. CONCLUSIONS AND FUTURE WORK We have considered a number of FMS shop-floor level configuration tasks for the CCDA evaluation. An experimental FMS shop-floor consisted of a number of FMS cells (usually 6-8), including laths, milling and drilling machines, different types of stores and transport system. Each cell typically consisted of 1-2 machines, a robot, and a clamping/resetting station. Each type of the equipment had from 20 to 200 instances to be analyzed.

We have considered the multi-agent approach to the ES development for the configuration design, based on project decomposition into fragments and their concurrent configuring. Use of fragments takes advantage of distribution of design process among agents, everyone working with a single fragment, which is then embedded into the fragment of the above level. To create the illusion of a shared design model,

most of interactions between agents are mediated by facilitators. The first experiments were provided with the environment for the DEsign of Structured Objects, called DESO. At that stage, constraint-based internal knowledge representation model, search heuristics, and communication between processes based on reduced set of KQML and TCP/IP protocol stack were investigated. The results of these experiments were presented at a number of conferences (Smirnov et al., 1995a, b; Koulinitch, 1997). The current prototype version attempts to use a federated architecture and DCOM/ActiveX object based model of agent interactions. CCDA is currently enhancing the main version written in C++ to take advantage of Microsoft's ActiveX and DCOM technologies, using DCOM 95 as the experimental testbed and a restricted version of KQML library. We are currently working on the incorporation of the Unix based components (FMS layout design system, developed in SPIIRAS) into the proposed framework, based on DCOM FTE as an implementation of the nongraphical part of Microsoft's DCOM technology. DCOM FTE allows DCOM-enabled applications running on non-Windows platforms to communicate with DCOM components in a heterogeneous network, i.e. a network with mixed architectures. So, for example, DCOM FTE allows DCOM-enabled agents running on a UNIX machine to communicate with DCOM CCDA agents that are active on a Windows machine. F-agent implementation and performance analysis with different object models is under investigation. In our future work more complicated agent negotiation algorithms are also to be investigated.

REFERENCES Benech, D., Desprats, T., & Raynaud, Y. (1997). A KQML-CORBA Based Architecture for the Communication of Intelligent Agents in Cooperative Service and Network Management. In Proc. of the First IFIP/IEEE International Conference on Management of Multimedia Networks and Services '97, July 8-10, Montréal, Canada. Chappell, D. (1996) Understanding ActiveX and OLE. Microsoft Press. Csuhaj-Varjú, E. (1993). On grammars with local and global context conditions. Intern. Journal on Computer Math. 47: 17-27. Distributed Component Object Model protocol DCOM/1.0. (1996). Network Working Group, Internet-Draft.

Durfee, E. H. (1988). Coordinating Distributed Problem Solvers. Kluwer Academic Publishers, Boston. Ehrig, H. & Mahr, B. (1990). Fundamental of Algebraic Specification: Module Specification and Constraints, V.21 of EATCS Monographs of Theoretical Computer Science. Springer, Berlin. Ehrig, H. & Lowe, M. (1993). Parallel and distributed derivation in single pushout approach. TCS, 109: 123-143. Frost, H.R. & Cutkosky, M.R. (1996). Design for Manufacturability via Agent Interaction. In 1996 ASME Design for Manufacturing Conf., Irvine, CA, Aug., pp. 18-22. Gauvin, D. (1995). Un environnement de programmation orienté agent. Dans Troisièmes journées francophones sur l'intelligence artificielle distribuée et les systèmes multiagents. St-Baldoph, Savoie, France, 15-17 mars 1995. Genesereth, M. R. & Ketchpel, S. P. (1994). Software agents. Communications of the ACM, 37(7):48-53. Hewitt, C. (1977). Viewing control structures as patterns of passing messages. Artificial Intelligence, 8(3):323-364. Jennings, N.R., Varga, L.Z., Aarnts, R.P., Fuchs, J., & Skarek, P. (1993) Transforming Standalone Expert Systems into a Community of Cooperating Agents, Eng. Applications of AI, 6(4), 317-331. Jennings, N. R. (1994). Cooperation in Industrial Multi-Agent Systems, Series in Computer Science, Vol 43, World Scientific Publishing Co. Inc. Klein, M. (1991). Supporting conflict resolution in cooperative design systems. IEEE Transactions on System, Man, Cybernetics, 21(5):1379-1390. Korff, M. (1994). Single pushout transformations of equationally defined graph structures with application to actors systems, Lecture Notes in Computer Science, Volume 776. Springer-Verlag. Koulinitch, A.S. (1997). Project-Sharing Architecture of a Concurrent Engineering Environment. In Proc. of the International Workshop on Parallel Computing and Scheduling, Mexico, Ensenada, 34-40. Lowe, M., Korff, M., & Wagner, A. (1993). An algebraic framework for the transformation of attributed graphs. In Term Graph Rewriting: Theory and Practice, chapter 14, p: 185-199, John Wiley & Sons. Mayfield, J., Labrou, Y., & Finin, T. (1996). Evaluation of KQML as an Agent Communication Language. In Intelligent Agents Volume II - Proc. of the 1995 Workshop on Agent Theories, Architectures, and languages. M. Wooldridge, J.P.Muller and M.Tambe (Eds.) Lecture Notes in Artificial Intelligence, Springer-Verlag.

McDermott, J. (1982). R1: A rule-based configuration of computer systems. AI, 19(1): 39-88. Müller, J., Wooldridge, M. J., & Jennings, N. R. (Eds.) (1997). Intelligent Agents III: Proceedings of the Third International Workshop on Agent Theories, Architectures, and Languages. Lecture Notes in Artificial Intelligence, Volume 1193, SpringerVerlag. Papandopouls, G. A. (1996). Concurrent Object Oriented Programming Techniques in Term Graph Rewriting Framework. In 4th EUROMICRO Workshop on Parallel and Distributed processing, Portugal, IEEE Press. Rosenberg, G. (Ed.) (1997). HandBook of Graph Grammars and Graph Transformation. Vol.3 Concurrency. Netherlands, World Scientific. Serrano, D. (1991). Constraint-Based Concurrent Design. Systems Automation: Research&Applications, 3(1):217-230. Shoham, Y. (1993). Agent-oriented Programming. Artificial Intelligence, 60(1):51- 93. Singh, M. P. (1994). Multiagent Systems, A Theoretical Framework for Intentions, Know-How, and Communications. Lecture Notes in Computer Science, Volume 799, (subseries: Lecture Notes in Artificial Intelligence), Springer-Verlag. Smirnov, A.V., Sheremetov, L.B., & Turbin, P.A. (1995a). Constraint-Based Expert System for the Design of Structured Objects. In Proc. of the International AMSE Conference on System Analysis, Control & Design, Methodologies & Examples SYS’95. Brno, Czech Republic, July 3-5, V.2, pp. 64-71.

Smirnov, A.V., Koulinitch, A.S., Sheremetov, L.B., & Turbin, P.A. (1995b). Knowledge-Based Configuration Design of Electronic Devices: A Case Study. In Proc. of the Int. Workschop on Design Methodologies for Microelectronics with Special Day on Co-operation and Vienna Industrial Day. Smolenice castle, Slovakia Vienna, Austria, September 11-15, pp. 206-215. Smirnov, A. V., Sheremetov, L. B., & Turbin, P. A. (1996) Information Support of FMS Configuration Design. In Camarinha-Matos, L.M. and Afsarmanesh, H. (Eds.), Balanced Automation Systems II - Implementation challenges for anthropocentric manufacturing, Chapman & Hall, 1996. pp 357 - 364. The Common Object Request Broker: Architecture and Specification. (1991). OMG Document# 91.12.1. Object Management Group, Framingham, MA. Werner, E. (1996). Logical Foundations of Distributed Artificial Intelligence. In O'Hare G.M. and Jennings N.R., (Eds.), Foundations of Distributed Artificial Intelligence. John Wiley & Sons, Inc. Wiederhold, G. (1992). Mediators in the Architecture of Future Information Systems, IEEE Computer, 5(3): 38-49. Wooldridge, M., Mueller, J.P., & Tambe, M. (Eds.). (1996). Intelligent Agents II. Volume 1037 of Lecture Notes in Artificial Intelligence, SpringerVerlag. Yokoo, M., Ishida, T., Durfee, E.H., & Kuwabara, K. (1992). Distributed Constraint Satisfaction for Formalizing Distributed Problem Solving, In Proc. of the 12th IEEE International Conference on Distributed Computing Systems '92, pp.614--621.