An Evolutional 　 Cooperative Computation Based on Adaptation to Environment

Naoyasu UBAYASHI and Tetsuo TAMAI

Graduate School of Arts and Sciences

University of Tokyo

APSEC’99

Overview

１． Introduction

２． Environment Adaptation Model

３． Advanced topics

using Environment Adaptation Model

４． Related Works

５． Conclusion

Introduction

BackgroundRecently, software systems that reside in network environments are spreading rapidly. These systems has properties such asdistributed, mobile, dynamic, adaptable.

*These kinds of software systems are composed of a number of 　 distributed objects that may change their locations dynamically.

*These objects change their functions dynamically to adapt themselves to their external environments.

Constructions of these kinds of systems are considered as very hard and difficult works.

Illustration ofRecent software systems

object

object

object

collaboration

Problems

It is difficult to describe functions that are dispersed in a number ofdistributed objects in current object oriented programming languages.These functions are implemented by collaborations among objects. -- not implemented by a single object!

gives abstraction mechanisms for collaborations

It is difficult to describe dynamic evolution in current object orientedprogramming languages.

gives abstraction mechanisms for evolution

Target (1)

Presents a framework that an object evolves through collaborations.

an object acquires or discards functions andattributes dynamically

Collaborations

a number of objects engaging in their own roles send messagesto each other and perform a job that cannot be executedby a single object

Evolution

Target (2)

gives

mechanisms for abstracting collaborations among objectsmechanisms for creating collaboration partsmechanisms for synthesizing collaboration partsmechanisms for object evolutionmechanisms for integrating collaborations with evolution

Environment Adaptation Model

Basic Concepts

role

environment

role

environment

(collaboration filed)

bindunbind

object object object

Multipleadaptation

Model Constructs (1)

Environment

- logical field where a group of objects collaborate with each other- composed of environment methods/attributes, role definitions- aims 1) to give name space 2) to give common methods/attributes 3) to coordinate behaviors of objects in the field 4) to define object behaviors that are available only in the field >> roles

Role

- composed of role methods/attributes

Model Constructs (2)

Evolution

- an object joins into an environment and acquires new collaboration functions by bind-operations.

the object can collaborate with otherobjects in the environment

role

environment

bind

object

object

Bind-operation

messagedelegation

- creates a message delegation path between an object and a role.

Merits

1) gives mechanisms that encapsulate collaboration descriptions among objects into environments and roles.

* design methods that abstract collaborations* techniques that construct reusable collaboration components

2) gives evolution mechanisms.

* design methods for distributed mobile agent systems -- agents need to change their functions dynamically in order to adapt themselves to their environments.

Example -- Contract Net Protocol

（１） task-announcement（２） bid（３） award

Role methods

Role （ manager）

Role(contractor)

（１）（３）

（２）

Environment （ contract-net）

Evolve to manager

(bind-operation)

object

Environment （ contract-net）

Evolve to contractor

General contract net protocol

Synthesizing simple contract-net environments

Programming Language Epsilon/0

1) Epsilon/0 supports Environment Adaptation Model. - environments, roles and bind-operations are supported as language constructs.

2) Epsilon/0 supports reflection mechanisms.

3) Epsilon/0 is implemented using ABCL/R3 that is a reflective object oriented programming language based on Scheme.

Descriptions of Contract Net Protocolin Epsilon/0

<< Environment >> contract-net

<< Role >> manager

start()bid()

<< Role >> contractor

task-announcement()award()execute-task()

manager

contractor

contractor

contractor

object

task-announcement

bid

award

bindexecute-task(delegate!!)

(define-context contract-net () 　　… common attributes)

(define-context-method contract-net (common method….))

Descriptions of contract-net environment

Environment class

(define-role contract-net manager () condition-shown-by-manager)

(define-role-method contract-net manager (start self) (let ((contractor-list (get-role (context-of self) ‘contractor)))　 ... broadcasts a task-announcement message to all roles that are contained in the contractor-list))

(define-role-method contract-net manager (bid self a-contractor a-condition-shown-by-contractor) ... stores a bid-information (if (bidding is finished) (award (select-contractor self) self)))

Descriptions of manager role

Role class

Descriptions of contractor role

(define-role contract-net contractor () condition-shown-by-contractor)

