Accelerating the similarity self-join using the GPU

Gowanlock, Michael; Karsin, Benjamin

doi:10.1016/j.jpdc.2019.06.005

Cited by 16 publications

(14 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Also, the majority of the indexes are designed for a specific use, whether they are for low-or high-dimensional data, for the CPU, for the GPU, or both architectures. We identify different indexing methods, including those designed for the CPU [2,3,[24][25][26][27][28][29], the GPU [10,12,30], or both architectures [15][16][17]. As our algorithm focuses on the low-dimensionality distance similarity search, we focus on presenting indexing methods that are designed for lower dimensions.…”

Section: Data Indexingmentioning

confidence: 99%

“…Furthermore, they assign multiple queries to a warp, with all the threads of the same warp that cooperate to compute one query at a time, thus reducing intra-warp thread divergence. We leverage the GPU grid index proposed by [30] and that is designed for distance similarity joins, which we present in Sect. 3.1.1.…”

Section: Data Indexingmentioning

confidence: 99%

“…In contrast, [16] elects to use two indexes for data parallelism to compute k NN searches. The CPU uses a kD-Tree [24], while the GPU uses a grid [30]. Hence, both indexes are suited to their respective architecture.…”

Section: Data Indexingmentioning

confidence: 99%

“…The GPU component of HEGJoin is based on the GPU kernel proposed by [6]. This kernel also uses the grid index and the batching scheme by [30]. This work is the best distance similarity join algorithm for low dimensions that uses the GPU.…”

Section: Gpu Algorithm: Lbjoinmentioning

confidence: 99%

“…The grid index presented by [30] allows the query points to only search for candidate points within its 3 d adjacent cells (and the query points' own cell), where d is the data dimensionality. This grid is stored in several arrays in the GPU's global memory: (i) the first array represents only the nonempty cells to minimize memory usage, (ii) the second array stores the cells' linear id and a minimum and maximum indices of the points, and (iii) the third array corresponds to the position of the points in the dataset and is pointed to by the second array.…”

Section: Grid Indexingmentioning

confidence: 99%

See 4 more Smart Citations

Heterogeneous CPU-GPU Epsilon Grid Joins: Static and Dynamic Work Partitioning Strategies

Gallet

Gowanlock

2020

Data Sci. Eng.

Self Cite

View full text Add to dashboard Cite

Given two datasets (or tables) A and B and a search distance $$\epsilon$$ ϵ , the distance similarity join, denoted as $$A \ltimes _\epsilon B$$ A ⋉ ϵ B , finds the pairs of points ($$p_a$$ p a , $$p_b$$ p b ), where $$p_a \in A$$ p a ∈ A and $$p_b \in B$$ p b ∈ B , and such that the distance between $$p_a$$ p a and $$p_b$$ p b is $$\le \epsilon$$ ≤ ϵ . If $$A = B$$ A = B , then the similarity join is equivalent to a similarity self-join, denoted as $$A \bowtie _\epsilon A$$ A ⋈ ϵ A . We propose in this paper Heterogeneous Epsilon Grid Joins (HEGJoin), a heterogeneous CPU-GPU distance similarity join algorithm. Efficiently partitioning the work between the CPU and the GPU is a challenge. Indeed, the work partitioning strategy needs to consider the different characteristics and computational throughput of the processors (CPU and GPU), as well as the data-dependent nature of the similarity join that accounts in the overall execution time (e.g., the number of queries, their distribution, the dimensionality, etc.). In addition to HEGJoin, we design in this paper a dynamic and two static work partitioning strategies. We also propose a performance model for each static partitioning strategy to perform the distribution of the work between the processors. We evaluate the performance of all three partitioning methods by considering the execution time and the load imbalance between the CPU and GPU as performance metrics. HEGJoin achieves a speedup of up to $$5.46\times$$ 5.46 × ($$3.97\times$$ 3.97 × ) over the GPU-only (CPU-only) algorithms on our first test platform and up to $$1.97\times$$ 1.97 × ($$12.07\times$$ 12.07 × ) on our second test platform over the GPU-only (CPU-only) algorithms.

show abstract