2,594 research outputs found
A compiler approach to scalable concurrent program design
The programmer's most powerful tool for controlling complexity in program design is abstraction. We seek to use abstraction in the design of concurrent programs, so as to
separate design decisions concerned with decomposition, communication, synchronization, mapping, granularity, and load balancing. This paper describes programming and compiler techniques intended to facilitate this design strategy. The programming techniques are based on a core programming notation with two important properties: the ability to separate concurrent programming concerns, and extensibility with reusable programmer-defined
abstractions. The compiler techniques are based on a simple transformation system together with a set of compilation transformations and portable run-time support. The
transformation system allows programmer-defined abstractions to be defined as source-to-source transformations that convert abstractions into the core notation. The same
transformation system is used to apply compilation transformations that incrementally transform the core notation toward an abstract concurrent machine. This machine can be implemented on a variety of concurrent architectures using simple run-time support.
The transformation, compilation, and run-time system techniques have been implemented and are incorporated in a public-domain program development toolkit. This
toolkit operates on a wide variety of networked workstations, multicomputers, and shared-memory
multiprocessors. It includes a program transformer, concurrent compiler, syntax checker, debugger, performance analyzer, and execution animator. A variety of substantial
applications have been developed using the toolkit, in areas such as climate modeling and fluid dynamics
Density-Based Semantics for Reactive Probabilistic Programming
Synchronous languages are now a standard industry tool for critical embedded
systems. Designers write high-level specifications by composing streams of
values using block diagrams. These languages have been extended with Bayesian
reasoning to program state-space models which compute a stream of distributions
given a stream of observations. However, the semantics of probabilistic models
is only defined for scheduled equations -- a significant limitation compared to
dataflow synchronous languages and block diagrams which do not require any
ordering.
In this paper we propose two schedule agnostic semantics for a probabilistic
synchronous language. The key idea is to interpret probabilistic expressions as
a stream of un-normalized density functions which maps random variable values
to a result and positive score. The co-iterative semantics interprets programs
as state machines and equations are computed using a fixpoint operator. The
relational semantics directly manipulates streams and is thus a better fit to
reason about program equivalence. We use the relational semantics to prove the
correctness of a program transformation required to run an optimized inference
algorithm for state-space models with constant parameters
Hardware Synthesis from a Recursive Functional Language
Abstraction in hardware description languages stalled at the register-transfer level decades ago, yet few alternatives have had much success, in part because they provide only modest gains in expressivity. We propose to make a much larger jump: a compiler that synthesizes hardware from behavioral functional specifications. Our compiler translates general Haskell programs into a restricted intermediate representation before applying a series of semantics-preserving transformations, concluding with a simple syntax-directed translation to SystemVerilog. Here, we present the overall framework for this compiler, focusing on the IRs involved and our method for translating general recursive functions into equivalent hardware. We conclude with experimental results that depict the performance and resource usage of the circuitry generated with our compiler
Syntactical and Semantical Aspects of Faust
International audienceThis paper presents some syntactical and semantical aspects of FAUST (Functional AUdio STreams), a programming language for real-time sound processing and synthesis. The programming model of FAUST combines two approaches : functional programming and block-diagrams composition. It is based on a block-diagram algebra. It has a well defined formal semantic and can be compiled into efficient C/C++ code
On the Efficiency of Optimising Shallow Backtracking in Prolog
The cost of backtracking has been identified as one of the bottlenecks in
achieving peak performance in compiled Prolog programs. Much of the backtracking in
Prolog programs is shallow, i.e. is caused by unification failures in the head of a
clause when there are more alternatives for the same procedure, and so special treatment
of this form of backtracking has been proposed as a significant optimisation. This
paper describes a modified WAM which optimises shallow backtracking. Four different
implementation approaches are compared. A number of benchmark results are presented,
measuring the relative tradeoffs between compilation time, code size, and run time. The
results show that the speedup gained by this optimisation can be significant
XQuery Streaming by Forest Transducers
Streaming of XML transformations is a challenging task and only very few
systems support streaming. Research approaches generally define custom
fragments of XQuery and XPath that are amenable to streaming, and then design
custom algorithms for each fragment. These languages have several shortcomings.
Here we take a more principles approach to the problem of streaming
XQuery-based transformations. We start with an elegant transducer model for
which many static analysis problems are well-understood: the Macro Forest
Transducer (MFT). We show that a large fragment of XQuery can be translated
into MFTs --- indeed, a fragment of XQuery, that can express important features
that are missing from other XQuery stream engines, such as GCX: our fragment of
XQuery supports XPath predicates and let-statements. We then rely on a
streaming execution engine for MFTs, one which uses a well-founded set of
optimizations from functional programming, such as strictness analysis and
deforestation. Our prototype achieves time and memory efficiency comparable to
the fastest known engine for XQuery streaming, GCX. This is surprising because
our engine relies on the OCaml built in garbage collector and does not use any
specialized buffer management, while GCX's efficiency is due to clever and
explicit buffer management.Comment: Full version of the paper in the Proceedings of the 30th IEEE
International Conference on Data Engineering (ICDE 2014
Formally Specifying and Proving Operational Aspects of Forensic Lucid in Isabelle
A Forensic Lucid intensional programming language has been proposed for
intensional cyberforensic analysis. In large part, the language is based on
various predecessor and codecessor Lucid dialects bound by the higher-order
intensional logic (HOIL) that is behind them. This work formally specifies the
operational aspects of the Forensic Lucid language and compiles a theory of its
constructs using Isabelle, a proof assistant system.Comment: 23 pages, 3 listings, 3 figures, 1 table, 1 Appendix with theorems,
pp. 76--98. TPHOLs 2008 Emerging Trends Proceedings, August 18-21, Montreal,
Canada. Editors: Otmane Ait Mohamed and Cesar Munoz and Sofiene Tahar. The
individual paper's PDF is at
http://users.encs.concordia.ca/~tphols08/TPHOLs2008/ET/76-98.pd
- …