(define-role-method contract-net contractor (task-announcement self a-manager a-condition-shown-by-manager) (if satisfies conditions) (bid a-manager self condition-shown-by-contractor)))

(define-role-method contract-net contractor (award self a-manager) (execute-task self))

1) execute a method of an object bound with this role2) execute-task is interface for binding with an object

Execute a program(define contract-A (make-context contract-net))(define contract-B (make-context contract-net))

(define-class person () name)(define-method person (execute-task …))(define a-person (make person))

;; evolves to manager(bind contract-A a-person (make-role contract-net manager contract-A))(start (search-role a-person contract-A))

;; evolves to contractor(bind contract-B a-person (make-role contract-net contractor contract-B))(start (search-role a-person contract-B))

behaves different roles

contract-A

contract-B

evolvesto manager

evolvesto contractor

Advanced topics using Environment Adaptation Model

Advanced topics

1) Autonomous evolution using reflection mechanisms

2) Reusable collaboration components

Environment Adaptation Model presents nice features for software constructions

Autonomous Evolution

evolution

evolution

Contract-net protocolenvironment

manager

contractor

Nancy John

Steve

Contract-net protocolenvironment

manager

Reflective Architecture

objectobject

Meta object Meta object Meta object

Each object can have its own engine

Meta level

Base level

Engine of autonomous action(replaceable)

Engine of autonomous action(replaceable)

Engine of autonomous action(replaceable)

object

Action strategies --- plans for environment adaptations

Reusable Collaboration ComponentConstruction Mechanism (1)

*It is difficult to abstract execution information such as number/kind/reference of objects that participate in collaborations.*This information changes dynamically and cannot be defined statically.

Problems ...

Reusable Collaboration ComponentConstruction Mechanism (2)

Abstracts execution informationusing refection mechanisms

ｇｅｔ－ａｌｌ－ｃｏｎｔｅｘｔｇｅｔ－ａｌｌ－ｃｏｎｔｅｘｔｎａｍｅｃｏｎｔｅｘｔ－ｏｆｇｅｔ－ｒｏｌｅｇｅｔ－ａｌｌ－ｒｏｌｅｇｅｔ－ａｌｌ－ｒｏｌｅｎａｍｅｂｏｕｎｄ？

Metainformationenvironment

Metainformation

role

rolemethod

access

Collaboration field

Name space

Presentsbuilt-in functions

Related Works

Related Works

Researches for abstracting collaborations

1) Aspect Oriented Programming (G.Kiczales, et al.) propose a programming paradigm that a system is divided into a number of aspects.

2) Role based design method (M.VanHilst, D.Notkin 1996) propose an idea of role components that are described by C++ templates.

3) Coordinated Roles (Juan M.Murillo, et al. 1999)

* Dynamic evolution is not so emphasized.

Conclusion

Summary

We proposed

mechanisms for abstracting collaborations among objectsmechanisms for creating collaboration partsmechanisms for synthesizing collaboration partsmechanisms for object evolutionmechanisms for integrating collaborations with evolution

Future Works

applies environment adaptation model

to distributed mobile agent systems to familiar languages such as Java ...

Base Level Descriptions

;; Class definition(define-class person () name money)(define-method person (execute-task self) ...)(define-method person (life self job) (meta-life (meta-of self) job))

;; Start autonomous actions(define taro (make person :name "Taro Yamada" :metaobject-creator make-taro-meta))

(life taro a-job)Specifies meta object

Calls meta object

Meta Level Description

;; Descriptions for adaptation strategies(meta (define-class taro-meta (metaobject)) (define (make-taro-meta class slots evaluator options) (make taro-meta :class class :slots slots :evaluator evaluator :lock (make-lock)))

(define-method john-meta (meta-life self job) (future-to-base ... divides a job into a number of sub-tasks. ... repeats the following activities. (let ((env (get-all-context))) (begin ... searches contract-net environments where he can join as a manager. (bind selected-contract-net (den-of self) selected-manager) (start (search-role (den-of self) selected-contract-net))))))

1) Searches target environments2) Searches target roles that exist in the selected environment 3) Binds itself with the selected role ( evolution ! )

Design Pattern

If this part is changed, a number of adaptation strategies can be implemented! !

Open Implementations