Relevant bibliographies by topics / Synchronous programming languages

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Books
  4. Book chapters
  5. Conference papers

Academic literature on the topic 'Synchronous programming languages'

Author: Grafiati
Published: 4 June 2021
Last updated: 15 February 2022

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Synchronous programming languages.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "Synchronous programming languages"

1

Newman, R. M. "The ClassiC programming language and design of synchronous concurrent object oriented languages." Journal of Systems Architecture 45, no. 5 (1998): 387–407. http://dx.doi.org/10.1016/s1383-7621(97)00089-1.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

LOULERGUE, F. "DISTRIBUTED EVALUATION OF FUNCTIONAL BSP PROGRAMS." Parallel Processing Letters 11, no. 04 (2001): 423–37. http://dx.doi.org/10.1142/s0129626401000701.

Full text
Abstract:
The BS λp-calculus is a calculus of functional bulk synchronous parallel (BSP) programs. It is the basis for the design of a bulk synchronous parallel ML language. For data-parallel languages, there are two points of view: the programming model where a program is seen as a sequence of operations on parallel vectors, and the execution model where the program is a parallel composition of programs run on each processor of the parallel machine. BSP algorithms are defined by data-parallel algorithms with explicit (physical) processes in order to allow their parallel execution time to be estimated. We present here a distributed evaluation minimally synchronous for BSP execution (which corresponds to the execution model). This distributed evaluation is correct w.r.t. the call-by-value strategy of the BS λp-calculus (which corresponds to the programming model).
APA, Harvard, Vancouver, ISO, and other styles
3

Schulz-Rosengarten, Alexander, Steven Smyth, and Michael Mendler. "Toward Object-oriented Modeling in SCCharts." ACM Transactions on Embedded Computing Systems 20, no. 4 (2021): 1–26. http://dx.doi.org/10.1145/3453482.

Full text
Abstract:
Object orientation is a powerful and widely used paradigm for abstraction and structuring in programming. Many languages are designed with this principle or support different degrees of object orientation. In synchronous languages, originally developed to design embedded reactive systems, there are only few object-oriented influences. However, especially in combination with a statechart notation, the modeling process can be improved by facilitating object orientation as we argue here. At the same time the graphical representation can be used to illustrate the object-oriented design of a system. Synchronous statechart dialects, such as the SCCharts language, provide deterministic concurrency for specifying safety-critical systems. Using SCCharts as an example, we illustrate how an object-oriented modeling approach that supports inheritance can be introduced. We further present how external, i.e., host language, objects can be included in the SCCharts language. Specifically, we discuss how the recently developed concepts of scheduling directives and scheduling policies can be used to ensure the determinism of objects while retaining encapsulation.
APA, Harvard, Vancouver, ISO, and other styles
4

Ramesh, S., and Chandrashekhar M. Shetty. "Impossibility of Synchronization in the Presence of Preemption." Parallel Processing Letters 08, no. 01 (1998): 111–20. http://dx.doi.org/10.1142/s0129626498000134.

Full text
Abstract:
This paper is concerned with implementation of Communicating Reactive Processes(CRP), a new paradigm unifying capabilities of synchronous and asynchronous approaches to parallel programming. Synchronous languages like Esterel, Statecharts have features like instantaneous broadcasts, logical concurrency and determinism. Asynchronous languages, like ADA and CSP, allow physical concurrency and rendezvous communication mechanisms. CRP is designed for complex real-time process control applications requiring both forms of concurrency. CRP programs can be compiled into reactive nodes that communicate using rendezvous mechanism. Implementation of rendezvous is non trivial as the following constraints are to be satisfied: 1) mutual agreement over selection of a rendezvous required between the concerned processes, 2) the implementation has to be distributed with no single process knowing instantaneously global state. This problem has been solved for Hoare's CSP, but none of these solutions can be extended to CRP. The reason is that in CRP, an enabled rendezvous can be preempted by a local reaction. In this paper, we establish that there can not exist fully distributed implementation of CRP that allows complete autonomy to reactive nodes.
APA, Harvard, Vancouver, ISO, and other styles
5

DONNELLY, KEVIN, and MATTHEW FLUET. "Transactional events." Journal of Functional Programming 18, no. 5-6 (2008): 649–706. http://dx.doi.org/10.1017/s0956796808006916.

