Results 1 -
9 of
9
Concurrent Separation Logic for Pipelined Parallelization
"... Abstract. Recent innovations in automatic parallelizing compilers are showing impressive speedups on multicore processors using shared memory with asynchronous channels. We have formulated an operational semantics and proved sound a concurrent separation logic to reason about multithreaded programs ..."
Abstract
-
Cited by 9 (0 self)
- Add to MetaCart
(Show Context)
Abstract. Recent innovations in automatic parallelizing compilers are showing impressive speedups on multicore processors using shared memory with asynchronous channels. We have formulated an operational semantics and proved sound a concurrent separation logic to reason about multithreaded programs that communicate asynchronously through channels and share memory. Our logic supports shared channel endpoints (multiple producers and consumers) and introduces histories to overcome limitations with local reasoning. We demonstrate how to transform a sequential proof into a parallelized proof that targets the output of the parallelizing optimization DSWP (Decoupled Software Pipelining). 1
Interprocedural Dependence Analysis of Higher-Order Programs via Stack Reachability
"... We present a small-step abstract interpretation for the A-Normal Form λ-calculus (ANF). This abstraction has been instrumented to find data-dependence conflicts for expressions and procedures. Our goal is parallelization: when two expressions have no de-pendence conflicts, it is safe to evaluate the ..."
Abstract
-
Cited by 8 (2 self)
- Add to MetaCart
(Show Context)
We present a small-step abstract interpretation for the A-Normal Form λ-calculus (ANF). This abstraction has been instrumented to find data-dependence conflicts for expressions and procedures. Our goal is parallelization: when two expressions have no de-pendence conflicts, it is safe to evaluate them in parallel. The under-lying principle for discovering dependences is Harrison’s principle: whenever a resources is accessed or modified, procedures that have frames live on the stack have a dependence upon that resource. The abstract interpretation models the stack of a modified CESK ma-chine by mimicking heap-allocation of continuations. Abstractions of continuation marks are employed so that the abstract semantics retain proper tail-call optimization without sacrificing dependence information.
Resource-Sensitive Synchronization Inference by Abduction
"... We present an analysis which takes as its input a sequential program, augmented with annotations indicating potential parallelization opportunities, and a sequential proof, written in separation logic, and produces a correctly-synchronized parallelized program and proof of that program. Unlike previ ..."
Abstract
-
Cited by 3 (1 self)
- Add to MetaCart
(Show Context)
We present an analysis which takes as its input a sequential program, augmented with annotations indicating potential parallelization opportunities, and a sequential proof, written in separation logic, and produces a correctly-synchronized parallelized program and proof of that program. Unlike previous work, ours is not an independence analysis; we insert synchronization constructs to preserve relevant dependencies found in the sequential program that may otherwise be violated by a naïve translation. Separation logic allows us to parallelize fine-grained patterns of resource-usage, moving beyond straightforward points-to analysis. Our analysis works by using the sequential proof to discover dependencies between different parts of the program. It leverages these discovered dependencies to guide the insertion of synchronization primitives into the parallelized program, and to ensure that the resulting parallelized program satisfies the same specification as the original sequential program, and exhibits the same sequential behaviour. Our analysis is built using frame inference and abduction, two techniques supported by an increasing number of separation logic tools.
Making fast hardware with separation logic
"... Recently developed tools now allow us to automatically synthesize hardware from programs that use the heap [5]. Unfortunately, because current tools are unable to accurately track the heap-carried data dependencies between program commands, the synthesis tools miss many opportunities for optimizatio ..."
Abstract
-
Cited by 2 (0 self)
- Add to MetaCart
(Show Context)
Recently developed tools now allow us to automatically synthesize hardware from programs that use the heap [5]. Unfortunately, because current tools are unable to accurately track the heap-carried data dependencies between program commands, the synthesis tools miss many opportunities for optimization, such as pipelining, parallelization, or memory localization. Thus, the resulting circuits have poor performance. In this paper we describe a separation logic based program analysis for identifying heap-carried data dependencies between program statements, and demonstrate the performance gains that it enables when performing hardware synthesis. 1.
A Primer on Separation Logic (and Automatic Program Verification and Analysis)
"... Abstract. These are the notes to accompany a course at the Marktoberdorf PhD summer school in 2011. The course consists of an introduction to separation logic, with a slant towards its use in automatic program verification and analysis. ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
(Show Context)
Abstract. These are the notes to accompany a course at the Marktoberdorf PhD summer school in 2011. The course consists of an introduction to separation logic, with a slant towards its use in automatic program verification and analysis.
A Proof-Directed Parallelization Synthesis by Separation Logic
"... We present an analysis which takes as its input a sequential program, augmented with annotations indicating potential parallelization opportunities, and a sequential proof, written in separation logic, and produces a correctly-synchronized parallelized program and proof of that program. Unlike previ ..."
Abstract
-
Cited by 1 (0 self)
- Add to MetaCart
We present an analysis which takes as its input a sequential program, augmented with annotations indicating potential parallelization opportunities, and a sequential proof, written in separation logic, and produces a correctly-synchronized parallelized program and proof of that program. Unlike previous work, ours is not a simple independence analysis that admits parallelization only when threads do not interfere; rather, we insert synchronization to preserve dependencies in the sequential program that might be violated by a naïve translation. Separation logic allows us to parallelize fine-grained patterns of resource-usage, moving beyond straightforward points-to analysis. The sequential proof need only represent shape properties, meaning we can handle complex algorithms without verifying every aspect of their behavior. Our analysis works by using the sequential proof to discover dependencies between different parts of the program. It leverages these discovered dependencies to guide the insertion of synchronization primitives into the parallelized program, and to ensure that the resulting parallelized program satisfies the same specification as the original sequential program, and exhibits the same sequential behavior. Our analysis is built using frame inference and abduction, two techniques supported by an increasing number of separation logic tools.
5.1.3. Formalising Geometric Algebras 4
"... c t i v it y e p o r t 2009 Table of contents ..."
(Show Context)
ISSN 1476-2986Resource-Sensitive Synchronization Inference by Abduction
, 2012
"... Number 808 ..."
(Show Context)
TOWARDS FUZZY GRANULARITY CONTROL IN PARALLEL/DISTRIBUTED COMPUTING
"... Automatic parallelization has become a mainstream research topic for different reasons. For example, multicore architectures, which are now present even in laptops, have awakened an interest in software tools that can exploit the computing power of parallel processors. Distributed and (multi)agent s ..."
Abstract
- Add to MetaCart
Automatic parallelization has become a mainstream research topic for different reasons. For example, multicore architectures, which are now present even in laptops, have awakened an interest in software tools that can exploit the computing power of parallel processors. Distributed and (multi)agent systems also benefit from techniques and tools for deciding in which locations should processes be run to make a better use of the available resources. Any decision on whether to execute some processes in parallel or sequentially must ensure correctness (i.e., the parallel execution obtains the same results as the sequential), but also has to take into account a number of practical overheads, such as those associated with tasks creation, possible migration of tasks to remote processors, the associated communication overheads, etc. Due to these overheads and if the granularity of parallel tasks, i.e., the “work available ” underneath them, is too small, it may happen that the costs are larger than the benefits in their parallel execution. Thus, the aim of granularity control is to change parallel execution to sequential execution or vice-versa based on some conditions related to grain size and overheads. In this work, we have applied fuzzy logic to automatic granularity control in parallel/distributed computing and proposed fuzzy conditions for deciding whether to execute some given tasks in parallel or sequentially. We have compared our proposed fuzzy conditions with existing (conservative) sufficient conditions and our experiments showed that the proposed fuzzy conditions result in more efficient executions on average than the conservative conditions.
