Request Scheduling for Multiactive Objects

National audienceThe Active Object programming model aims to facilitate the writing of distributed applica- tions. It provides asynchronous remote method calls and mechanisms to prevent data races. However, this model does not take advantage of multicore architectures as it is intrinsically mono-threaded. To overcome this problem, a recent extension of the active object model has been designed, which is called the Multiactive Object model. Multiactive objects enable local parallelism at a high level without giving up simplicity and safety provided by active objects: the programmer can declare which requests can be run in parallel through a customized spec- ification language. However, in this new model, the programmer has not yet control on the scheduling policy applied to the requests executed by a multiactive object. In this work, we study application-level scheduling concepts that can be applied to multiactive objects. The goal is to allow the programmer to have a fine control on the scheduling policy through simple specifications. We first develop a priority mechanism that can be used to reorder awaiting requests in the queue of multiactive objects. Second, we provide a simple thread management mechanism to better allocate available threads to awaiting requests. Finally, we experiment the new features in a practical context, showing that the proposed mechanisms increase the efficiency of multiactive objects while keeping a low overhead. On the whole, we provide gen- eral specifications for application-level scheduling that are together fine-grained, user-friendly, and efficient

A ProActive Backend for ABS: from Modelling to Deployment

ABS is an object-oriented modeling language that is based on a concurrent object group model, derived itself from the active object model. Its goal is to describe distributed and concurrent applications in order to verify their properties and make them safer. Thanks to the ABS Tool Suite, ABS programs can be translated into the Java programming language (among others), and executed in the JVM. This paper presents a new ABS backend that translates ABS programs into ProActive programs. ProActive is a well known active object Java library that provides support for distribution of applications across clusters or grids. The benefit of this work is to be able to easily distribute ABS programs, so that ABS models can also be experimented in a large scale setting. Our contribution includes the ProActive backend itself, the complete description of our translation strategy, and a realistic experiment that shows the benefits of the ProActive backend

Request Scheduling for Multiactive Objects

National audienceThe Active Object programming model aims to facilitate the writing of distributed applica- tions. It provides asynchronous remote method calls and mechanisms to prevent data races. However, this model does not take advantage of multicore architectures as it is intrinsically mono-threaded. To overcome this problem, a recent extension of the active object model has been designed, which is called the Multiactive Object model. Multiactive objects enable local parallelism at a high level without giving up simplicity and safety provided by active objects: the programmer can declare which requests can be run in parallel through a customized spec- ification language. However, in this new model, the programmer has not yet control on the scheduling policy applied to the requests executed by a multiactive object. In this work, we study application-level scheduling concepts that can be applied to multiactive objects. The goal is to allow the programmer to have a fine control on the scheduling policy through simple specifications. We first develop a priority mechanism that can be used to reorder awaiting requests in the queue of multiactive objects. Second, we provide a simple thread management mechanism to better allocate available threads to awaiting requests. Finally, we experiment the new features in a practical context, showing that the proposed mechanisms increase the efficiency of multiactive objects while keeping a low overhead. On the whole, we provide gen- eral specifications for application-level scheduling that are together fine-grained, user-friendly, and efficient

An Optimal Broadcast Algorithm for Content-Addressable Networks -- Extended Version

Structured peer-to-peer networks are powerful underlying structures for communication and storage systems in large-scale setting. In the context of the Content-Addressable Network (CAN), this paper addresses the following challenge: how to perform an efficient broadcast while the local view of the network is restricted to a set of neighbours? In existing approaches, either the broadcast is inefficient (there are duplicated messages) or it requires to maintain a particular structure among neighbours, e.g. a spanning tree. We define a new broadcast primitive for CAN that sends a minimum number of messages while covering the whole network, without any global knowledge. Currently, no other algorithm achieves those two goals in the context of CAN. In this sense, the contribution we propose in this paper is threefold. First, we provide an algorithm that sends exactly one message per recipient without building a global view of the network. Second, we prove the absence of duplicated messages and the coverage of the whole network when using this algorithm. Finally, we show the practical benefits of the algorithm throughout experiments.Ce document présente un nouvel algorithme de broadcast pour réseaux pair-à-pair de type CAN. Cet algorithme de broadcast est optimal dans le sens où tous les pairs ne reçoivent le message qu'une seule fois, sans connaissances globales. Après avoir introduit les étapes fondamentales de cet algorithme, ses principales propriétés sont exposées et prouvées. Des expériences à taille réelle montrent la validité de cet algorithme et ses bénéfices

Execution support for multi-threaded active objects : design and implementation