Full text
Abstract:
AbstractConcurrent programs require high-level abstractions in order to manage complexity and enable compositional reasoning. In this paper, we introduce a novel concurrency abstraction, dubbed transactional events, which combines first-class synchronous message passing events with all-or-nothing transactions. This combination enables simple solutions to interesting problems in concurrent programming. For example, guarded synchronous receive can be implemented as an abstract transactional event, whereas in other languages it requires a non-abstract, non-modular protocol. As another example, three-way rendezvous can be implemented as an abstract transactional event, which is impossible using first-class events alone. Both solutions are easy to code and easy to reason about.The expressive power of transactional events arises from a sequencing combinator whose semantics enforces an all-or-nothing transactional property – either both of the constituent events synchronize in sequence or neither of them synchronizes. This sequencing combinator, along with a non-deterministic choice combinator, gives transactional events the compositional structure of a monad-with-plus. We provide a formal semantics for transactional events and give a detailed account of an implementation.
APA, Harvard, Vancouver, ISO, and other styles
6

Lohstroh, Marten, Christian Menard, Soroush Bateni, and Edward A. Lee. "Toward a Lingua Franca for Deterministic Concurrent Systems." ACM Transactions on Embedded Computing Systems 20, no. 4 (2021): 1–27. http://dx.doi.org/10.1145/3448128.

Full text
Abstract:
Many programming languages and programming frameworks focus on parallel and distributed computing. Several frameworks are based on actors, which provide a more disciplined model for concurrency than threads. The interactions between actors, however, if not constrained, admit nondeterminism. As a consequence, actor programs may exhibit unintended behaviors and are less amenable to rigorous testing. We show that nondeterminism can be handled in a number of ways, surveying dataflow dialects, process networks, synchronous-reactive models, and discrete-event models. These existing approaches, however, tend to require centralized control, pose challenges to modular system design, or introduce a single point of failure. We describe “reactors,” a new coordination model that combines ideas from several of these approaches to enable determinism while preserving much of the style of actors. Reactors promote modularity and allow for distributed execution. By using a logical model of time that can be associated with physical time, reactors also provide control over timing. Reactors also expose parallelism that can be exploited on multicore machines and in distributed configurations without compromising determinacy.
APA, Harvard, Vancouver, ISO, and other styles
7

KOUZAPAS, DIMITRIOS, NOBUKO YOSHIDA, RAYMOND HU, and KOHEI HONDA. "On asynchronous eventful session semantics." Mathematical Structures in Computer Science 26, no. 2 (2014): 303–64. http://dx.doi.org/10.1017/s096012951400019x.

Full text
Abstract:
Event-driven programming is one of the major paradigms in concurrent and communication-based programming, where events are typically detected as the arrival of messages on asynchronous channels. Unfortunately, the flexibility and performance of traditional event-driven programming come at the cost of more complex programs: low-level APIs and the obfuscation of event-driven control flow make programs difficult to read, write and verify.This paper introduces a π-calculus with session types that modelsevent-driven session programming(called ESP) and studies its behavioural theory. The main characteristics of the ESP model are asynchronous, order-preserving message passing, non-blocking detection of event/message arrivals and dynamic inspection of session types. Session types offer formal safety guarantees, such as communication and event handling safety, and programmatic benefits that overcome problems with existing event-driven programming languages and techniques. The new typed bisimulation theory developed for the ESP model is distinct from standard synchronous or asynchronous bisimulation, capturing the semantic nature of eventful session-based processes. The bisimilarity coincides with reduction-closed barbed congruence.We demonstrate the features and benefits of ESP and the behavioural theory through two key use cases. First, we examine an encoding and the semantic behaviour of the event selector, a central component of general event-driven systems, providing core results for verifying type-safe event-driven applications. Second, we examine the Lauer–Needham duality, building on the selector encoding and bisimulation theory to prove that a systematic transformation from multithreaded to event-driven session processes is type- and semantics-preserving.
APA, Harvard, Vancouver, ISO, and other styles
8

Sirjani, Marjan, Edward A. Lee, and Ehsan Khamespanah. "Verification of Cyberphysical Systems." Mathematics 8, no. 7 (2020): 1068. http://dx.doi.org/10.3390/math8071068.

