Efficient stream compaction on wide SIMD many-core architectures

Billeter, Markus; Olsson, Ola; Assarsson, Ulf

doi:10.1145/1572769.1572795

Cited by 88 publications

(69 citation statements)

References 17 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…It computes the offset for a selected element by using: section offset+ block offset + warp offset + intra warp offset. The intra warp offset can be determined by using the intra-warp voting functions ballot() and popc() [2][5], while the warp offset can be computed by using the binary-bit scan operations [5]. It uses the function syncthreads count() to get the total number of wanted elements within the block and then writes the number to an intermediate block-count array.…”

Section: Prefix-sum Based Approachesmentioning

confidence: 99%

Efficient Algorithms for Stream Compaction on GPUs

Bakunas-Milanowski¹,

Rego

Sang

et al. 2017

IJNC

View full text Add to dashboard Cite

Stream compaction, also known as stream filtering or selection, produces a smaller output array which contains the indices of the only wanted elements from the input array for further processing. With the tremendous amount of data elements to be filtered, the performance of selection is of great concern. Recently, modern Graphics Processing Units (GPUs) have been increasingly used to accelerate the execution of massively large, data parallel applications. In this paper, we designed and implemented two new algorithms for stream compaction on GPU. The first algorithm, which can preserve the relative order of the input elements, uses a multi-level prefix-sum approach. The second algorithm, which is non-order-preserving, is based the hybrid use of the prefix-sum and the atomics approaches. We compared their performance with other parallel selection algorithms on the current generation of NVIDIA GPUs. The experimental results show that both algorithms run faster than Thrust, an open-source parallel algorithms library. Furthermore, the hybrid method performs the best among all existing selection algorithms on GPU and can be two orders of magnitude faster than the sequential selection on CPU, especially when the data size is large.

show abstract

Section: Prefix-sum Based Approachesmentioning

confidence: 99%

Efficient Algorithms for Stream Compaction on GPUs

Bakunas-Milanowski¹,

Rego

Sang

et al. 2017

IJNC

View full text Add to dashboard Cite

show abstract

“…A parallel prefix sum over this array will generate the list of indirections from which the parent nodes can be updated in parallel. Finally a stream compaction pass generates the new list of unique nodes [Billeter et al 2009]. …”

Section: Reducing a Sparse Voxel Tree To A Dagmentioning

confidence: 99%

High resolution sparse voxel DAGs

2013

Self Cite

View full text Add to dashboard Cite

Figure 1: The EPICCITADEL scene voxelized to a 128K 3 (131 072 3 ) resolution and stored as a Sparse Voxel DAG. Total voxel count is 19 billion, which requires 945MB of GPU memory. A sparse voxel octree would require 5.1GB without counting pointers. Primary shading is from triangle rasterization, while ambient occlusion and shadows are raytraced in the sparse voxel DAG at 170 MRays/sec and 240 MRays/sec respectively, on an NVIDIA GTX680. AbstractWe show that a binary voxel grid can be represented orders of magnitude more efficiently than using a sparse voxel octree (SVO) by generalising the tree to a directed acyclic graph (DAG). While the SVO allows for efficient encoding of empty regions of space, the DAG additionally allows for efficient encoding of identical regions of space, as nodes are allowed to share pointers to identical subtrees. We present an efficient bottom-up algorithm that reduces an SVO to a minimal DAG, which can be applied even in cases where the complete SVO would not fit in memory. In all tested scenes, even the highly irregular ones, the number of nodes is reduced by one to three orders of magnitude. While the DAG requires more pointers per node, the memory cost for these is quickly amortized and the memory consumption of the DAG is considerably smaller, even when compared to an ideal SVO without pointers. Meanwhile, our sparse voxel DAG requires no decompression and can be traversed very efficiently. We demonstrate this by ray tracing hard and soft shadows, ambient occlusion, and primary rays in extremely high resolution DAGs at speeds that are on par with, or even faster than, state-of-the-art voxel and triangle GPU ray tracing.

show abstract

“…Most notably, algorithms to efficiently implement workload balancing using a compactation step were introduced in the context of KDtrees [15], Reyes-style subdivision [8] and bounding volume hierarchies construction [4]. Generalized stream compaction was presented by Billeter et al [1]. In the context of tessellating parametric surfaces, scan operations were used in order to scatter dynamically generated vertices to a VBO [12].…”

Section: Previous Workmentioning

confidence: 99%

“…Maybe applying the sharedmemory aware compaction model presented by Billeter et al [1] could further improve performance.…”

Section: Derivationmentioning

confidence: 99%

“…An analysis of the intrinsic parallelism of L-systems is provided in Section 3. Then our system consisting of two major building blocks will be described: (1) The derivation step will start with the axiom and generate a long string of modules (Section 4). (2) The interpretation step takes the string as input and generates the actual geometry (Section 5).…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Parallel generation of multiple L-systems

Lipp

Wonka

Wimmer

2010

Computers & Graphics

View full text Add to dashboard Cite

This paper introduces a solution to compute L-systems on parallel architectures like GPUs and multi-core CPUs. Our solution can split the derivation of the L-system as well as the interpretation and geometry generation into thousands of threads running in parallel. We introduce a highly parallel algorithm for L-system evaluation that works on arbitrary L-systems, including parametric productions, context sensitive productions, stochastic production selection, and productions with side effects. This algorithm is further extended to allow evaluation of multiple independent L-systems in parallel. In contrast to previous work, we directly interpret the productions defined in plain-text, without requiring any compilation or transformation step (e.g., into shaders). Our algorithm is efficient in the sense that it requires no explicit inter-thread communication or atomic operations, and is thus completely lock free.

show abstract

Efficient stream compaction on wide SIMD many-core architectures

Cited by 88 publications

References 17 publications

Efficient Algorithms for Stream Compaction on GPUs

Efficient Algorithms for Stream Compaction on GPUs

High resolution sparse voxel DAGs

Parallel generation of multiple L-systems

Contact Info

Product

Resources

About