184,402 research outputs found
Creating a Distributed Programming System Using the DSS: A Case Study of OzDSS
This technical report describes the integration of the Distribution Subsystem (DSS) to the programming system Mozart. The result, OzDSS, is described in detail. Essential when coupling a programming system to the DSS is how the internal model of threads and language entities are mapped to the abstract entities of the DSS. The model of threads and language entities of Mozart is described at a detailed level to explain the design choices made when developing the code that couples the DSS to Mozart. To show the challenges associated with different thread implementations, the C++DSS system is introduced. C++DSS is a C++ library which uses the DSS to implement different types of distributed language entities in the form of C++ classes. Mozart emulates threads, thus there is no risk of multiple threads accessing the DSS simultaneously. C++DSS, on the other hand, makes use of POSIX threads, thus simultaneous access to the DSS from multiple POSIX threads can happen. The fundamental differences in how threads are treated in a system that emulates threads (Mozart) to a system that make use of native-threads~(C++DSS) is discussed. The paper is concluded by a performance comparison between the OzDSS system and other distributed programming systems. We see that the OzDSS system outperforms ``industry grade'' Java-RMI and Java-CORBA implementations
A Model of Cooperative Threads
We develop a model of concurrent imperative programming with threads. We
focus on a small imperative language with cooperative threads which execute
without interruption until they terminate or explicitly yield control. We
define and study a trace-based denotational semantics for this language; this
semantics is fully abstract but mathematically elementary. We also give an
equational theory for the computational effects that underlie the language,
including thread spawning. We then analyze threads in terms of the free algebra
monad for this theory.Comment: 39 pages, 5 figure
From Single-thread to Multithreaded: An Efficient Static Analysis Algorithm
A great variety of static analyses that compute safety properties of
single-thread programs have now been developed. This paper presents a
systematic method to extend a class of such static analyses, so that they
handle programs with multiple POSIX-style threads. Starting from a pragmatic
operational semantics, we build a denotational semantics that expresses
reasoning a la assume-guarantee. The final algorithm is then derived by
abstract interpretation. It analyses each thread in turn, propagating
interferences between threads, in addition to other semantic information. The
combinatorial explosion, ensued from the explicit consideration of all
interleavings, is thus avoided. The worst case complexity is only increased by
a factor n compared to the single-thread case, where n is the number of
instructions in the program. We have implemented prototype tools, demonstrating
the practicality of the approach
A progression ring for interfaces of instruction sequences, threads, and services
We define focus-method interfaces and some connections between such
interfaces and instruction sequences, giving rise to instruction sequence
components. We provide a flexible and practical notation for interfaces using
an abstract datatype specification comparable to that of basic process algebra
with deadlock. The structures thus defined are called progression rings. We
also define thread and service components. Two types of composition of
instruction sequences or threads and services (called `use' and `apply') are
lifted to the level of components.Comment: 12 page
Bialgebraic Semantics for Logic Programming
Bialgebrae provide an abstract framework encompassing the semantics of
different kinds of computational models. In this paper we propose a bialgebraic
approach to the semantics of logic programming. Our methodology is to study
logic programs as reactive systems and exploit abstract techniques developed in
that setting. First we use saturation to model the operational semantics of
logic programs as coalgebrae on presheaves. Then, we make explicit the
underlying algebraic structure by using bialgebrae on presheaves. The resulting
semantics turns out to be compositional with respect to conjunction and term
substitution. Also, it encodes a parallel model of computation, whose soundness
is guaranteed by a built-in notion of synchronisation between different
threads
- …