Full text
Abstract:
The value of verification of cyberphysical systems depends on the relationship between the state of the software and the state of the physical system. This relationship can be complex because of the real-time nature and different timelines of the physical plant, the sensors and actuators, and the software that is almost always concurrent and distributed. In this paper, we study different ways to construct a transition system model for the distributed and concurrent software components of a CPS. The purpose of the transition system model is to enable model checking, an established and widely used verification technique. We describe a logical-time-based transition system model, which is commonly used for verifying programs written in synchronous languages, and derive the conditions under which such a model faithfully reflects physical states. When these conditions are not met (a common situation), a finer-grained event-based transition system model may be required. We propose an approach for formal verification of cyberphysical systems using Lingua Franca, a language designed for programming cyberphysical systems, and Rebeca, an actor-based language designed for model checking distributed event-driven systems. We focus on the cyber part and model a faithful interface to the physical part. Our method relies on the assumption that the alignment of different timelines during the execution of the system is the responsibility of the underlying platforms. We make those assumptions explicit and clear.
APA, Harvard, Vancouver, ISO, and other styles
9

Halbwachs, N., P. Caspi, P. Raymond, and D. Pilaud. "The synchronous data flow programming language LUSTRE." Proceedings of the IEEE 79, no. 9 (1991): 1305–20. http://dx.doi.org/10.1109/5.97300.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Le Guernic, P., A. Benveniste, P. Bournai, and T. Gautier. "Synchronous Data Flow Programming with the Language SIGNAL." IFAC Proceedings Volumes 20, no. 2 (1987): 359–64. http://dx.doi.org/10.1016/s1474-6670(17)55987-x.

Full text
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Synchronous programming languages"

1

Miller, R. Quentin. "Programming bulk-synchronous parallel computers." Thesis, University of Oxford, 1996. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.318894.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Bourke, Timothy Peter Computer Science &amp Engineering Faculty of Engineering UNSW. "Modelling and programming embedded controllers with timed automata and synchronous languages." Awarded by:University of New South Wales. Computer Science & Engineering, 2009. http://handle.unsw.edu.au/1959.4/44746.

Full text
Abstract:
Embedded controllers coordinate the behaviours of specialised hardware components to satisfy broader application requirements. They are difficult to model and to program. One of the greatest challenges is to express intricate timing behaviours???which arise from the physical characteristics of components???while not precluding efficient implementations on resource-constrained platforms. Aspects of this challenge are addressed by this thesis through four distinct applications of timed automata and the synchronous languages Argos and Esterel. A novel framework for simulating controllers written in an imperative synchronous language is described. It includes a transformation of synchronous models into timed automata that accounts for timing properties which are important in constrained implementations but ignored by the usual assumption of synchrony. The transformation provides an interface between the discrete time of synchronous programs and a continuous model of time. This interface is extended to provide a way for simulating Argos programs within the widely-used Simulink software. Timed automata are well-suited for semantic descriptions, like the aforementioned transformation, and for modelling abstract algorithms and protocols. This thesis also includes a different type of case study. The timing diagram of a small-scale embedded component is modelled in more detail than usual with the aim of studying timing properties in this type of system. Multiple models are constructed, including one of an assembly language controller. Their interrelations are verified in Uppaal using a construction for timed trace inclusion testing. Existing constructions for testing timed trace inclusion do not directly address recent features of the Uppaal modelling language. Novel solutions for the problems presented by selection bindings, quantifiers, and channel arrays in Uppaal are presented in this thesis. The first known implementation of a tool for automatically generating a timed trace inclusion construction is described. The timed automata case study demonstrates one way of implementing application timing behaviours while respecting implementation constraints. A more challenging, but less detailed, example is proposed to evaluate the adequacy of Esterel for such tasks. Since none of the standard techniques are completely adequate, a novel alternative for expressing delays in physical time is proposed. Programs in standard Esterel are recovered through syntactic transformations that account for platform constraints.
APA, Harvard, Vancouver, ISO, and other styles
3

