Elixir: a system for synthesizing concurrent graph programs

Algorithms in new application areas like machine learning and network analysis use "irregular" data structures such as graphs, trees and sets. Writing efficient parallel code in these problem domains is very challenging because it requires the programmer to make many choices: a given problem can usually be solved by several algorithms, each algorithm may have many implementations, and the best choice of algorithm and implementation can depend not only on the characteristics of the parallel platform but also on properties of the input data such as the structure of the graph. One solution is to permit the application programmer to experiment with different algorithms and implementations without writing every variant from scratch. Auto-tuning to find the best variant is a more ambitious solution. These solutions require a system for automatically producing efficient parallel implementations from high-level specifications. Elixir, the system described in this paper, is the first step towards this ambitious goal. Application programmers write specifications that consist of an operator, which describes the computations to be performed, and a schedule for performing these computations. Elixir uses sophisticated inference techniques to produce efficient parallel code from such specifications. We used Elixir to automatically generate many parallel implementations for three irregular problems: breadth-first search, single source shortest path, and betweenness-centrality computation. Our experiments show that the best generated variants can be competitive with handwritten code for these problems from other research groups; for some inputs, they even outperform the handwritten versions.

[1]  Horst Bunke,et al.  An Efficient Implementation of Graph Grammars Based on the RETE Matching Algorithm , 1990, Graph-Grammars and Their Application to Computer Science.

[2]  Xin-She Yang,et al.  Introduction to Algorithms , 2021, Nature-Inspired Optimization Algorithms.

[3]  Eran Yahav,et al.  Abstraction-guided synthesis of synchronization , 2010, POPL '10.

[4]  Robert Paige,et al.  Program Derivation by Fixed Point Computation , 1989, Sci. Comput. Program..

[5]  Grzegorz Rozenberg,et al.  Handbook of Graph Grammars and Computing by Graph Transformations, Volume 1: Foundations , 1997 .

[6]  U. Brandes A faster algorithm for betweenness centrality , 2001 .

[7]  Keshav Pingali,et al.  Synthesizing concurrent schedulers for irregular algorithms , 2011, ASPLOS XVI.

[8]  David A. Bader,et al.  Approximating Betweenness Centrality , 2007, WAW.

[9]  Sumit Gulwani,et al.  From program verification to program synthesis , 2010, POPL '10.

[10]  Christos Faloutsos,et al.  R-MAT: A Recursive Model for Graph Mining , 2004, SDM.

[11]  Nikolaj Bjørner,et al.  Z3: An Efficient SMT Solver , 2008, TACAS.

[12]  Eran Yahav,et al.  Deriving linearizable fine-grained concurrent objects , 2008, PLDI '08.

[13]  Bor-Yuh Evan Chang,et al.  Boogie: A Modular Reusable Verifier for Object-Oriented Programs , 2005, FMCO.

[14]  Sandra Steinert,et al.  The graph programming language GP , 2007 .

[15]  Kunle Olukotun,et al.  Green-Marl: a DSL for easy and efficient graph analysis , 2012, ASPLOS XVII.

[16]  Daniel Grund,et al.  GrGen: A Fast SPO-Based Graph Rewriting Tool , 2006, ICGT.

[17]  David A. Bader,et al.  Parallel Algorithms for Evaluating Centrality Indices in Real-world Networks , 2006, 2006 International Conference on Parallel Processing (ICPP'06).

[18]  Neil Immerman,et al.  A simple inductive synthesis methodology and its applications , 2010, OOPSLA.

[19]  Bradley C. Kuszmaul,et al.  The pochoir stencil compiler , 2011, SPAA '11.

[20]  Camil Demetrescu,et al.  Reactive Imperative Programming with Dataflow Constraints , 2014, ACM Trans. Program. Lang. Syst..

[21]  Albert Zündorf,et al.  The PROGRES approach: language and environment , 1999 .

[22]  Yanhong A. Liu,et al.  From datalog rules to efficient programs with time and space guarantees , 2009, TOPL.

[23]  Peter Sanders,et al.  [Delta]-stepping: a parallelizable shortest path algorithm , 2003, J. Algorithms.

[24]  Armando Solar-Lezama,et al.  Sketching concurrent data structures , 2008, PLDI '08.

[25]  Robert Paige,et al.  Finite Differencing of Computable Expressions , 1982, TOPL.

[26]  Franz Franchetti,et al.  SPIRAL: Code Generation for DSP Transforms , 2005, Proceedings of the IEEE.

[27]  Rastislav Bodík,et al.  Synthesis of first-order dynamic programming algorithms , 2011, OOPSLA '11.

[28]  Hartmut Ehrig,et al.  Handbook of graph grammars and computing by graph transformation: vol. 3: concurrency, parallelism, and distribution , 1999 .

[29]  Keshav Pingali,et al.  Lonestar: A suite of parallel irregular programs , 2009, 2009 IEEE International Symposium on Performance Analysis of Systems and Software.

[30]  Charles E. Leiserson,et al.  A work-efficient parallel breadth-first search algorithm (or how to cope with the nondeterminism of reducers) , 2010, SPAA '10.

[31]  Arash Jalali,et al.  Incremental Pattern Matching in Graph-Based State Space Exploration , 2010, Electron. Commun. Eur. Assoc. Softw. Sci. Technol..

[32]  Keshav Pingali,et al.  The tao of parallelism in algorithms , 2011, PLDI '11.