Compiling CHR to parallel hardware

Triossi, A.; Orlando, Salvatore; Raffaetà, Alessandra; Frühwirth, Thom

doi:10.1145/2370776.2370798

Cited by 10 publications

(18 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…This gives a maximum, linear parallel speed-up without the need to modify the program. This was confirmed experimentally for both a software and a hardware implementation (Lam, 2018;Triossi et al, 2012).…”

Section: Algorithms Of Erastothenes Euclid Von Neumann Floyd and Wmentioning

confidence: 60%

See 1 more Smart Citation

Parallelism, concurrency and distribution in constraint handling rules: A survey

Frühwirth¹

2018

Theory and Practice of Logic Programming

Self Cite

View full text Add to dashboard Cite

Constraint Handling Rules (CHR) is both an effective concurrent declarative programming language and a versatile computational logic formalism. In CHR, guarded reactive rules rewrite a multi-set of constraints. Concurrency is inherent, since rules can be applied to the constraints in parallel. In this comprehensive survey, we give an overview of the concurrent, parallel as well as distributed CHR semantics, standard and more exotic, that have been proposed over the years at various levels of refinement. These semantics range from the abstract to the concrete. They are related by formal soundness results. Their correctness is proven as a correspondence between parallel and sequential computations. On the more practical side, we present common concise example CHR programs that have been widely used in experiments and benchmarks. We review parallel and distributed CHR implementations in software as well as hardware. The experimental results obtained show a parallel speed-up for unmodified sequential CHR programs. The software implementations are available online for free download and we give the web links. Due to its high level of abstraction, the CHR formalism can also be used to implement and analyse models for concurrency. To this end, the Software Transaction Model, the Actor Model, Colored Petri Nets and the Join-Calculus have been faithfully encoded in CHR. Finally, we identify and discuss commonalities of the approaches surveyed and indicate what problems are left open for future research.

show abstract

Section: Algorithms Of Erastothenes Euclid Von Neumann Floyd and Wmentioning

confidence: 60%

“…Note that to any pair of gcd constraints, the rule will always be applicable. A parallel speed-up was observed in a hardware implementation (Triossi et al, 2012), and even a super-linear speed-up in a software implementation (Lam, 2018).…”

Section: Algorithms Of Erastothenes Euclid Von Neumann Floyd and Wmentioning

confidence: 99%

Parallelism, concurrency and distribution in constraint handling rules: A survey

Frühwirth¹

2018

Theory and Practice of Logic Programming

Self Cite

View full text Add to dashboard Cite

show abstract

“…Thus, using completion, we can turn non-confluent programs into parallel programs. This method has been applied to the classical Union-Find algorithm which is very hard to parallelize [51] (with [129] showing the effectiveness of the resulting program) and to the Preflow-Push algorithm [93]. Alternative and more refined semantics for parallel CHR are e.g.…”

Section: Operational Semantics For Parallel Chrmentioning

confidence: 99%

“…As for concurrency, prototype parallel CHR implementations exist in software using Haskell [86] and in hardware using Nvidia CUDA by transforming a subset of CHR to C++ [138] and using FPGA's [129]. These papers feature experiments that show a potential for optimal linear speedup by parallelization of CHR programs (and super-linear speed-up e.g.…”

Section: Chr Implementations and Their Efficiencymentioning

confidence: 99%

Constraint Handling Rules - What Else?

Frühwirth

2015

Rule Technologies: Foundations, Tools, and Applications

Self Cite

View full text Add to dashboard Cite

Abstract. Constraint Handling Rules (CHR) is both an effective concurrent declarative constraint-based programming language and a versatile computational formalism. While conceptually simple, CHR is distinguished by a remarkable combination of desirable features:-a semantic foundation in classical and linear logic, -an effective and efficient sequential and parallel execution model -guaranteed properties like the anytime online algorithm properties -powerful analysis methods for deciding essential program properties. This overview of some CHR-related research and applications is by no means meant to be complete. Essential introductory reading for CHR provide the survey article [125] and the books [56,63]. Up-to-date information on CHR can be found online at the CHR web-page www. constraint-handling-rules.org, including the slides of the keynote talk associated with this article. In addition, the CHR website dtai. cs.kuleuven.be/CHR/ offers everything you want to know about CHR, including online demo versions and free downloads of the language. Executive SummaryConstraint Handling Rules (CHR) [56] tries to bridge the gap between theory and practice, between logical specification and executable program by abstraction through constraints and the concepts of computational logic. CHR has its roots in constraint logic programming and concurrent constraint programming, but also integrates ideas from multiset transformation and rewriting systems as well as automated reasoning and theorem proving. It seamlessly blends multi-headed rewriting and concurrent constraint logic programming into a compact userfriendly rule-based programming language. CHR consists of guarded reactive rules that transform multisets of relations called constraints until no more change occurs. By the notion of constraint, CHR does not need to distinguish between data and operations, and its rules are both descriptive and executable.In CHR, one distinguishes two main kinds of rules: Simplification rules replace constraints by simpler constraints while preserving logical equivalence, e.g., X≤Y∧Y≤X ⇔ X=Y. Propagation rules add new constraints that are logically redundant but may cause further simplification, e.g., X≤Y∧Y≤Z ⇒ X≤Z. Together with X≤X ⇔ true, these rules encode the axioms of a partial order relation. The rules compute its transitive closure and replace inequalities ≤ by equalities = whenever possible. For example, A≤B∧B≤C∧C≤A becomes A=B∧B=C. More program examples can be found in Section 2. Semantics of CHR are discussed in Section 3.

show abstract

“…This approach originated in associative processors [6] and active data structures [1]; other examples include priority queues [2], systems with chunks of memory organised as trees [15], smart memories for multicore processors [5], associative searching [9]. Circuit parallelism is the target platform for compilation of a declarative committed-choice rule language [16]. The idea is to bring the parallelism inherent in digital circuits to bear directly on the computations required by an algorithm, rather than organising the circuit into conventional processors.…”

Section: Introductionmentioning

confidence: 99%

Extensible sparse functional arrays with circuit parallelism

O'Donnell

2013

Proceedings of the 15th Symposium on Principles and Practice of Declarative Programming

View full text Add to dashboard Cite

A longstanding open question in algorithms and data structures is the time and space complexity of pure functional arrays. Imperative arrays provide update and lookup operations that require constant time in the RAM theoretical model, but it is conjectured that there does not exist a RAM algorithm that achieves the same complexity for functional arrays, unless restrictions are placed on the operations. The main result of this paper is an algorithm that does achieve optimal unit time and space complexity for update and lookup on functional arrays. This algorithm does not run on a RAM, but instead it exploits the massive parallelism inherent in digital circuits. The algorithm also provides unit time operations that support storage management, as well as sparse and extensible arrays. The main idea behind the algorithm is to replace a RAM memory by a tree circuit that is more powerful than the RAM yet has the same asymptotic complexity in time (gate delays) and size (number of components). The algorithm uses an array representation that allows elements to be shared between many arrays with only a small constant factor penalty in space and time. This system exemplifies circuit parallelism, which exploits very large numbers of transistors per chip in order to speed up key algorithms. Extensible Sparse Functional Arrays (ESFA) can be used with both functional and imperative programming languages. The system comprises a set of algorithms and a circuit specification, and it has been implemented on a GPGPU with good performance.

show abstract

Compiling CHR to parallel hardware

Cited by 10 publications

References 21 publications

Parallelism, concurrency and distribution in constraint handling rules: A survey

Parallelism, concurrency and distribution in constraint handling rules: A survey

Constraint Handling Rules - What Else?

Extensible sparse functional arrays with circuit parallelism

Contact Info

Product

Resources

About