Shen, Ying. "Compiling a synchronous programming language into field programmable gate arrays." Thesis, National Library of Canada = Bibliothèque nationale du Canada, 1999. http://www.collectionscanada.ca/obj/s4/f2/dsk1/tape8/PQDD_0029/MQ47476.pdf.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Guatto, Adrien. "A synchronous functional language with integer clocks." Thesis, Paris Sciences et Lettres (ComUE), 2016. http://www.theses.fr/2016PSLEE020/document.

Full text
Abstract:
Cette thèse traite de la conception et implémentationd’un langage de programmation pour les systèmes detraitement de flux en temps réel, comme l’encodagevidéo. Le modèle des réseaux de Kahn est bien adaptéà ce domaine et y est couramment utilisé. Dans cemodèle, un programme consiste en un ensemble deprocessus parallèles communicant à travers des filesmono-producteur, mono-consommateur. La force dumodèle réside en son déterminisme.Les langages synchrones fonctionnels comme Lustresont dédiés aux systèmes embarqués critiques. Un programmeLustre définit un réseau de Kahn synchronequi peut être exécuté avec des files bornées et sans blocage.Cette propriété est garantie par un système detypes dédié, le calcul d’horloge, qui établit une échellede temps globale à un programme. Cette échelle detemps globale est utilisée pour définir les horloges, sé-quences booléennes indiquant pour chaque file, et àchaque pas de temps, si un processus produit ou consommeune donnée. Cette information sert non seulementà assurer la synchronie mais également à générerdu logiciel ou matériel à état fini.Nous proposons et étudions les horloges entières, unegénéralisation des horloges booléennes autorisant desentiers naturels arbitrairement grands. Les horlogesentières décrivent la production ou consommation deplusieurs valeurs depuis une même file au cours d’uninstant. Nous les utilisons pour définir la constructiond’échelle de temps locale, qui peut masquer despas de temps cachés par un sous-programme au contexteenglobant.Ces principes sont intégrés à un calcul d’horloge pourun langage fonctionnel d’ordre supérieur. Nous étudionsses propriétés et prouvons en particulier que lesprogrammes bien typés ne bloquent pas. Nous compilonsles programmes typés vers des circuits numériquessynchrones en adaptant le schéma de générationde code dirigé par les horloges de Lustre. L’informationde typage contrôle certains compromis entre temps etespace dans les circuits générés<br>This thesis addresses the design and implementationof a programming language for real-time streaming applications,such as video decoding. The model of Kahnprocess networks is a natural fit for this area and hasbeen used extensively. In this model, a program consistsin a set of parallel processes communicating via singlereader, single writer queues. The strength of the modellies in its determinism.Synchronous functional languages such as Lustre arededicated to critical embedded systems. A Lustre programdefines a synchronous Kahn process network, thatis, which can be executed using finite queues and withoutdeadlocks. This is enforced by a dedicated type system,the clock calculus, which establishes a global timescale throughout a program. The global time scale isused to define clocks: per-queue boolean sequences indicating,for each time step, whether a process producesor consumes a token in the queue. This information isused both for enforcing synchrony and for generatingfinite-state software or hardware.We propose and study integer clocks, a generalizationof boolean clocks featuring arbitrarily big natural numbers.Integer clocks model the production or consumptionof several values from the same queue in the courseof a time step. We then rely on integer clocks to definethe local time scale construction, which may hide timesteps performed by a sub-program from the surroundingcontext.These principles are integrated into a clock calculus fora higher-order functional language. We study its properties,proving among other results that well-typed programsdo not deadlock. We adjust the clock-directedcode generation scheme of Lustre to generate finite-statedigital synchronous circuits from typed programs. Thetyping information controls certain trade-offs betweentime and space in the generated circuits
APA, Harvard, Vancouver, ISO, and other styles
5

Attar, Pejman. "Towards a safe and secure synchronous language." Phd thesis, Université Nice Sophia Antipolis, 2013. http://tel.archives-ouvertes.fr/tel-00920152.

