An Evolutional Cooperative Computation Based on Adaptation to Environment

1
An Evolutional Cooperative Computation Based on
Adaptation to Environment
APSEC99

• Naoyasu UBAYASHI and Tetsuo TAMAI
• Graduate School of Arts and Sciences
• University of Tokyo

2
Overview

• 1.Introduction
• 2.Environment Adaptation Model
• 3.Advanced topics
• using Environment Adaptation Model
• 4.Related Works
• 5.Conclusion

3
Introduction
4
Background
Recently, software systems that reside in network
environments are spreading rapidly. These systems
has properties such as distributed, 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.
5
Illustration ofRecent software systems
object
collaboration
object
object
6
Problems
It is difficult to describe functions that are
dispersed in a number of distributed 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 oriented programming languages.
gives abstraction mechanisms for evolution
7
Target (1)
Presents a framework that an object evolves
through collaborations.
Collaborations
a number of objects engaging in their own roles
send messages to each other and perform a job
that cannot be executed by a single object
Evolution
an object acquires or discards functions
and attributes dynamically
8
Target (2)
gives mechanisms for abstracting collaborations
among objects mechanisms for creating
collaboration parts mechanisms for synthesizing
collaboration parts mechanisms for object
evolution mechanisms for integrating
collaborations with evolution
9
Environment Adaptation Model
10
Basic Concepts
(collaboration filed)
Multiple adaptation
bind
unbind
object
object
object
11
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 gtgt roles
Role
- composed of role methods/attributes
12
Model Constructs (2)
Evolution
environment
- an object joins into an environment and
acquires new collaboration functions by
bind-operations.
role
the object can collaborate with other objects in
the environment
bind
message delegation
Bind-operation
object
- creates a message delegation path between an
object and a role.
object
13
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.
14
Example -- Contract Net Protocol
Environment (contract-net)
Role (manager)
Role(contractor)
Environment (contract-net)
(1)
(3)
(2)
Evolve to manager (bind-operation)
Synthesizing simple contract-net environments
Evolve to contractor
General contract net protocol
object
15
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.
16
Descriptions of Contract Net Protocolin Epsilon/0
task-announcement
bid
manager
award
execute-task (delegate!!)
bind
ltlt Role gtgt contractor
object
task-announcement() award() execute-task()
17
Descriptions of contract-net environment
Environment class
(define-context contract-net () common
attributes) (define-context-method contract-net
(common method.))
18
Descriptions of manager role
Role 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-ro
le-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)))
19
Descriptions of contractor role
(define-role contract-net contractor ()
condition-shown-by-contractor) (define-role-metho
d 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-rol
e-method contract-net contractor (award self
a-manager) (execute-task self))
1) execute a method of an object bound with this
role 2) execute-task is interface for binding
with an object
20
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))
contract-B
contract-A
evolves to contractor
evolves to manager
behaves different roles
21
Advanced topics using Environment Adaptation
Model
22
Advanced topics
Environment Adaptation Model presents nice
features for software constructions
1) Autonomous evolution using
reflection mechanisms 2) Reusable collaboration
components
23
Autonomous Evolution
John
Nancy
Contract-net protocol environment
evolution
manager
Contract-net protocol environment
contractor
manager
Steve
evolution
24
Reflective Architecture
Action strategies --- plans for environment
adaptations
Meta level
Meta object
Meta object
Meta object
Base level
object
object
object
Each object can have its own engine
25
Reusable Collaboration ComponentConstruction
Mechanism (1)
Problems ...
It is difficult to abstract execution
information such as number/kind/reference of
objects that participate in collaborations. Thi
s information changes dynamically and cannot be
defined statically.
26
Reusable Collaboration ComponentConstruction
Mechanism (2)
Abstracts execution information using refection
mechanisms
Presents built-in functions
get-all-context get-all-contextname context-of get
-role get-all-role get-all-rolename bound?
27
Related Works
28
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.
29
Conclusion
30
Summary
We proposed mechanisms for abstracting
collaborations among objects mechanisms for
creating collaboration parts mechanisms for
synthesizing collaboration parts mechanisms for
object evolution mechanisms for integrating
collaborations with evolution
31
Future Works
applies environment adaptation model to
distributed mobile agent systems to familiar
languages such as Java ...
32
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)
Calls meta object
Specifies meta object
33
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)) ))))
Design Pattern
1) Searches target environments 2) Searches
target roles that exist in the selected
environment 3) Binds itself with the selected
role ( evolution ! )
If this part is changed, a number of adaptation
strategies can be implemented! !
Open Implementations