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.8051

@PhdThesis{VanBelle:thesis,

• 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 = "Pleinlaan 2, 1050 Brussels, 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://soft.vub.ac.be/soft/dissertations",
• URL = "http://prog.vub.ac.be/Publications/2003/vub-prog-phd-03-01.pdf",
• size = "300 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 = "Programming Technology Lab (PROG), DINF, VUB, Pleinlaan 2, 1050 Brussels

  FKFO, IWT

  Adviser: Prof. Dr. Theo D'Hondt co-Adviser: Dr. Tom Mens",

}

Genetic Programming entries for Werner Van Belle

Citations