Full text
Abstract:
Cette thèse propose une nouvelle approche du parallélisme et de la concurrence, posant les bases d'un langage de programmation à la fois sûr et "secure" (garantissant la sécurité des données), fondé sur une sémantique formelle claire et simple, tout en étant adapté aux architectures multi-cores. Nous avons adopté le paradigme synchrone, dans sa variante réactive, qui fournit une alternative simple à la programmation concurrente standard en limitant l'impact des erreurs dépendant du temps ("data-races"). Dans un premier temps, nous avons considéré un langage réactif d'orchestration, DSL, dans lequel on fait abstraction de la mémoire (Partie 1). Dans le but de pouvoir traiter la mémoire et la sécurité, nous avons ensuite étudié (Partie 2) un noyau réactif, CRL, qui utilise un opérateur de parallélisme déterministe. Nous avons prouvé la réactivité bornée des programmes de CRL. Nous avons ensuite équipé CRL de mécanismes pour contrôler le flux d'information (Partie 3). Pour cela, nous avons d'abord étendu CRL avec des niveaux de sécurité pour les variables et les évènement, puis nous avons défini dans le langage étendu, SSL, un système de types permettant d'éviter les fuites d'information. Parallèlement (Partie 4), nous avons ajouté la mémoire à CRL, en proposant le modèle DSLM. En utilisant une notion d'agent, nous avons structuré la mémoire de telle sorte qu'il ne puisse y avoir de "data-races". Nous avons également étudié l'implémentation de DSLM sur les architectures multi-cores, fondée sur la notion de site et de migration d'un agent entre les sites. L'unification de SSL et de DSLM est une piste pour un travail futur.
APA, Harvard, Vancouver, ISO, and other styles
6

Knee, Simon. "Opal : modular programming using the BSP model." Thesis, University of Oxford, 1997. http://ora.ox.ac.uk/objects/uuid:97d95f01-a098-499c-8c07-303b853c2460.

Full text
Abstract:
Parallel processing can provide the huge computational resources that are required to solve todays grand challenges, at a fraction of the cost of developing sequential machines of equal power. However, even with such attractive benefits the parallel software industry is still very small compared to its sequential counterpart. This has been attributed to the lack of an accepted parallel model of computation, therefore leading to software which is architecture dependent with unpredictable performance. The Bulk Synchronous Parallel (BSP) model provides a solution to these problems and can be compared to the Von Neumann model of sequential computation. In this thesis we investigate the issues involved in providing a modular programming environment based on the BSP model. Using our results we present Opal, a BSP programming language that has been designed for parallel programming-in-the-large. While other BSP languages and libraries have been developed, none of them provide support for libraries of parallel algorithms. A library mechanism must be introduced into BSP without destroying the existing cost model. We examine such issues and show that the active library mechanism of Opal leads to algorithms which still have predictable performance. If algorithms are to retain acceptable levels of performance across a range of machines then they must be able to adapt to the architecture that they are executing on. Such adaptive algorithms require support from the programming language, an issue that has been addressed in Opal. To demonstrate the Opal language and its modular features we present a number of example algorithms. Using an Opal compiler that has been developed we show that we can accurately predict the performance of these algorithms. The thesis concludes that by using Opal it is possible to program the BSP model in a modular fashion that follows good software engineering principles. This enables large scale parallel software to be developed that is architecture independent, has predictable performance and is adaptive to the target architecture.
APA, Harvard, Vancouver, ISO, and other styles
7

Kilaru, Jyothsna. "PLASA| Programming Language for Synchronous Agents." Thesis, California State University, Long Beach, 2019. http://pqdtopen.proquest.com/#viewpdf?dispub=10978428.

Full text
Abstract:
<p> The introduction of autonomous agents to replace humans in unfavorable and unreachable environments has been a longstanding goal in the field of robotics. The existing work of various researchers address several challenges involved in design or control of such robotic systems. However, existing solutions have been unable to offer users an easy and efficient programming environment for developing versatile robotic applications. These inadequacies have given rise to the development of a new robot programming language, called Programming LAnguage for Synchronous Agents (PLASA). </p><p> The main objective of this paper is to give a brief introduction about the newly developed robot programming language, PLASA, which facilitates the rapid implementation of co-operative applications on multiple physical robots, in dynamic environments. The syntax and semantics of this language are similar to those in many other high-level programming languages. In addition to the features offered by other high-level languages, PLASA offers two novel instructions: "do instruction'', which helps in executing the main motion primitives, and "query instruction'', which helps in executing a great variety of geometric and mathematical queries. A compiler produces a program that is executed by a virtual machine in each of the robots. The virtual machine offers a key characteristic that guarantees the timely execution of robots' movements through a synchronization protocol. To verify the correct functionality of the co-operative applications, a simulator that includes the proposed components has been provided. </p><p> The developed language offers abstraction for hiding complex network details and delivers human-readable language; these features make the programming environment suitable for anyone to control robot systems, regardless of expertise. The synchronization and co-ordination mechanisms provided by the language ensure the safety and prompt execution of robot operations in a robot system developed using PLASA.</p><p>
APA, Harvard, Vancouver, ISO, and other styles
8

