Concurrency control publications referencing Quasar :
2008
.
Using Java or C# Monitor for a concurrency kernel implies defensive multithreading programming.
Preliminary submission to Ada EU 2009.
Abstract : With the development of embedded and mobile systems, Java and C#, which are widely used for application programs, are also considered for implementing systems kernel or application platforms. It is the aim of this paper to exemplify some subtle programming errors that may result from the process queuing and awaking policy, which corresponds to a weak fairness semantic and which has been chosen for implementing the monitor concept in these languages. Two examples show some subtle deadlocks resulting from this policy. The first example deals with process synchronization: processes seeking after partners for a peer-to-peer communication call a symmetrical rendezvous server. The second example concerns resource sharing according to a solution of the dining philosophers paradigm. In this example, several implementations are presented, the last ones aiming to provide deterministic process awakening. All these examples have been validated and simulated and this allows comparing their concurrency complexity and effectiveness. Our conclusion is, first, that Java and C# need defensive multithreading programming for developing correct programs and, second, that a good acquaintance with several styles of concurrent programming helps designing more robust Java or C# solutions, once the choice of the implementation language is irrevocable.
The Data collected by Quasar and the results of different simulations. of the publications
.
Concurrent Program metrics
drawn by QUASAR numbers.
CEDRIC Scientific Report n°1315. [.pdf]
Preliminary submission to Ada EU 2008.
Abstract : Aiming at developing reliable concurrent software, the engineering practice uses appropriate metrics. Quasar, the tool that we develop for automatically analyzing the concurrent part of programs, provides some data as a result of its program analysis process. We attempt to use them as metrics and to show their usefulness for software engineering and for reliable programming control. In addition to the validation of code, some delivered data may be relevant for marking the quality of code; we show that they may be useful for comparing different concurrency semantics, for comparing the execution indeterminism of different implementations of a concurrency pattern and for estimating the scalability of a solution. As a case study for providing data and insights, we present and analyze with Quasar several implementations of a distributed symmetric non-deterministic rendezvous algorithm. We consider also two possible uses of these data for indeterminacy estimation and for concurrent software quality. We conclude with a feedback on software practice.
You can also find some related materials to this publication :
.
Modelling remote concurrency with Ada. Case study of symmetric non-deterministic rendez-vous.
CEDRIC Scientific Report n°1102. [.pdf]
Preliminary submission to Ada EU 2007.
Abstract : When developing concurrent software, a proper engineering practice is to choose a good level of abstraction for expressing concurrency control. Ideally, this level should provide platform-independent abstractions but, as the platform concurrency behaviour cannot be ignored, this abstraction level must also be able to cope with it and exhibit the influence of different possible behaviours. We state that the Ada language provides such a convenient abstraction level and thus may be used as a domain-specific language for concurrency description and evaluation, including distributed concurrency. For demonstrating it, we present two cooperative algorithms based on remote procedure calls which, although simply stated, contain actual concurrency complexity and difficulties. They allow a distributed symmetric non-deterministic rendez-vous. One relies on a common server and the second is fully distributed. Both realize a symmetric rendez-vous using an asymmetric RPC modelled by Ada rendez-vous. Using these case studies, we show that Ada concurrency features provide the adequate abstraction level both for describing and evaluating concurrency and for carrying out design decisions.
You can also find some related materials to this publication :
. Comparing Java, C# and Ada Monitors queuing policies : a case study and its Ada refinement. Ada Letters, volume XXVI(2), aug. 2006.
Abstract : Learning concurrency paradigms is necessary but it is not sufficient since the choice of run-time semantics may introduce subtle programming errors. It is the aim of this paper to exemplify the importance of process queuing and awaking policies resulting from possible choices of the monitor concept implementation. The first part of the paper compares the behaviour of concurrent processes sharing a unique waiting queue for condition synchronization when implemented in Java or in Ada. A particular solution of the dining philosophers paradigm will be used to show how the difference in the monitor semantics may lead or not to deadlock. This comparison provides insight for deriving a correct Java implementation. The second part of the paper shows how the implementation can be refined when using Ada entry families and requeue with requeue once restriction. The result is elegant, safe and fair, and deterministic. This paper ends with quantitative comparisons of concurrency complexity and of concurrency effectiveness. We conclude that Java and C# multithreading need defensive concurrent programming while Ada allows more latitude for developing correct concurrent programs.
You can also find some related materials to this publication :
.
Noyau de concurrence par moniteur pour Java ou C#: pour une autre sémantique plus fiable et plus performante.
CEDRIC Technical Report n° 1021 [.pdf]
Résumé (french) : Avec l'extension de Java et C# et de leur emploi pour programmer des applications embarquées mobiles ou temps réel puis pour introduire des processus concurrents dans ces applications, se développe l'idée d'écrire aussi les systèmes d'exploitation et les plates-formes dans ces langages. Nous comparons deux politiques possibles pour gérer le blocage et le réveil des "threads" qui partagent un objet sous contrôlele de la structure de "moniteur". Cela renvoie à deux sémantiques différentes pour le moniteur. L'une de celles-ci entraîne des interblocages pour des algorithmes qui, pour d'autres implantations, sont fiables ou à des commutations de contexte superflues et coûteuses. L'autre sémantique n'a pas ces défauts. Il se trouve que Java et C# ont choisi la plus mauvaise de ces politiques. Nous explicitons cela sur des exemples. Nous montrons aussi la limitation de performance introduite par le choix de Java d'une file d'attente unique, implicite, par objet monitoré. Enfin nous utilisons une mesure de complexité des algorithmes concurrents pour comparer des implantations avec ces deux sémantiques. Nous proposons aux développeurs de systèmes d'exploitation des éléments pour améliorer la qualité du contrôle de concurrence en reconsidérant les choix d'implantation du moniteur.
Abstract : With the development of embedded and mobile systems, Java and C#, which are widely used for application programs, are also considered for implementing systems kernel or application platforms. It is the aim of this paper to exemplify some subtle deadlocks and some inefficiencies that may result from the process queuing and awaking policy which has been chosen for implementing the monitor concept in these languages. Several examples are given, two of them showing unforeseen deadlocks, another one showing the limitation of the implicit unique queue of Java. We compare some solutions with a complexity measure for concurrent programs. Last we propose some iplementation changes for an operating system providingmore robust Java or C# monitor implementations.
You can also find some related materials to this publication :
. Chameneos, a Concurrency Game for Java, Ada and Others. In ACS/IEEE International Conference on Computer Systems and Applications (AICCSA'03). IEEE CS Press, 2003. Tunis, Tunisia, jul. 2003. (preliminary submission)
Abstract : This paper presents a peer-to-peer cooperation paradigm and several implementations. The paradigm is expressed as a game. The implementations are done in three different languages largely available to-day (Ada, Java and C with the POSIX standard). This allows comparing their programming style and their ability to provide secure programs. Java and Ada are high level languages which allow concurrent programming. Both use the concept of monitor, but their implementation choices make them differ greatly. POSIX offers low level system API for concurrent programming. As prolegomena of the game, we first present the application contexts in which this concurrency paradigm may be useful. Then we summerize the concurrent programming structures of Java, Ada and POSIX, and the coloured Petri nets formalism. This presentation may be skipped by the user aware of it.
last update : 11/19/2007