🤖 AI Summary
This paper addresses two major bottlenecks—excessive work and scattered output memory—in parallel evaluation of relational queries on the CRCW PRAM model. We propose the first constant-time, weakly work-efficient (O(T^{1+ε})) parallel evaluation framework. Methodologically, we integrate the Goldberg–Zwick approximate prefix-sum algorithm with compactification techniques, leveraging practical assumptions such as sorting or numerical constraints to achieve operator-level parallelization for acyclic queries, semijoin algebra, and worst-case-optimal joins. Our contributions are threefold: (i) the first constant-time, weakly work-efficient parallel evaluation for these three fundamental query classes; (ii) work complexity asymptotically approaching that of the optimal sequential algorithms; and (iii) substantial improvements over naive parallel approaches, coupled with highly compact output memory layout.
📝 Abstract
The article studies query evaluation in parallel constant time in the CRCW PRAM model. While it is well-known that all relational algebra queries can be evaluated in constant time on an appropriate CRCW PRAM model, this article is interested in the efficiency of evaluation algorithms, that is, in the number of processors or, asymptotically equivalent, in the work. Naive evaluation in the parallel setting results in huge (polynomial) bounds on the work of such algorithms and in presentations of the result sets that can be extremely scattered in memory. The article discusses some obstacles for constant-time PRAM query evaluation. It presents algorithms for relational operators and explores three settings, in which efficient sequential query evaluation algorithms exist: acyclic queries, semijoin algebra queries, and join queries -- the latter in the worst-case optimal framework. Under mild assumptions -- that data values are numbers of polynomial size in the size of the database or that the relations of the database are suitably sorted -- constant-time algorithms are presented that are weakly work-efficient in the sense that work $mathcal{O}(T^{1+varepsilon})$ can be achieved, for every $varepsilon>0$, compared to the time $T$ of an optimal sequential algorithm. Important tools are the algorithms for approximate prefix sums and compaction from Goldberg and Zwick (1995).