Talbot, Pierre. "Spacetime programming : a synchronous language for constraint search." Electronic Thesis or Diss., Sorbonne université, 2018. http://www.theses.fr/2018SORUS416.

Full text
Abstract:
La programmation par contraintes est un paradigme basé sur des relations mathématiques appelées contraintes. C'est une approche de programmation déclarative permettant de décrire de nombreux problèmes comme l’ordonnancement de tâches ou des problèmes de composition musicale. On contraste cette approche avec la programmation procédurale qui décrit comment un problème est résolu, tandis que la programmation par contraintes décrit quel est le problème. Dans ce dernier cas, la partie résolution de contraintes est laissé à un solveur de contraintes générique. Malheureusement, il n'existe pas d'algorithme efficace pour tout type de problème, et par conséquent le solveur doit souvent être configuré à la main. Même les langages par contraintes basés sur ces solveurs sont limités pour exprimer des stratégies d'exploration. Dans cette thèse, nous proposons un langage de programmation permettant de programmer des stratégies d'exploration. Nous établissons d'abord une nouvelle formalisation dans la théorie des treillis des problèmes de contraintes. Ceci nous permet de comparer et définir précisément notre langage, appelé programmation spatio-temporelle, et basé sur la programmation synchrone. Ce paradigme ouvre de nouveaux horizons pour programmer des stratégies d'exploration dans les problèmes de satisfaction de contraintes mais aussi, plus généralement, les problèmes utilisant un mécanisme de retour sur traces (i.e. backtracking). On applique notamment ce paradigme à la composition musicale par contraintes, où le compositeur peut naviguer dans l'espace des solutions généré par un problème musical<br>Constraint programming is a paradigm for computing with mathematical relations named constraints. It is a declarative approach to describe many real-world problems including scheduling, vehicles routing, biology and musical composition. Constraint programming must be contrasted with procedural approaches that describe how a problem is solved, whereas constraint models describe what the problem is. The part of how a constraint problem is solved is left to a general constraint solver. Unfortunately, there is no solving algorithm efficient enough to every problem, because the search strategy must often be customized per problem to attain reasonable efficiency. This is a daunting task that requires expertise and good understanding on the solver's intrinsics. Moreover, higher-level constraint-based languages provide limited support to specify search strategies. In this dissertation, we tackle this challenge by designing a programming language for specifying search strategies. It is constructed around two axes: (i) a novel theory of constraint programming based on lattice theory, and (ii) a programming language, called spacetime programming, building on lattice theory for its data structures and on synchronous programming for its computational model. This paradigm opens the door to new, more complex, search strategies in constraint programming but also in applications requiring backtracking search. We demonstrated its usefulness in an interactive computer-aided composition system where we designed a search strategy to help the composer navigating in the state space generated by a musical constraint problem
APA, Harvard, Vancouver, ISO, and other styles
9

Cohen, Albert. "Contributions à la conception de systèmes à hautes performances, programmables et sûrs: principes, interfaces, algorithmes et outils." Habilitation à diriger des recherches, Université Paris Sud - Paris XI, 2007. http://tel.archives-ouvertes.fr/tel-00550830.

Full text
Abstract:
La loi de Moore sur semi-conducteurs approche de sa fin. L'evolution de l'architecture de von Neumann à travers les 40 ans d'histoire du microprocesseur a conduit à des circuits d'une insoutenable complexité, à un très faible rendement de calcul par transistor, et une forte consommation énergetique. D'autre-part, le monde du calcul parallèle ne supporte pas la comparaison avec les niveaux de portabilité, d'accessibilité, de productivité et de fiabilité de l'ingénérie du logiciel séquentiel. Ce dangereux fossé se traduit par des défis passionnants pour la recherche en compilation et en langages de programmation pour le calcul à hautes performances, généraliste ou embarqué. Cette thèse motive notre piste pour relever ces défis, introduit nos principales directions de travail, et établit des perspectives de recherche.
APA, Harvard, Vancouver, ISO, and other styles
10

