The Experts below are selected from a list of 300 Experts worldwide ranked by ideXlab platform

Stephen A. Edwards - One of the best experts on this subject based on the ideXlab platform.

  • static deadlock detection for the shim Concurrent Language
    International Conference on Formal Methods and Models for Co-Design, 2008
    Co-Authors: Nalini Vasudevan, Stephen A. Edwards
    Abstract:

    Concurrent programming Languages are becoming mandatory with the advent of multi-core processors. Two major concerns in any Concurrent program are data races and deadlocks. Each are potentially subtle bugs that can be caused by non-deterministic scheduling choices in most Concurrent formalisms. As an alternative, the SHIM Concurrent Language guarantees the absence of data races by eschewing shared memory, but a SHIM program may still deadlock if a program violates a communication protocol. We present a model-checking-based static deadlock detection technique for the SHIM Language. Although SHIM is asynchronous, its semantics allow us to model it synchronously without losing precision, greatly reducing the state space that must be explored. This plus the obvious division between control and data in SHIM programs makes it easy to construct concise abstractions. Experimentally, we find our procedure runs in only a few seconds for modest-sized programs, making it practical to use as part of a compilation chain.

  • MEMOCODE - Static Deadlock Detection for the SHIM Concurrent Language
    2008 6th ACM IEEE International Conference on Formal Methods and Models for Co-Design, 2008
    Co-Authors: Nalini Vasudevan, Stephen A. Edwards
    Abstract:

    Concurrent programming Languages are becoming mandatory with the advent of multi-core processors. Two major concerns in any Concurrent program are data races and deadlocks. Each are potentially subtle bugs that can be caused by non-deterministic scheduling choices in most Concurrent formalisms. As an alternative, the SHIM Concurrent Language guarantees the absence of data races by eschewing shared memory, but a SHIM program may still deadlock if a program violates a communication protocol. We present a model-checking-based static deadlock detection technique for the SHIM Language. Although SHIM is asynchronous, its semantics allow us to model it synchronously without losing precision, greatly reducing the state space that must be explored. This plus the obvious division between control and data in SHIM programs makes it easy to construct concise abstractions. Experimentally, we find our procedure runs in only a few seconds for modest-sized programs, making it practical to use as part of a compilation chain.

  • MacShim: Compiling MATLAB to a Scheduling-Independent Concurrent Language
    2006
    Co-Authors: Neesha Subramaniam, Stephen A. Edwards, Oda Ohan
    Abstract:

    Nondeterminism is a central challenge in most Concurrent models of computation. That programmers must worry about races and other timing-dependent behavior is a key reason that parallel programming has not been widely adopted. The SHIM Concurrent Language, intended for hardware/software codesign applications, avoids this problem by providing deterministic (race-free) concurrency, but does not support automatic parallelization of sequential algorithms. In this paper, we present a compiler able to parallelize a simple MATLAB-like Language into Concurrent SHIM processes. From a user-provided partitioning of arrays to processes, our compiler divides the program into coarse-grained processes and schedules and synthesizes inter-process communication. We demonstrate the effectiveness of our approach on some image-processing algorithms.

  • EMSOFT - Scheduling-independent threads and exceptions in SHIM
    Proceedings of the 6th ACM & IEEE International conference on Embedded software - EMSOFT '06, 2006
    Co-Authors: Olivier Tardieu, Stephen A. Edwards
    Abstract:

    Concurrent programming Languages should be a good fit for embedded systems because they match the intrinsic parallelism of their architectures and environments. Unfortunately, typical Concurrent programming formalisms are prone to races and nondeterminism, despite the presence of mechanisms such as monitors.In this paper, we propose SHIM, the core of a deterministic Concurrent Language, meaning the behavior of a program is independent of the scheduling of Concurrent operations. SHIM does not sacrifice power or flexibility to achieve this determinism. It supports both synchronous and asynchronous paradigms-loosely and tightly synchronized threads-the dynamic creation of threads and shared variables, recursive procedures, and exceptions.We illustrate our programming model with examples including breadth-first-search algorithms and pipelines. By construction, they are race-free. We provide the formal semantics of SHIM and a pre-liminary implementation.

  • Compiling Esterel into Static Discrete-Event Code
    Electronic Notes in Theoretical Computer Science, 2006
    Co-Authors: Stephen A. Edwards, Vimal M. Kapadia, Michael Halas
    Abstract:

    Executing Concurrent specifications on sequential hardware is important for both simulation of systems that are eventually implemented on Concurrent hardware and for those most conveniently described as a set of Concurrent processes. As with most forms of simulation, this is easy to do correctly but difficult to do efficiently. Solutions such as preemptive operating systems and discrete-event simulators present significant overhead. In this paper, we present a technique for compiling the Concurrent Language Esterel into very efficient C code. Our technique minimizes runtime overhead by making most scheduling decisions at compile time and using a very simple linked-list-based event queue at runtime. While these techniques work particularly well for Esterel with its high-level Concurrent semantics, the same technique could also be applied to efficiently execute other Concurrent specifications.

