Structure-driven optimizations for amorphous data-parallel programs

Méndez-Lojo, Mario; Nguyen, Donald; Prountzos, Dimitrios; Sui, Xin; Hassaan, M. Amber; Kulkarni, Milind; Burtscher, Martin; Pingali, Keshav

doi:10.1145/1693453.1693457

Cited by 50 publications

(44 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Instead of state separation, Kulkarni et al proposed a rollback based speculative parallelization technique [15][16][17][18]21]. They introduce two special constructs that users can employ to identify speculative parallelism.…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Enhanced speculative parallelization via incremental recovery

et al. 2011

View full text Add to dashboard Cite

The widespread availability of multicore systems has led to an increased interest in speculative parallelization of sequential programs using software-based thread level speculation. Many of the proposed techniques are implemented via state separation where non-speculative computation state is maintained separately from the speculative state of threads performing speculative computations. If speculation is successful, the results from speculative state are committed to non-speculative state. However, upon misspeculation, discard-all scheme is employed in which speculatively computed results of a thread are discarded and the computation is performed again. While this scheme is simple to implement, one disadvantage of discard-all is its inability to tolerate high misspeculation rates due to its high runtime overhead. Thus, it is not suitable for use in applications where misspeculation rates are input dependent and therefore may reach high levels.In this paper we develop an approach for incremental recovery in which, instead of discarding all of the results and reexecuting the speculative computation in its entirety, the computation is restarted from the earliest point at which a misspeculation causing value is read. This approach has two advantages. First, the cost of recovery is reduced as only part of the computation is reexecuted. Second, since recovery takes less time, the likelihood of future misspeculations is reduced. We design and implement a strategy for implementing incremental recovery that allows results of partial computations to be efficiently saved and reused. For a set of programs where misspeculation rate is input dependent, our experiments show that with inputs that result in misspeculation rates of around 40% and 80%, applying incremental recovery technique results in 1.2x-3.3x and 2.0x-6.6x speedups respectively over the discard-all recovery scheme. Furthermore, misspeculations observed during discard-all scheme are reduced when incremental recovery is employed -reductions range from 10% to 85%.

show abstract

Section: Related Workmentioning

confidence: 99%

“…We will refer to this strategy as discard-all. Some other works employ rollback to recover from misspeculation [15,18,21]. The rollback cost is minimized by having the programmer exploit application specific knowledge in providing the rollback code.…”

Section: Introductionmentioning

confidence: 99%

Enhanced speculative parallelization via incremental recovery

et al. 2011

View full text Add to dashboard Cite

show abstract

“…Since each activity performs a relatively small computation, the overhead of adding and removing work from the centralized work-list can be substantial. To reduce this performance penalty, we use iteration coalescing [23], which can be viewed as a data-centric version of loop chunking [27]. When an activity adds an edge to the graph, it checks to see if the new edge violates any invariants at the source node.…”

Section: Optimizationsmentioning

confidence: 99%

Parallel inclusion-based points-to analysis

Méndez-Lojo¹,

Mathew

Pingali

2010

Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications

Self Cite

View full text Add to dashboard Cite

Inclusion-based points-to analysis provides a good trade-off between precision of results and speed of analysis, and it has been incorporated into several production compilers including gcc. There is an extensive literature on how to speed up this algorithm using heuristics such as detecting and collapsing cycles of pointer-equivalent variables. This paper describes a complementary approach based on exploiting parallelism. Our implementation exploits two key insights. First, we show that inclusion-based points-to analysis can be formulated entirely in terms of graphs and graph rewrite rules. This exposes the amorphous data-parallelism in this algorithm and makes it easier to develop a parallel implementation. Second, we show that this graph-theoretic formulation reveals certain key properties of the algorithm that can be exploited to obtain an efficient parallel implementation. Our parallel implementation achieves a scaling of up to 3x on a 8-core machine for a suite of ten large C programs. For all but the smallest benchmarks, the parallel analysis outperforms a state-of-the-art, highly optimized, serial implementation of the same algorithm. To the best of our knowledge, this is the first parallel implementation of a points-to analysis.

show abstract

“…This paper describes a parallel PathFinder implementation using the open source Galois framework [12,14]. Galois' programming model, compiler, and runtime synergistically accelerate irregular algorithms that dynamically modify linked-based data structures.…”

Section: Introductionmentioning

confidence: 99%

Parallel FPGA Routing based on the Operator Formulation

Moctar

Brisk

2014

Proceedings of the 51st Annual Design Automation Conference

View full text Add to dashboard Cite

We have implemented an FPGA routing algorithm on a shared memory multi-processor using the Galois API, which offers speculative parallelism in software. The router is a parallel implementation of PathFinder, which is the basis for most commercial FPGA routers. We parallelize the maze expansion step for each net, while routing nets sequentially to limit the amount of rollback that would likely occur due to misspeculation. Our implementation relies on non-blocking priority queues, which use software transactional memory (SMT), to identify the best route for each net. Our experimental results demonstrate scalability for large benchmarks and that the amount of available parallelism depends primarily on the circuit size, not the interdependence of signals. We achieve an average speedup of approximately 3x compared to the most recently published work on parallel multi-threaded FPGA routing, and up to 6x in comparison to the single-threaded router implemented in the publicly available Versatile Place and Route (VPR) framework.

show abstract

Structure-driven optimizations for amorphous data-parallel programs

Cited by 50 publications

References 24 publications

Enhanced speculative parallelization via incremental recovery

Enhanced speculative parallelization via incremental recovery

Parallel inclusion-based points-to analysis

Parallel FPGA Routing based on the Operator Formulation

Contact Info

Product

Resources

About