1,199 research outputs found
Lambda Calculus in Core Aldwych
No full textCore Aldwych is a simple model for concurrent computation, involving the concept of agents which communicate through shared variables. Each variable will have exactly one agent that can write to it, and its value can never be changed once written, but a value can contain further variables which are written to later. A key aspect is that the reader of a value may become the writer of variables in it. In this paper we show how this model can be used to encode lambda calculus. Individual function applications can be explicitly encoded as lazy or not, as required. We then show how this encoding can be extended to cover functions which manipulate mutable variables, but with the underlying Core Aldwych implementation still using only immutable variables. The ordering of function applications then becomes an issue, with Core Aldwych able to model either the enforcement of an ordering or the retention of indeterminate ordering, which allows parallel execution
Mobile Data, Dynamic Allocation and Zero Aliasing: an occam Experiment
No full textF.R.M. Barnes and P.H. Welch Communicating Process Architectures 2001 (WoTUG 24) Traditional imperative languages (such as C) and modern object-oriented languages are plagued by uncontrolled resource aliasing problems. Add in concurrency and the problems compound exponentially. Improperly synchronised access to shared (i.e. aliased) resources leads to problems of race-hazard, deadlock, livelock and starvation. This paper describes the binding into occam (a concurrent processing language based on CSP) of a secure, dynamic and efficient way of sharing data between parallel processes with minimal synchronisation overheads. The key new facilities provided are: a movement semantics for assignment and communication, strict zero-aliasing, apparently dynamic memory allocation and automatic zero-or-very-small-unit-time garbage collection. The implementation of this mechanism is also presented, along with some initial performance figures (e.g. 80ns for mobile communication on an 800 MHz Pentium 3). With occam becoming available on a variety of microprocessors for GUI building, internet services and small-memory-footprint embedded products, these capabilities are timely. Lessons are drawn for concurrency back in OO languages - and especially for the JCSP (CSP for Java) package library
Communicating Mobile Processes
No full textThis paper presents a new model for mobile processes in occam-pi. A process, embedded anywhere in a dynamically evolving network, may suspend itself mid-execution, be safely disconnected from its local environment, moved (by communication along a channel), reconnected to a new environment and reactivated. Upon reactivation, the process resumes execution from the same state (i.e. data values and code positions) it held when it suspended. Its view of its environment is unchanged, since that is abstracted by its synchronisation (e.g. channels and barriers) interface and that remains constant. The environment behind that interface will (usually) be completely different. The mobile process itself may contain any number of levels of dynamic sub-network. This model is simpler and, in some ways, more powerful than our earlier proposal, which required a process to terminate before it could be moved. Its formal semantics and implementation, however, throw up extra challenges. We present details and performance of an initial implementation
Communicating Process Architectures 2008
No full textCommunicating Process Architectures 2008 contains the proceedings of the thirty-first CPA conference, organized under the auspices of WoTUG and the Department of Computer Science of the University of York. The aim of this book is to cover both theoretical aspects and industrial applications of Communicating Processes. Two invited speakers have given excellent contributions to this topic. Professor Samson Abramsky has worked in the areas of semantics and logic of computation, and concurrency. His work on game semantics considers interaction and information flow between multiple agents and their environment. This has yielded new approaches to compositional model-checking and to analysis for programs with state, concurrency, probability and other features. Professor Colin O’Halloran has been instrumental in the uptake of formal methods in the development and verification of high assurance systems on an industrial scale. His research interests are in automating the use of formal methods, and using these techniques at reasonable cost and on an industrial scale
tranx86 -- an Optimising ETC to IA32 Translator
No full texttranx86 -- an Optimising ETC to IA32 Translator ----------------------------------------------- F.R.M. Barnes Communicating Process Architectures 2001 (WoTUG 24) This paper describes tranx86, a program which converts Extended Transputer Code (ETC) from a modified Inmos occam compiler, into IA32 code for execution on the Intel i386 family of processors within the KRoC/Linux system. Several optimisations are employed in an attempt to maximise performance on this family of processors, including optimisations in the CCSP run-time kernel. These include a graph-colouring type register allocation scheme and various inlining of code. While tranx86 is mostly architecture dependent, effort has been made to allow the use of arbitrary schedulers, although currently CCSP is the only fully supported one. Various benchmark programs are used to compare the performance of this translator with the old system, giving significant time wins in some cases. For the commstime benchmark program on an 800 MHz Pentium-3, the old KRoC/Linux system gave 233 ns per communication (2 context switches); the new one, with optimisations and inlining, gives 67 ns per communication -- more than a 3-fold reduction in overheads
An Introduction to the Kent C++CSP Library
No full textThis paper reports on a CSP library for C++, developed over the past year at the University of Kent. It is based on the OO-design and API of JCSP and the lightweight algorithms of KRoC occam, with extensions to exploit specific C++ capabilities (such as templates). Both user-level and operating system threads are used to provide a range of oimplementation options and semantics (e.g. for managing blocking system calls intelligently) that run efficiently under either Windows or Linux. The library is presented from the user's point of view, mainly by way of a tutorial. Implementation details are also outlines and some benchmark results given. The performance of C++CSP is between that of KRoC occam and JCSP -- fairly close to KRoC
Using Java for Parallel Computing: JCSP versus CTJ
No full textJava provides support for concurrent and parallel programming through threads, monitors and its socket and Remote Method Invocation (RMI) classes. However, there have been many concerns expressed about the way in which this support is provided, e.g., [1][2], citing problems such as improper implementation of monitors and difficulty of programming with threads. Hoare’s Communicating Sequential Processes (CSP) [3][4][5] model fully specifies thread synchronization and is based on processes, compositions, and channel communication. It provides a mathematical notation for describing patterns of communication using algebraic expressions and contains formal proofs for analyzing, verifying and eliminating undesirable conditions, such as race hazards, deadlocks, livelock, and starvation. Two independent research efforts provide a CSP based process-oriented design pattern for concurrency implemented in Java: Communicating Sequential Processes for Java (JCSP) [6] and Communication Threads in Java (CTJ) [7]. In this paper, we compare these two packages, looking at the philosophy behind their development,
their similarities, their differences, their performance, and their use
Cluster Computing and JCSP Networking
No full textHoare's algebra of Communicating Sequential Processes (CSP) enables a view of systems as layered networks of concurrent components, generating and responding to events communicated to each other through channels, barriers and other formally defined synchronisation primitives. The resulting image and discipline is close to hardware design and correspondingly easy to visualise, reason about, compose and scale. JCSP is a library of Java packages providing an (occam) extended version of this model that may be used alongside, or as a replacement for, the very different threads-and-monitors concurrency mechanisms built into Java. The current release (JCSP 1.0) supports concurrency within a single Java Virtual Machine (which may be multi-processor). This paper reports early experiments with JCSP.net, an extension of JCSP for the dynamic construction of CSP networks across distributed environments. The aims of JCSP.net are to simplify the construction and programming of dynamically distributed and parallel systems. It provides high-level support for CSP architectures, unifying concurrency logic within and between processors. The experiments are on some classical HPC problems, an area of work for which JCSP.net was not primarily designed. However, low overheads in the supporting infrastructure were a primary consideration - along with an intuitive and high-level distributed programming model (based on CSP). Results reported show JCSP holding up well against - and often exceeding - the performance obtained from existing tools such as mpiJava and IBM's TSpaces. The experimental platform was a cluster of 16 dual-processor PIII Linux machines. It is expected that future optimisations in the pipeline for the JCSP.net infrastructure will improve the results presented here. JCSP and JCSP.net were developed at the University of Kent
The Transterpreter: A Transputer Interpreter
No full textWe have written the Transterpreter, a virtual machine for executing the transputer instruction set. This interpreter is a small, portable, and extensible run-time, intended to be easily ported to handheld computers, mobile phones, and other embedded contexts. In striving for this level of portability, occam programs compiled to Transputer byte-code can currently be run on desktop computers, handhelds, and even the LEGO Mindstorms robotics kit
Process support for evolving active architectures
No full textThis work is supported by the EC Framework V project ArchWare (IST-001-32360), and the UK Engineering and Physical Sciences Research Council (EPSRC) under grants GR/R51872 (Reflective Application Framework for Distributed Architectures) and GR/R67743 (my Grid: Directly Supporting the E-Scientist).Long-lived, architecture-based software. systems are increasingly important. Effective process support for these systems depends upon recognising their compositional nature and the active, role of their architecture in guiding evolutionary development. Current process approaches have difficulty with run-time architecture changes that are not known a priori, and dealing with extant data during system evolution. This paper describes an approach that deals with these issues. It is based on a process-aware architecture description language (ADL), with explicit compose and decompose constructs, and with a hyper-code representation for dealing with extant data and code. An example is given to illustrate the ease-of-use benefits of this approach
- …