Ana Cavalcanti - One of the best experts on this subject based on the ideXlab platform.

  • ZB - The Semantics of Circus
    ZB 2002:Formal Specification and Development in Z and B, 2002
    Co-Authors: Jim Woodcock, Ana Cavalcanti
    Abstract:

    Circus is a Concurrent Language for refinement; it is a unification of imperative CSP, Z, and the refinement calculus. We describe the Language of Circus and the formalisation of its model in Hoare & He's unifying theories of programming.

  • a Concurrent Language for refinement
    Formal Methods, 2001
    Co-Authors: Jim Woodcock, Ana Cavalcanti
    Abstract:

    We present a combination of the well-established formal specification Languages Z and CSP; our objective is to provide support for the specification of both data and behaviour aspects of Concurrent systems, and a development technique. The resulting Language, Circus, distinguishes itself in that it is aimed at the calculational refinement of specifications to programs written in a Language similar to occam and Handel-C. In this paper, we present Circus, the rationale for its design, and a case study in its use.

  • IWFM - A Concurrent Language for refinement
    2001
    Co-Authors: Jim Woodcock, Ana Cavalcanti
    Abstract:

    We present a combination of the well-established formal specification Languages Z and CSP; our objective is to provide support for the specification of both data and behaviour aspects of Concurrent systems, and a development technique. The resulting Language, Circus, distinguishes itself in that it is aimed at the calculational refinement of specifications to programs written in a Language similar to occam and Handel-C. In this paper, we present Circus, the rationale for its design, and a case study in its use.

Konstantinos Sagonas - One of the best experts on this subject based on the ideXlab platform.

  • A Concurrent Language with a uniform treatment of regions and locks
    Electronic Proceedings in Theoretical Computer Science, 2010
    Co-Authors: Prodromos Gerakios, Nikolaos Papaspyrou, Konstantinos Sagonas
    Abstract:

    A challenge for programming Language research is to design and implement multi-threaded low-level Languages providing static guarantees for memory safety and freedom from data races. Towards this goal, we present a Concurrent Language employing safe region-based memory management and hierarchical locking of regions. Both regions and locks are treated uniformly, and the Language supports ownership transfer, early deallocation of regions and early release of locks in a safe manner.

  • a Concurrent Language with a uniform treatment of regions and locks
    Electronic Proceedings in Theoretical Computer Science, 2010
    Co-Authors: Prodromos Gerakios, Nikolaos Papaspyrou, Konstantinos Sagonas
    Abstract:

    A challenge for programming Language research is to design and implement multi-threaded low-level Languages providing static guarantees for memory safety and freedom from data races. Towards this goal, we sketch a Concurrent Language employing safe region-based memory management and hierarchical locking of regions. Both regions and locks are treated uniformly, and the Language supports ownership transfer, early deallocation of regions and early release of locks in a safe manner.

  • message analysis guided allocation and low pause incremental garbage collection in a Concurrent Language
    International Symposium on Memory Management, 2004
    Co-Authors: Konstantinos Sagonas, Jesper Wilhelmsson
    Abstract:

    We present a memory management scheme for a Concurrent programming Language where communication occurs using message-passing with copying semantics. The runtime system is built around process-local heaps, which frees the memory manager from redundant synchronization in a multithreaded implementation and allows the memory reclamation of process-local heaps to be a private business and to often take place without garbage collection. The allocator is guided by a static analysis which speculatively allocates data possibly used as messages in a shared memory area. To respect the (soft) real-time requirements of the Language, we develop a generational, incremental garbage collection scheme tailored to the characteristics of this runtime system. The collector imposes no overhead on the mutator, requires no costly barrier mechanisms, and has a relatively small space overhead. We have implemented these schemes in the context of an industrial-strength implementation of a Concurrent functional Language used to develop large-scale, highly Concurrent, embedded applications. Our measurements across a range of applications indicate that the incremental collector substantially reduces pause times, imposes only very small overhead on the total runtime, and achieves a high degree of mutator utilization.

