21 research outputs found

    Reactive concurrent programming revisited

    Get PDF
    In this note we revisit the so-called reactive programming style, which evolves from the synchronous programming model of the Esterel language by weakening the assumption that the absence of an event can be detected instantaneously. We review some research directions that have been explored since the emergence of the reactive model ten years ago. We shall also outline some questions that remain to be investigated

    The Junior Reactive Kernel

    Get PDF
    We define Junior as a Java framework kernel for reactive programming with broadcast events. We give Junior a formal semantics based on rewriting rule. We also describe three implementations of Junior. The first one, called REWRITE, is the direct implementation of the semantics rules. The second one is called REPLACE; it is more efficient than REWRITE as it reuses Java objects instead of always creating new ones. The third implementat- ion, called TURBO, optimises the number of syntax tree traversals and is adapted to situations where there are a large number of events. Finally, we discuss the extension of Junior to distributed contexts and compare it with the SugarCubes Reactive Java framework

    Distributed Reactive Machines

    Get PDF
    One considers systems made of synchronizers to which distributed reactive machines are connected. The corresponding model is described with its implementation in Java, using SugarCubes and the RMI mechanism

    DSLM : Dynamic Synchronous Language with Memory

    Get PDF
    We propose a new scripting language called DSLM based on the syn- chronous/reactive model. In DSLM, systems are composed of several sites executed asynchronously, and each site is running agents in a synchronous way. Each agent executes its script in synchronous par- allel way. Scripts may call functions that are considered in an abstract way: their effect on the memory is not considered, but only their "orchestration" i.e. the organisation of their calls in time and in place (the site where they are called). The mapping of sites onto cores allows one to benefit from multicore architectures. Two properties are assumed by DSL: reactivity of sites and absence of interferences between scripts run by distinct sites. We consider several variants of DSL. In the first variant, functions are defined in FunLoft. In the second variant of DSL, functions are defined in Re- activeML and the JoCaml system is used for asynchronous inter-sites communications. The third variant is based on SugarCubes which is a Java based framework for reactive programming. Finally, in the fourth variant, functions are defined in Scheme/Bigloo

    Exécution efficace de programmes ReactiveML

    Get PDF
    National audienceReactiveML est un langage dédié à la programmation de systèmes combinant des parties algorithmiques et réactives. Il s'agit d'une extension de ML avec des constructions pour la concurrence inspirées des langages synchrones. Celles-ci permettent d'obtenir une très grande expressivité, mais leur implantation efficace représente un défi. Dans cet article, nous présentons l'implantation de ReactiveML, de la compilation à l'implantation du moteur d'exécution en OCaml. Nous décrivons également une implantation parallèle en mémoire partagée du moteur d'exécution utilisant le vol de tâches. L'approche choisie permet d'obtenir une exécution efficace même en présence de structures de contrôle complexes. Elle s'étend simplement au cas parallèle avec des résultats expérimentaux prometteurs

    Fine-grained and coarse-grained reactive noninterference

    Get PDF
    International audienceWe study the security property of noninterference in a core synchronous reactive language that we call CRL. In the synchronous reactive paradigm, programs communicate by means of broadcast events, and their parallel execution is regulated by a notion of instant. We first show that CRL programs are indeed reactive, namely that they always converge to a state of termination or suspension ("end of instant") in a finite number of steps. We define two bisimulation equivalences on CRL programs, corresponding respectively to a fine-grained and to a coarse-grained observation of programs. We show that coarse-grained bisimilarity is more abstract than fine-grained bisimilarity, as it is insensitive to the order of generation of events and to repeated emissions of the same event during an instant. Based on these bisimulations, two properties of Reactive Noninterference (RNI) are introduced, formalising secure information flow. Both properties are time-insensitive and termination-insensitive. Again, coarse-grained RNI is more abstract than fine-grained RNI. Finally, a type system guaranteeing both security properties is presented. Thanks to a design choice of CRL, which offers two separate constructs for loops and iteration, and to refined typing rules, this type system allows for a precise treatment of termination leaks, which are an issue in parallel languages

    The FunLoft Language

    Get PDF
    Description of the FunLoft language for safe reactive programming (using the version v0.2 of the compiler)Description du langage FunLoft permettant une programmation réactive sûre (utilisant la version v0.2 du compilateur

    Sequentially Constructive Concurrency: A Conservative Extension of the Synchronous Model of Computation

    Get PDF
    Synchronous languages ensure deterministic concurrency, but at the price of heavy restrictions on what programs are considered valid, or constructive. Meanwhile, sequential languages such as C and Java offer an intuitive, familiar programming paradigm but provide no guarantees with regard to deterministic concurrency. The sequentially constructive model of computation (SC MoC) presented here harnesses the synchronous execution model to achieve deterministic concurrency while addressing concerns that synchronous languages are unnecessarily restrictive and difficult to adopt. In essence, the SC MoC extends the classical synchronous MoC by allowing variables to be read and written in any order as long as sequentiality expressed in the program provides sufficient scheduling information to rule out race conditions. This allows to use programming patterns familiar from sequential programming, such as testing and later setting the value of a variable, which are forbidden in the standard synchronous MoC. The SC MoC is a conservative extension in that programs considered constructive in the common synchronous MoC are also SC and retain the same semantics. In this paper, we identify classes of variable accesses, define sequential constructiveness based on the concept of SC-admissible scheduling, and present a priority-based scheduling algorithm for analyzing and compiling SC programs
    corecore