- author = "Werner {Van Belle}",
- title = "Creation of an Intelligent Concurrency Adaptor in order to mediate the Differences between Conflicting Concurrency Interfaces",
- school = "Computer Science Department, Vrije Universiteit Brussel",
- year = "2003",
- address = "Belgium",
- month = May,
- keywords = "genetic algorithms, genetic programming, distributed systems, mobile multi-agent systems, Petri-nets, concurrency strategies, reinforcement learning, component based development",
-
URL = "
http://prog.vub.ac.be/Publications/2003/vub-prog-phd-03-01.pdf",
- size = "approx 294 pages",
-
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 updated
without prior notification and without guarantees that
the new interface is backward compatible. Such updates
can range from syntactic modifications over slight
semantic differences to 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 coloured Petri-nets and certain 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 communicating 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 entirely. 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 behaviour 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 should happen. Bypassing a clients behavior is achieved with a reinforcement learning algorithm that maximises 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 concurrency-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 operations 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 programmer 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 take into 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 interfaces are 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.",
-
notes = "PROG, DINF, VUB, Pleinlaan 2, 1050 Brussels
Adviser: Prof. Dr. Theo D'Hondt co-Adviser: Dr. Tom Mens",
