| O
n l i n e P u b l
i c a t i o n |
C o m p u t e r S c i e n
c e
|
PhD Dissertation |
http://werner.yellowcouch.org/Phd/index.html |
Creation of an Intelligent Concurrency Adaptor in order to
mediate the Differences between Conflicting Concurrency Interfaces
Werner Van
Belle
Advisor: Prof. Dr. Theo D'Hondt
Co-Advisor: Dr. Tom Mens
Programming Technology Lab (PROG)
Department
Computer Science (DINF)
Vrije Universiteit Brussel (VUB), Belgium
University
i Tromsø, Norway
August 2001 -
September 2003
e-mail: werner@yellowcouch.org
Abstract: The
dissertation you are about to read,
tries
to solve one of the more prominent problems within open distributed
systems
namely: concurrency management between components written by different
manufacturers. All too often, the concurrency strategy provided or
required by
a component is badly documented and rarely matches the concurrency
strategy
provided or required by another component. Whenever this happens there
is a concurrency interface conflict. Solving these conflicts requires a
substantial amount of resources with respect to software engineering:
the
time necessary to understand the problem, the time necessary to solve
the
problem, and above all the resources towards maintaining a working
concurrency
strategy that mediates between the different components. Indeed, in
open
distributed systems, components can be up-dated without prior
notification
and without guarantees that the new interface is backward compatible.
Such
updates can range from syntactic modifications over slight semantic
differencesto
completely new concurrency strategies. For example, changing a nested
locking
strategy to a non-nested locking strategy or changing a non-blocking
server
to work synchronously.
In order
to solve the problem of
conflicting
concurrency interfaces we will create a concurrency adaptor that
resolves
incompatibilities between incompatible concurrency strategies. We do
this
in two steps: first we require a certain amount of extra information to
be present: every provided and required interface should be documented
by means of colored Petri-nets andcertain checkpoints are to be placed
in the code to check the liveness.
Second, we
construct a concurrency
adaptor
that can be placed between the different commu-nicating components.
This
is done by means of a hybrid approach: first the adaptor will try to
gain
freedom by bypassing all the existing concurrency strategies. For a
client
a stub concurrency-interface is generated that will keep the client
alive.
For a server a stub concurrency interface is generated that will allow
anything to happen; in essence bypassing the concurrency strategy
en-tirely.
The concurrency adaptor is finished by plugging in an existing,
formally
guaranteed to work concurrency strategy between the two stub
concurrency
interfaces.
Bypassing
a server's behavior is
achieved
by means of a runtime formal deduction. Given the current state of the
Petri-net and the required state a prolog program deduces what
shouldhappen.
Bypassing a clients behavior is achieved with a reinforcement learning
algorithm that maximizes the reward it receives from the component
itself.
The rewards are based on check-points as specified by the component
itself.
When
placing a guaranteed to work
concurrency
strategy between the different stub concur-rency-interfaces, we need a
meta-protocol that is understood by this central concurrency strategy.
This meta-protocol specifies which resources are present and which
locking/unlocking
opera-tions can work upon them. The meta-protocol is deduced entirely
from
the Petri-nets involved.
The
approach presented in this
dissertation
provides a substantial added value to the pro-grammer of components in
open distributed systems. He now only needs to specify what he requires
or provides as a concurrency strategy within his component. He no
longer
needs to takeinto account the concurrency strategy offered by other
components.
This might reduce development and maintenance time drastically. A
second
advantage of using Petri-nets is that interfacesare not only
documented,
but that this information can be verified automatically: whenever
necessary
the formal specification can be tested against the actual working of a
component.
Jury: Mads
Nygaard (NO/NTNU/IDI), Koen Debosschere (BE/UGENT/PARIS), Anne Nowe
(BE/VUB/COMO), Dirk Vermeir (BE/VUB/TINF), Tom Mens (BE/VUB/PROG),
Yolande Berbers (BE/KUL/DISTRINET), Theo D'Hondt (BE/VUB/PROG)
Refering: Wvb03]
Werner Van Belle;
Creation of an Intelligent
Concurrency Adaptor in order to
mediate the Differences between Conflicting Concurrency Interfaces; Programing
Technology Lab, Department
Computer Science, Vrije Universiteit Brussels, Belgium; Published by
online
publications; Online at
http://werner.yellowcouch.org/Phd/PhdIndex.html; September 2003;
e-mail: werner@yellowcouch.org
Keywords: distributed systems,
mobile
multi-agent systems, Petri-nets, concurrency strategies, reinforce-ment
learning, component based development.