Pour aborder le développement d'applications concurrentes et distribuées, le modèle de programmation à objets actifs procure une abstraction de haut niveau pour programmer de façon concurrente. Les objets actifs sont des entités indépendantes qui communiquent par messages asynchrones. Peu de systèmes à objets actifs considèrent actuellement une exécution multi-threadée. Cependant, introduire un parallélisme contrôlé permet d'éviter les coûts induits par des appels de méthodes distants. Dans cette thèse, nous nous intéressons aux enjeux que présentent les objets actifs multi-threadés, et à la coordination des threads pour exécuter de façon sûre les tâches d'un objet actif en parallèle. Nous enrichissons dans un premier temps le modèle de programmation, afin de contrôler l'ordonnancement interne des tâches. Puis nous exhibons son expressivité de deux façons différentes: d'abord en développant et en analysant les performances de plusieurs applications,puis en compilant un autre langage à objets actifs avec des primitives de synchronisation différentes dans notre modèle de programmation. Aussi, nous rendons nos objets actifs multi-threadés résilients dans un contexte distribué en utilisant les paradigmes de programmation que nous avons développé. Enfin, nous développons une application pair-à-pair qui met en scène des objets actifs multi-threadés. Globalement, nous concevons un cadre de développement et d'exécution complet pour les applications hautes performances distribuées. Nous renforçons notre modèle de programmation en formalisant nos contributions et les propriétés du modèle. Cela munit le programmeur de garanties fortes sur le comportement du modèle de programmation.In order to tackle the development of concurrent and distributed applications, the active object programming model provides a high-level abstraction to program concurrent behaviours. Active objects are independent entities that communicate by mean of asynchronous messages. Very few of the existing active object frameworks consider a multi-threaded execution of active objects. Introducing a controlled parallelism enables removing some latency induced by remote method invocations. In this thesis, we take interest in the challenges of having multiple threads inside an active object, and in their safe coordination to execute tasks in parallel. We enhance this programming model by adding language constructs that control the internal scheduling of tasks. We then show its expressiveness in two ways: first with a classical approach, by developing and analysing the performance of several applications, and secondly, by compiling another active object language with different synchronisation primitives into our programming model. Also, we make multi-threaded active objects resilient in a distributed context through generic engineering constructs, and by using our programming abstractions. Finally, we develop a peer-to-peer application that shows multi-threaded active objects and their features in action. Overall, we design a thorough framework for the development and execution of high performance distributed applications. We reinforce our programming model by formalising our work and the model’s propertie

From Modelling to Systematic Deployment of Distributed Active Objects – Extended Version

In the context of the expansion of actors and active objects,we are still facing a gap between the safety guaranteed by modellingand verification languages and the efficiency of distributed middlewares.In this paper, we reconcile two active object-based languages, ABS andProActive, that respectively target the aforementioned goals. We compile ABS programs into ProActive, making possible to benefit fromthe strengths of both languages, while requiring no modification on thesource code. After introducing the translational semantics, we establishthe properties and the correctness of the translation. Overall, this paperpresents an approach to running di↵erent active object models in distributed environments, and more generally studies the implementationof programming languages based on active objects

From Modelling to Systematic Deployment of Distributed Active Objects

International audienceIn the context of the expansion of actors and active objects, we are still facing a gap between the safety guaranteed by modelling and verification languages and the efficiency of distributed middlewares. In this paper, we reconcile two active object-based languages, ABS and ProActive, that respectively target the aforementioned goals. We compile ABS programs into ProActive, making possible to benefit from the strengths of both languages, while requiring no modification on the source code. After introducing the translational semantics, we establish the properties and the correctness of the translation. Overall, this paper presents an approach to running different active object models in distributed environments, and more generally studies the implementation of programming languages based on active objects

Multiactive objects and their applications

In order to tackle the development of concurrent and distributed systems, theactive object programming model provides a high-level abstraction to programconcurrent behaviours. There exists already a variety of active objectframeworks targeted at a large range of application domains: modelling,verification, efficient execution. However, among these frameworks, very fewconsider a multi-threaded execution of active objects. Introducing controlledparallelism within active objects enables overcoming some of their limitations.In this paper, we present a complete framework around the multi-active objectprogramming model. We present it through ProActive, the Java library thatoffers multi-active objects, and through MultiASP, the programming languagethat allows the formalisation of our developments. We then show how to compilean active object language with cooperative multi-threading into multi-activeobjects. This paper also presents different use cases and the developmentsupport to illustrate the practical usability of our language. Formalisation ofour work provides the programmer with guarantees on the behaviour of themulti-active object programming model and of the compiler

Multiactive objects and their applications

In order to tackle the development of concurrent and distributed systems, the active object programming model provides a high-level abstraction to program concurrent behaviours. There exists already a variety of active object frameworks targeted at a large range of application domains: modelling, verification, efficient execution. However, among these frameworks, very few consider a multi-threaded execution of active objects. Introducing controlled parallelism within active objects enables overcoming some of their limitations. In this paper, we present a complete framework around the multi-active object programming model. We present it through ProActive, the Java library that offers multi-active objects, and through MultiASP, the programming language that allows the formalisation of our developments. We then show how to compile an active object language with cooperative multi-threading into multi-active objects. This paper also presents different use cases and the development support to illustrate the practical usability of our language. Formalisation of our work provides the programmer with guarantees on the behaviour of the multi-active object programming model and of the compiler