1,081 research outputs found
Abstract Interpretation with Unfoldings
We present and evaluate a technique for computing path-sensitive interference
conditions during abstract interpretation of concurrent programs. In lieu of
fixed point computation, we use prime event structures to compactly represent
causal dependence and interference between sequences of transformers. Our main
contribution is an unfolding algorithm that uses a new notion of independence
to avoid redundant transformer application, thread-local fixed points to reduce
the size of the unfolding, and a novel cutoff criterion based on subsumption to
guarantee termination of the analysis. Our experiments show that the abstract
unfolding produces an order of magnitude fewer false alarms than a mature
abstract interpreter, while being several orders of magnitude faster than
solver-based tools that have the same precision.Comment: Extended version of the paper (with the same title and authors) to
appear at CAV 201
Parameterized Construction of Program Representations for Sparse Dataflow Analyses
Data-flow analyses usually associate information with control flow regions.
Informally, if these regions are too small, like a point between two
consecutive statements, we call the analysis dense. On the other hand, if these
regions include many such points, then we call it sparse. This paper presents a
systematic method to build program representations that support sparse
analyses. To pave the way to this framework we clarify the bibliography about
well-known intermediate program representations. We show that our approach, up
to parameter choice, subsumes many of these representations, such as the SSA,
SSI and e-SSA forms. In particular, our algorithms are faster, simpler and more
frugal than the previous techniques used to construct SSI - Static Single
Information - form programs. We produce intermediate representations isomorphic
to Choi et al.'s Sparse Evaluation Graphs (SEG) for the family of data-flow
problems that can be partitioned per variables. However, contrary to SEGs, we
can handle - sparsely - problems that are not in this family
VegaProf: Profiling Vega Visualizations
Vega is a popular domain-specific language (DSL) for visualization
specification. At runtime, Vega's DSL is first transformed into a dataflow
graph and then functions to render visualization primitives. While the Vega
abstraction of implementation details simplifies visualization creation, it
also makes Vega visualizations challenging to debug and profile without
adequate tools. Our formative interviews with three practitioners at Sigma
Computing showed that existing developer tools are not suited for visualization
profiling as they are disconnected from the semantics of the Vega DSL
specification and its resulting dataflow graph. We introduce VegaProf, the
first performance profiler for Vega visualizations. VegaProf effectively
instruments the Vega library by associating the declarative specification with
its compilation and execution. Using interactive visualizations, VegaProf
enables visualization engineers to interactively profile visualization
performance at three abstraction levels: function, dataflow graph, and
visualization specification. Our evaluation through two use cases and feedback
from five visualization engineers at Sigma Computing shows that VegaProf makes
visualization profiling tractable and actionable.Comment: Submitted to EuroVis'2
Generating Code and Memory Buffers to Reorganize Data on Many-core Architectures
International audienceThe dataflow programming model has shown to be a relevant approach to efficiently run mas-sively parallel applications over many-core architectures. In this model, some particular builtin agents are in charge of data reorganizations between user agents. Such agents can Split, Join and Duplicate data onto their communication ports. They are widely used in signal processing for example. These system agents, and their associated implementations, are of major impor-tance when it comes to performance, because they can stand on the critical path (think about Amdhal's law). Furthermore, a particular data reorganization can be expressed by the devel-oper in several ways that may lead to inefficient solutions (mostly unneeded data copies and transfers). In this paper, we propose several strategies to manage data reorganization at compile time, with a focus on indexed accesses to shared buffers to avoid data copies. These strategies are complementary: they ensure correctness for each system agent configuration, as well as performance when possible. They have been implemented within the Sigma-C industry-grade compilation toolchain and evaluated over the Kalray MPPA 256-core processor
Ground Profile Recovery from Aerial 3D LiDAR-based Maps
The paper presents the study and implementation of the ground detection
methodology with filtration and removal of forest points from LiDAR-based 3D
point cloud using the Cloth Simulation Filtering (CSF) algorithm. The
methodology allows to recover a terrestrial relief and create a landscape map
of a forestry region. As the proof-of-concept, we provided the outdoor flight
experiment, launching a hexacopter under a mixed forestry region with sharp
ground changes nearby Innopolis city (Russia), which demonstrated the
encouraging results for both ground detection and methodology robustness.Comment: 8 pages, FRUCT-2019 conferenc
A static data flow simulation study at Ames Research Center
Demands in computational power, particularly in the area of computational fluid dynamics (CFD), led NASA Ames Research Center to study advanced computer architectures. One architecture being studied is the static data flow architecture based on research done by Jack B. Dennis at MIT. To improve understanding of this architecture, a static data flow simulator, written in Pascal, has been implemented for use on a Cray X-MP/48. A matrix multiply and a two-dimensional fast Fourier transform (FFT), two algorithms used in CFD work at Ames, have been run on the simulator. Execution times can vary by a factor of more than 2 depending on the partitioning method used to assign instructions to processing elements. Service time for matching tokens has proved to be a major bottleneck. Loop control and array address calculation overhead can double the execution time. The best sustained MFLOPS rates were less than 50% of the maximum capability of the machine
Mechanized semantics
The goal of this lecture is to show how modern theorem provers---in this
case, the Coq proof assistant---can be used to mechanize the specification of
programming languages and their semantics, and to reason over individual
programs and over generic program transformations, as typically found in
compilers. The topics covered include: operational semantics (small-step,
big-step, definitional interpreters); a simple form of denotational semantics;
axiomatic semantics and Hoare logic; generation of verification conditions,
with application to program proof; compilation to virtual machine code and its
proof of correctness; an example of an optimizing program transformation (dead
code elimination) and its proof of correctness
- …