[Paper Review] gSMat: A Scalable Sparse Matrix-based Join for SPARQL Query Processing

Xiaowang Zhang, Mingyue Zhang+4 more|arXiv (Cornell University)|Jul 20, 2018

Graph Theory and Algorithms33 references4 citations

TL;DR

This paper proposes gSMat, a scalable sparse matrix-based approach for SPARQL query processing over large-scale RDF datasets. By modeling RDF data as sparse matrices per predicate and leveraging matrix multiplication for join operations, gSMat achieves high efficiency and scalability, with up to 114x speedup over gStore and 53x over RDF-3X on real-world datasets, especially benefiting from GPU acceleration via CUDA.

ABSTRACT

Resource Description Framework (RDF) has been widely used to represent information on the web, while SPARQL is a standard query language to manipulate RDF data. Given a SPARQL query, there often exist many joins which are the bottlenecks of efficiency of query processing. Besides, the real RDF datasets often reveal strong data sparsity, which indicates that a resource often only relates to a few resources even the number of total resources is large. In this paper, we propose a sparse matrix-based (SM-based) SPARQL query processing approach over RDF datasets which con- siders both join optimization and data sparsity. Firstly, we present a SM-based storage for RDF datasets to lift the storage efficiency, where valid edges are stored only, and then introduce a predicate- based hash index on the storage. Secondly, we develop a scalable SM-based join algorithm for SPARQL query processing. Finally, we analyze the overall cost by accumulating all intermediate results and design a query plan generated algorithm. Besides, we extend our SM-based join algorithm on GPU for parallelizing SPARQL query processing. We have evaluated our approach compared with the state-of-the-art RDF engines over benchmark RDF datasets and the experimental results show that our proposal can significantly improve SPARQL query processing with high scalability.

Motivation & Objective

• Address the performance bottleneck in SPARQL query processing caused by inefficient joins over large-scale, sparse RDF data.
• Leverage the inherent sparsity of real-world RDF datasets (e.g., DBpedia, YAGO) to design a more compact and efficient storage model.
• Develop a matrix-based join algorithm that exploits data sparsity and enables high parallelism for efficient query execution.
• Optimize query execution plans using cost estimation based on intermediate result sizes to improve performance.
• Extend the approach to GPU acceleration for further scalability and performance gains in large-scale workloads.

Proposed method

• Represent each RDF predicate as a sparse matrix, storing only non-zero (valid) edges to exploit data sparsity and reduce storage overhead.
• Apply predicate-based hash indexing on the sparse matrix storage to accelerate access and join operations.
• Model SPARQL basic graph patterns (BGPs) as a sequence of sparse matrix multiplications, where each triple pattern corresponds to a matrix.
• Use matrix multiplication to compute natural joins between relations, enabling fine-grained parallelism across matrix elements.
• Design a cost-based query plan generator that estimates intermediate result sizes and selects the optimal join order to minimize overall execution cost.
• Implement a GPU-optimized version using CUDA to parallelize matrix multiplication and accelerate query processing on modern hardware.

Experimental results

Research questions

• RQ1 How can sparse matrix representation be effectively used to model and store large-scale, sparse RDF datasets with high storage and query efficiency?
• RQ2 Can matrix multiplication operations over sparse matrices serve as a scalable and efficient alternative to traditional join algorithms in SPARQL query processing?
• RQ3 How does the integration of cost-based query optimization based on intermediate result estimation improve the performance of SPARQL query execution?
• RQ4 To what extent can GPU acceleration enhance the performance of sparse matrix-based SPARQL joins on large RDF workloads?
• RQ5 How does the proposed gSMat approach compare in performance and scalability against state-of-the-art RDF systems like gStore and RDF-3X on real-world datasets?

Key findings

• gSMat achieves up to 114x speedup over gStore and 11.3x over RDF-3X on benchmark datasets with 500 million triples.
• On real-world datasets, gSMat achieves up to 46.4x speedup over gStore and 33.6x over RDF-3X for complex SPARQL queries.
• The GPU-accelerated variant, gSMat+, achieves up to 128.8x speedup over gStore and 16.13x over RDF-3X on benchmark data.
• On real datasets, gSMat+ achieves up to 78.9x speedup over gStore and 53.0x over RDF-3X, demonstrating strong scalability on production workloads.
• The cost-based query plan generator significantly reduces intermediate result sizes, leading to more efficient execution plans compared to naive join ordering.
• The sparse matrix-based storage reduces memory footprint and enables efficient, hyper-parallelizable computation, making it highly suitable for large-scale RDF data.