Delaval, Gwenaël. "Répartition modulaire de programmes synchrones." Phd thesis, Grenoble INPG, 2008. http://tel.archives-ouvertes.fr/tel-00750832.

Full text
Abstract:
Nous nous intéressons à la conception sûre de systèmes répartis. Nous montrons qu'avec la complexité et l'intégration croissante des systèmes embarqués, la structure fonctionnelle du système peut entrer en conflit avec la structure de son architecture. L'approche traditionnelle de conception par raffinement de cette architecture compromet alors la modularité fonctionnelle du système. Nous proposons donc une méthode permettant de concevoir un système réparti défini comme un programme unique, dont la structure fonctionnelle est indépendante de l'architecture du système. Cette méthode est basée sur l'ajout de primitives de répartition à un langage flots de données synchrone. Ces primitives permettent d'une part de déclarer l'architecture sous la forme d'un graphe définissant les ressources existantes et les liens de communication existant entre ces ressources, et d'autre part de spécifier par des annotations la localisation de certaines valeurs et calculs du programme. Nous définissons ensuite la sémantique formelle de ce langage étendu. Cette sémantique a pour but de rendre compte de manière formelle l'effet des annotations ajoutées par le programmeur. Un système de types à effets permet ensuite de vérifier la cohérence de ces annotations. Ce système de types est muni d'un mécanisme d'inférence, qui permet d'inférer, à partir des annotations du programmeur, la localisation des calculs non annotés. Nous définissons ensuite, à partir de ce système de types, une méthode de répartition automatique permettant d'obtenir, à partir d'un programme annoté, un fragment de programme par ressource de l'architecture. La correction du système de types avec la sémantique du langage est prouvée, ainsi que l'équivalence sémantique de l'exécution des fragments obtenus par la méthode de répartition automatique avec le programme initial. Cette méthode a été implémentée dans le compilateur du langage Lucid Synchrone, et testée sur un exemple de radio logicielle.
APA, Harvard, Vancouver, ISO, and other styles

Books on the topic "Synchronous programming languages"

1

Synchronous programming of reactive systems. Kluwer Academic Publishers, 1993.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
2

Gamatié, Abdoulaye. Designing Embedded Systems with the SIGNAL Programming Language: Synchronous, Reactive Specification. Springer-Verlag New York, 2010.

Find full text
APA, Harvard, Vancouver, ISO, and other styles

Book chapters on the topic "Synchronous programming languages"

1

Pnneli, A., O. Shtriehman, and M. Siegel. "Translation validation for synchronous languages." In Automata, Languages and Programming. Springer Berlin Heidelberg, 1998. http://dx.doi.org/10.1007/bfb0055057.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Halbwachs, Nicolas. "Declarative languages: Lustre and Signal." In Synchronous Programming of Reactive Systems. Springer US, 1993. http://dx.doi.org/10.1007/978-1-4757-2231-4_4.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Aguado, Joaquín, Michael Mendler, Reinhard von Hanxleden, and Insa Fuhrmann. "Grounding Synchronous Deterministic Concurrency in Sequential Programming." In Programming Languages and Systems. Springer Berlin Heidelberg, 2014. http://dx.doi.org/10.1007/978-3-642-54833-8_13.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Tiskin, A. "Bulk-synchronous parallel multiplication of boolean matrices." In Automata, Languages and Programming. Springer Berlin Heidelberg, 1998. http://dx.doi.org/10.1007/bfb0055078.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Cuoq, Pascal, and Marc Pouzet. "Modular Causality in a Synchronous Stream Language." In Programming Languages and Systems. Springer Berlin Heidelberg, 2001. http://dx.doi.org/10.1007/3-540-45309-1_16.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Tiskin, A. "Erratum: Bulk-Synchronous Parallel Multiplication of Boolean Matrices." In Automata, Languages and Programming. Springer Berlin Heidelberg, 1999. http://dx.doi.org/10.1007/3-540-48523-6_68.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Leeuwen, Jan, Nicola Santoro, Jorge Urrutia, and Shmuel Zaks. "Guessing games and distributed computations in synchronous networks." In Automata, Languages and Programming. Springer Berlin Heidelberg, 1987. http://dx.doi.org/10.1007/3-540-18088-5_29.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Feldman, Paul, and Silvio Micali. "An optimal probabilistic algorithm for synchronous Byzantine agreement." In Automata, Languages and Programming. Springer Berlin Heidelberg, 1989. http://dx.doi.org/10.1007/bfb0035770.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Cohen, Albert, Louis Mandel, Florence Plateau, and Marc Pouzet. "Abstraction of Clocks in Synchronous Data-Flow Systems." In Programming Languages and Systems. Springer Berlin Heidelberg, 2008. http://dx.doi.org/10.1007/978-3-540-89330-1_17.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Stadtmüller, Kai, Martin Sulzmann, and Peter Thiemann. "Static Trace-Based Deadlock Analysis for Synchronous Mini-Go." In Programming Languages and Systems. Springer International Publishing, 2016. http://dx.doi.org/10.1007/978-3-319-47958-3_7.

