Creation of an Intelligent Concurrency Adaptor in order to mediate the Differences between Conflicting Concurrency Interfaces

Created by W.Langdon from gp-bibliography.bib Revision:1.4202

  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
  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 =          "",
  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

                 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

Genetic Programming entries for Werner Van Belle