Hans-j. Boehm - One of the best experts on this subject based on the ideXlab platform.

  • conflict exceptions simplifying Concurrent Language semantics with precise hardware exceptions for data races
    International Symposium on Computer Architecture, 2010
    Co-Authors: Brandon Lucia, Karin Strauss, Luis Ceze, Shaz Qadeer, Hans-j. Boehm
    Abstract:

    We argue in this paper that concurrency errors should be treated as exceptions, i.e., have fail-stop behavior and precise semantics. We propose an exception model based on conflict of synchronization free regions, which precisely detects a broad class of data-races. We show that our exceptions provide enough guarantees to simplify high-level programming Language semantics and debugging, but are significantly cheaper to enforce than traditional data-race detection. To make the performance cost of enforcement negligible, we propose architecture support for accurately detecting and precisely delivering these exceptions. We evaluate the suitability of our model as well as the behavior of our architectural mechanisms using the PARSEC benchmark suite and commercial applications. Our results show that the exception model largely reflects how programmers are already writing code and that the main memory, traffic and performance overheads of the enforcement mechanisms we propose are very low.

  • ISCA - Conflict exceptions: simplifying Concurrent Language semantics with precise hardware exceptions for data-races
    Proceedings of the 37th annual international symposium on Computer architecture - ISCA '10, 2010
    Co-Authors: Brandon Lucia, Karin Strauss, Luis Ceze, Shaz Qadeer, Hans-j. Boehm
    Abstract:

    We argue in this paper that concurrency errors should be treated as exceptions, i.e., have fail-stop behavior and precise semantics. We propose an exception model based on conflict of synchronization free regions, which precisely detects a broad class of data-races. We show that our exceptions provide enough guarantees to simplify high-level programming Language semantics and debugging, but are significantly cheaper to enforce than traditional data-race detection. To make the performance cost of enforcement negligible, we propose architecture support for accurately detecting and precisely delivering these exceptions. We evaluate the suitability of our model as well as the behavior of our architectural mechanisms using the PARSEC benchmark suite and commercial applications. Our results show that the exception model largely reflects how programmers are already writing code and that the main memory, traffic and performance overheads of the enforcement mechanisms we propose are very low.

Jim Woodcock - One of the best experts on this subject based on the ideXlab platform.

  • ZB - The Semantics of Circus
    ZB 2002:Formal Specification and Development in Z and B, 2002
    Co-Authors: Jim Woodcock, Ana Cavalcanti
    Abstract:

    Circus is a Concurrent Language for refinement; it is a unification of imperative CSP, Z, and the refinement calculus. We describe the Language of Circus and the formalisation of its model in Hoare & He's unifying theories of programming.

  • a Concurrent Language for refinement
    Formal Methods, 2001
    Co-Authors: Jim Woodcock, Ana Cavalcanti
    Abstract:

    We present a combination of the well-established formal specification Languages Z and CSP; our objective is to provide support for the specification of both data and behaviour aspects of Concurrent systems, and a development technique. The resulting Language, Circus, distinguishes itself in that it is aimed at the calculational refinement of specifications to programs written in a Language similar to occam and Handel-C. In this paper, we present Circus, the rationale for its design, and a case study in its use.

  • IWFM - A Concurrent Language for refinement
    2001
    Co-Authors: Jim Woodcock, Ana Cavalcanti
    Abstract:

    We present a combination of the well-established formal specification Languages Z and CSP; our objective is to provide support for the specification of both data and behaviour aspects of Concurrent systems, and a development technique. The resulting Language, Circus, distinguishes itself in that it is aimed at the calculational refinement of specifications to programs written in a Language similar to occam and Handel-C. In this paper, we present Circus, the rationale for its design, and a case study in its use.