Full text
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "Synchronous programming languages"

1

Gretz, Friedrich, and Franz-Josef Grosch. "Blech, Imperative Synchronous Programming!" In 2018 Forum on specification & Design Languages (FDL). IEEE, 2018. http://dx.doi.org/10.1109/fdl.2018.8524036.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

El Sibaïe, Rémy, and Emmanuel Chailloux. "Synchronous-reactive web programming." In SPLASH '16: Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM, 2016. http://dx.doi.org/10.1145/3001929.3001931.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

von Hanxleden, Reinhard, Timothy Bourke, and Alain Girault. "Real-time ticks for synchronous programming." In 2017 Forum on Specification and Design Languages (FDL). IEEE, 2017. http://dx.doi.org/10.1109/fdl.2017.8303893.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Aguado, Joaquin, Michael Mendler, Jia Jie Wang, Bruno Bodin, and Partha Roop. "Compositional timing-aware semantics for synchronous programming." In 2017 Forum on Specification and Design Languages (FDL). IEEE, 2017. http://dx.doi.org/10.1109/fdl.2017.8303895.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Colaço, Jean-Louis. "An overview of Scade, a synchronous language for safety-critical software (keynote)." In SPLASH '20: Conference on Systems, Programming, Languages, and Applications, Software for Humanity. ACM, 2020. http://dx.doi.org/10.1145/3427763.3432350.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Drăgoi, Cezara, Thomas A. Henzinger, and Damien Zufferey. "PSync: a partially synchronous language for fault-tolerant distributed algorithms." In POPL '16: The 43rd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages. ACM, 2016. http://dx.doi.org/10.1145/2837614.2837650.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Santos, Rodrigo C. M., Guilherme F. Lima, Francisco Sant'Anna, Roberto Ierusalimschy, and Edward H. Haeusler. "A memory-bounded, deterministic and terminating semantics for the synchronous programming language Céu." In LCTES '18: SIGPLAN/SIGBED Conference on Languages, Compilers and Tools for Embedded Systems 2018. ACM, 2018. http://dx.doi.org/10.1145/3211332.3211334.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Berry, Gérard, and Manuel Serrano. "HipHop.js: (A)Synchronous reactive web programming." In PLDI '20: 41st ACM SIGPLAN International Conference on Programming Language Design and Implementation. ACM, 2020. http://dx.doi.org/10.1145/3385412.3385984.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Yip, Eugene, Alain Girault, Partha S. Roop, and Morteza Biglari-Abhari. "The ForeC Synchronous Deterministic Parallel Programming Language for Multicores." In 2016 IEEE 10th International Symposium on Embedded Multicore/Many-core Systems-on-Chip (MCSoC). IEEE, 2016. http://dx.doi.org/10.1109/mcsoc.2016.13.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Grosch, Franz-Josef. "Elevate embedded real-time programming with a synchronous language." In MEMOCODE '17: 15th ACM-IEEE International Conference on Formal Methods and Models for System Design. ACM, 2017. http://dx.doi.org/10.1145/3127041.3131363.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Synchronous programming languages' for particular source types:
Journal articles
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography