Scheduling strategies for optimistic parallel execution of irregular programs

Kulkarni, Milind; Carribault, Patrick; Pingali, Keshav; Ramanarayanan, Ganesh; Walter, Bruce; Bala, Kavita; Chew, L. Paul

doi:10.1145/1378533.1378575

Cited by 46 publications

(46 citation statements)

References 28 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The efficient kd-tree based algorithms are challenging since each iteration potentially has data dependencies with the prior ones. In previous work [12,10,11], we showed that there is exploitable parallelism in the heap-based and locallyordered algorithms using the Galois optimistic approach.…”

Section: Parallelizing Agglomerative Clustering For Multicorementioning

confidence: 96%

Fast agglomerative clustering for rendering

Walter

Bala

Kulkarni

et al. 2008

2008 IEEE Symposium on Interactive Ray Tracing

Self Cite

View full text Add to dashboard Cite

Hierarchical representations of large data sets, such as binary cluster trees, are a crucial component in many scalable algorithms used in various fields. Two major approaches for building these trees are agglomerative, or bottom-up, clustering and divisive, or top-down, clustering. The agglomerative approach offers some real advantages such as more flexible clustering and often produces higher quality trees, but has been little used in graphics because it is frequently assumed to be prohibitively expensive (O(N 2 ) or worse).In this paper we show that agglomerative clustering can be done efficiently even for very large data sets. We introduce a novel locally-ordered algorithm that is faster than traditional heap-based agglomerative clustering and show that the complexity of the tree build time is much closer to linear than quadratic. We also evaluate the quality of the agglomerative clustering trees compared to the best known divisive clustering strategies in two sample applications: bounding volume hierarchies for ray tracing and light trees in the Lightcuts rendering algorithm. Tree quality is highly application, data set, and dissimilarity function specific. In our experiments the agglomerative-built tree quality is consistently higher by margins ranging from slight to significant, with up to 35% reduction in tree query times.

show abstract

Section: Parallelizing Agglomerative Clustering For Multicorementioning

confidence: 96%

Fast agglomerative clustering for rendering

Walter

Bala

Kulkarni

et al. 2008

2008 IEEE Symposium on Interactive Ray Tracing

Self Cite

View full text Add to dashboard Cite

show abstract

“…The FailedAt attribute of t indicates which live-in variables caused the speculation to fail. Since, when each live-in variable is first read, the instruction address of the read and the space ID before the read are recorded ( Figure 10, line 2), the main thread can retrieve these two values of the first accessed live-in variable by calling another two auxiliary functions GetRecoveryPC and getRecoverySpaceID (lines [16][17]. These two values determine the starting point of the reexecution.…”

Section: Handling Speculative Resultsmentioning

confidence: 99%

“…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%

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

“…Next, all speculative execution is rolled back (line 13). Finally, ParaMeter "commits" the highest priority elements in the system by re-executing them (lines [16][17][18][19][20][21][22][23]. Any newly created work will be executed in the next round (line 19).…”

Section: Ordered Loopsmentioning

confidence: 99%

How much parallelism is there in irregular applications?

Kulkarni

Burtscher

Inkulu

et al. 2009

Proceedings of the 14th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

Self Cite

View full text Add to dashboard Cite

Irregular programs are programs organized around pointer-based data structures such as trees and graphs. Recent investigations by the Galois project have shown that many irregular programs have a generalized form of data-parallelism called amorphous data-parallelism. However, in many programs, amorphous dataparallelism cannot be uncovered using static techniques, and its exploitation requires runtime strategies such as optimistic parallel execution. This raises a natural question: how much amorphous data-parallelism actually exists in irregular programs?In this paper, we describe the design and implementation of a tool called ParaMeter that produces parallelism profiles for irregular programs. Parallelism profiles are an abstract measure of the amount of amorphous data-parallelism at different points in the execution of an algorithm, independent of implementation-dependent details such as the number of cores, cache sizes, load-balancing, etc. ParaMeter can also generate constrained parallelism profiles for a fixed number of cores. We show parallelism profiles for seven irregular applications, and explain how these profiles provide insight into the behavior of these applications.

show abstract

Scheduling strategies for optimistic parallel execution of irregular programs

Cited by 46 publications

References 28 publications

Fast agglomerative clustering for rendering

Fast agglomerative clustering for rendering

Enhanced speculative parallelization via incremental recovery

How much parallelism is there in irregular applications?

Contact Info

Product

Resources

About