Cache-Oblivious Planar Orthogonal Range Searching and Counting
Lars Arge∗ Gerth Stølting Brodal‡ Rolf Fagerberg§ BRICS† BRICS† Dept. of Mathematics and Dept. of Computer Science Dept. of Computer Science Computer Science University of Aarhus University of Aarhus University of Southern IT Parken, Aabogade 34 IT Parken, Aabogade 34 Denmark 8200 Aarhus N, Denmark 8200 Aarhus N, Denmark 5230 Odense M, Denmark [email protected] [email protected] [email protected]
Morten Laustsen BRICS† Dept. of Computer Science University of Aarhus IT Parken, Aabogade 34 8200 Aarhus N, Denmark [email protected]
ABSTRACT space for four-sided queries. We present the first cache-oblivious data structure for planar Based on the O(N log N) space range counting structure, orthogonal range counting, and improve on previous results we develop a data structure that uses O(N log2 N) space for cache-oblivious planar orthogonal range searching. and answers three-sided range queries in O(logB N + T/B) Our range counting structure uses O(N log N) space and memory transfers, where T is the number of reported points. 2 Based on this structure, we present a general four-sided answers queries using O(logB N) memory transfers, where 2 B is the block size of any memory level in a multilevel mem- range searching structure that uses O(N log2 N/ log2 log2 N) ory hierarchy. Using bit manipulation techniques, the space space and answers queries in O(logB N + T/B) memory can be further reduced to O(N). The structure can also transfers. be modified to support more general semigroup range sum queries in O(logB N) memory transfers, using O(N log2 N) Categories and Subject Descriptors space for three-sided queries and O(N log2 N/ log log N) 2 2 2 F.2.2 [Analysis of Algorithms and Problem Complex- ∗Supported in part by the US National Science Founda- ity]: Nonnumerical Algorithms and Problems—geometrical tion through RI grant EIA–9972879, CAREER grant CCR– problems and computations 9984099, ITR grant EIA–0112849, and U.S.-Germany Co- operative Research Program grant INT–0129182, by the US Army Research Office through grant W911NF-04-1-0278, General Terms and by an Ole Rømer Scholarship from the Danish National Algorithms, Design Science Research Council. Part of this work was done while the author was at Duke University. †Basic Research in Computer Science, www.brics.dk, funded Keywords by the Danish National Research Foundation. ‡Partially supported by the Carlsberg Foundation through Cache-Oblivious, orthogonal range searching, range count- grant ANS-0257/20 and the Danish Natural Science Re- ing, semi-group range queries search Council through grant 21-04-0389. §Supported in part by the Danish Natural Science Research Council (SNF). 1. INTRODUCTION The memory systems of modern computers are becoming increasingly complex; they consist of a hierarchy of several levels of cache, main memory, and disk. The access times Permission to make digital or hard copies of all or part of this work for of different levels of memory often vary by orders of mag- personal or classroom use is granted without fee provided that copies are nitude, and to amortize the large access times of memory not made or distributed for profit or commercial advantage and that copies levels far away from the processor, data is normally trans- bear this notice and the full citation on the first page. To copy otherwise, to fered between levels in large blocks. Thus, it is important republish, to post on servers or to redistribute to lists, requires prior specific to design algorithms that are sensitive to the architecture permission and/or a fee. SCG'05, June 6–8, 2005, Pisa, Italy. of the memory system and have a high degree of locality in Copyright 2005 ACM 1-58113-991-8/05/0006 ...$5.00. their memory-access patterns. For the traditional RAM model of computation one as- tree structure obtains these bounds [6]. If only linear space sumes a flat memory-system with uniform access time; is used then Θ(pN/B + T/B) transfers, as obtained by therefore algorithms for the RAM model often exhibit low the kd-B tree [24, 27], is needed to answer a query. For memory-access locality and are thus inefficient in a hierar- the problem of range counting, the CRB-tree [22], which chical memory system. Although a lot of work has recently is an external version of the compressed range tree [18], an- been done on algorithms for a two-level memory model, in- swers queries in O(logB N) memory transfers and uses O(N) troduced to model the large difference in the access times space if bit manipulations of pointers and counters are al- of main memory and disks, relatively little work has been lowed. Refer to recent surveys for further I/O-model and done in models of multilevel memory. One reason for this is hierarchical memory model results [4, 28]. the many parameters in such models. The cache-oblivious Frigo et al. [21] developed cache-oblivious algorithms for model was introduced as a way of achieving algorithms that sorting, Fast Fourier Transform, and matrix multiplication. are efficient in arbitrary memory hierarchies without the use Subsequently, a number of other results have been obtained of complicated multilevel memory models. in the cache-oblivious model [1, 5, 8, 9, 10, 11, 12, 13, 14, In this paper we develop new and improved cache- 15, 16, 26], among them several cache-oblivious B-tree struc- oblivious data structures for planar orthogonal range count- tures with O(logB N) search and update bounds [10, 11, 12, ing and searching. Planar orthogonal range searching is the 16, 26]. Several of these structures can also support one- problem of finding, among a set of N points in the plane, all dimensional range searching in O(logB N + T/B) memory T points lying in a given query axis-parallel rectangle. The transfers [11, 12, 16] (but at an increased amortized up- corresponding counting problem returns the number of such 1 2 2 date cost of O(logB N + B log2 N) = O(logB N) memory points. transfers). In [13], an algorithm for batched planar orthog- onal range searching were developed, which answers a set of 1.1 Model of computation N N O(N) queries using O( B logM/B B + T/B) memory trans- In the two-level I/O-model (or external-memory model), fers, where T is the combined size of the answers. introduced by Aggarwal and Vitter [3], the memory hier- Agarwal et al. [1] were the first to develop cache-oblivious archy consists of an internal memory (or cache) of size M structures for non-batched planar orthogonal range search- and an arbitrarily large external memory partitioned into ing. They developed a cache-oblivious version of a kd-tree blocks of size B. An I/O, or memory transfer, transfers one that answers planar range queries in O(pN/B+T/B) mem- block between the internal and the external memory. Com- ory transfers using linear space. It supports updates in log2 N 2 putation can only occur on data present in internal memory. O( B logM/B N) = O(logB N) transfers. The structure The complexity of an algorithm in this model (an external can be extended to d dimensions. They also developed a memory algorithm) is measured in terms of the number of cache-oblivious version of a two-dimensional range tree that memory transfers it performs, as well as the amount of ex- answers planar range queries in O(logB N + T/B) memory 2 ternal memory it uses. transfers but using O(N log2 N) space. The central part of In the cache-oblivious model, introduced by Frigo et this structure is an O(N log2 N) space structure for answer- al. [21], algorithms are described in the RAM model, but ing planar three-sided range queries in O(logB N + T/B) are analyzed in the two-level I/O-model. It is assumed that memory transfers, that is, for finding all T points in a query when an algorithm accesses an element that is not stored range [xl,xr] × [yb, ∞). The analysis of the range tree struc- in cache, the relevant block is automatically transfered into ture (or rather, the structure for three-sided queries) re- c the cache. If the cache is full, an optimal paging strategy re- quires that B = 22 for some nonnegative integer constant c. places the ideal block in cache based on the future accesses of the algorithm. Often, it is also assumed that M > B2 (the tall cache assumption). So informally, cache-oblivious algorithms run in the two-level I/O-model, but cannot make 1.3 Our results use of M and B. Because an analysis of a cache-oblivious In this paper, we develop the first cache-oblivious struc- algorithm in the two-level model must hold for any block tures for planar orthogonal range counting. Our structures and main memory size, it holds for any level of an arbitrary answer queries in O(logB N) memory transfers. We first memory hierarchy [21]. As a consequence, an algorithm that describe a version using O(N log2 N) space, and then re- is optimal in the two-level model is optimal on all levels of duce the space to O(N) assuming that bit manipulations of an arbitrary multilevel hierarchy. pointers and counters are allowed. This matches the perfor- mance of the CRB-tree [22] in the I/O-model. The struc- 1.2 Previous results ture can be generalized to support semigroup range sum Range searching has been studied extensively in the RAM queries in O(logB N) memory transfers using O(N log2 N) 2 model. In the planar case, for example, some of the best and O(N log2 N/ log2 log2 N) space for three-sided and four- known structures (for any fixed ε > 0) answer orthogonal sided queries, respectively (assuming that elements in the ε range queries in O(log2 N +T log (2N/T )) time using linear semigroup can be represented in O(1) space). ε space and in O(log2 N + T ) time using O(N log N) space, For planar orthogonal range searching, we develop an im- respectively [17, 18]. Refer to a recent survey for further proved cache-oblivious three-sided structure without any results [2]. assumption on B. The structure uses O(N log2 N) space In the I/O-model, the B-tree [7, 20] supports one- and supports queries in O(logB N + T/B) memory trans- dimensional range queries in O(logB N + T/B) memory fers. Based on this structure, we then give an im- transfers using linear space. In two dimensions, one proved O(logB N + T/B) query general (four-sided) struc- has to use Θ(N logB N/ logB logB N) space to obtain an ture without any assumption on B and with an improved 2 O(logB N + T/B) query bound [6, 19]. The external range- O(N log2 N/ log2 log2 N) space bound. 2. RANGE COUNTING tree, we will, as argued below, locate the relevant topmost In this section we describe a cache-oblivious data struc- point with y-coordinate at most yt in the list Lv in each node tures supporting four-sided range counting queries in v on the search path. Whenever the search continues to the right child, we also add leftsum(pi) to the output count; if O(logB N) memory transfers. A four-sided range counting query Q = [xl,xr] × [yb,yt] can be answered using four two- the point stored at the final leaf is contained in Q the count sided queries; refer to Figure 1. Without loss of generality is incremented by one. we therefore only consider two-sided range counting queries It is easy to see that in order to prove that the query Q =(−∞,xr] × (−∞,yt] in the rest of this section. procedure correctly counts the number of points from S in Q, we simply have to argue that if pi is the topmost point in Lv y with y-coordinate at most yt, then left(pi) and right(pi) are Q yt 1 the topmost points in Lleft(v) and Lright(v) with y-coordinate at most yt. This is implied by the fact that Lleft(v) ⊆ Lv Q1 = (−∞,xr] × (−∞,yt] Q Q and L ⊆ L for all nodes v. 2 Q = (−∞,x ) × (−∞,y ] right(v) v 2 l t It it equally easy to see that the query procedure uses Q3 = (−∞,xr] × (−∞,yb) O(log N) time: O(log N) time to search Lr and O(1) time yb Q = (−∞,x ) × (−∞,y ) 2 2 4 l b at each level of T . Q4 Q3 x xl xr 2.2 Memory layout Figure 1: Reducing four-sided range counting Our method for achieving an efficient cache-oblivious ver- sion of the above data structure is based on two ideas. The queries Q = [xl,xr] × [yb,yt] to four two-sided queries; Q = Q − Q − Q + Q . first idea is a recursively defined memory layout of the Lv 1 2 3 4 lists, developed from the van Emde Boas layout [25] of bi- Our structures are based on a construction of Lueker [23] nary trees. In each step of the van Emde Boas recursion, we further divide the Lv lists for the nodes in the subtree for range reporting in O(log2 N + T ) time. The basic struc- ture resembling Lueker’s construction [23] is described in under consideration. The first part for all nodes in the sub- Section 2.1. The main contribution of Section 2.2 is then tree are stored together, then the next part for all nodes, a recursive layout of this structure in memory that enables and so forth. The second idea is to ensure locality of ref- erence during a search by adding redundant information to cache-oblivious range counting queries in O(logB N) mem- the lists: each list Lv is replaced by a list Lv ⊇ Lv con- ory transfers using O(N log2 N) space. The layout is a gen- eralization of the layout of the cache oblivious search tree of sisting of Lv plus some dummy points. We will ensure that Prokop [25] to handle non-constant sized secondary struc- Lr = Lr and Lv ⊆ Lparent(v) for all nodes v. As in the basic tures. In Section 2.3 we then reduce the space to O(N) using structure, a point pi ∈ Lv has pointers left(pi) and right(pi) standard bit manipulation techniques, assuming that each to the topmost points pl and pr in Lleft(v) and Lright(v) with y-coordinate at most y(pi). However, dummy points are not word contains Ω(log2 N) bits. counted in leftsum(pi), i.e. leftsum(pi) denotes the number 2.1 Basic approach of points in Lleft(v) with y-coordinate at most y(pi). Since Given a set S of N points in the plane, our basic structure, Lv ⊆ Lparent(v) and Lv ⊇ Lv dummy points do not affect the based on the structure of Lueker [23], is defined as follows: time complexity or the correctness of the query procedure The N points are stored at the leaves of a binary search described above. The dummy points are introduced during tree T in x-coordinate sorted order from left-to-right. A list the recursive layout of the structure in memory, as defined Lv is associated with each internal node v of T containing formally below. the points stored at the leaves of the subtree rooted at v The cache-oblivious data structure consists of three sub- sorted with respect to y-coordinate. With each point pi in structures: X, Y , and L. The structures X and Y are sim- Lv we store two pointers left(pi) and right(pi) to the topmost ply van Emde Boas layouts [25] of the base tree T (without point pl and pr in Lleft(v) and Lright(v), respectively, with y- the Lv lists) and of Lr; this cache-oblivious layout supports coordinate at most y(pi); here left(v) and right(v) are the searches in O(logB N) memory transfers [25]. The struc- left and right child of v, respectively, and y(pi) is the y- ture L is the recursive layout of the Lv lists described in the coordinate of the point pi. With pi in Lv we also store the rest of this section. number of points in Lleft(v) with y-coordinate at most y(pi) In the following we let α denote a positive integer. For as leftsum(pi). Finally, for the root r we store a binary the O(N log2 N) space structure we use α = 1, whereas search tree on Lr ordered with respect to y-coordinate. The for the linear space data structure in Section 2.3 we use store uses O(N log N) space since each point is stored in α = ⌊log2 N⌋. The recursive layout is defined using triples a list on each level of T . Figure 7 illustrates a tree T for < C,I,p >, where I is a y-interval, C is a subtree of T sixteen points and the links between the associated Lv lists. consisting of the topmost h levels of the subtree rooted at To answer a counting query Q =(−∞,xr] × (−∞,yt] we a node v, for some height h, and p is a dummy point to be perform a top-down traversal of T for the rightmost leaf included in all Lu lists for nodes u ∈ C; we require that h storing a point with x-coordinate at most xr, while in each |Lu ∩ I| ≤ α2 where h is the height of C, and that the encountered node v locating the topmost point in Lv with y-coordinate of p equals the lower endpoint of I. For the y-coordinate at most yt: We first search the binary search outermost recursion we have C = T and I = (y(p), ∞), tree on Lr to locate the topmost point pi with y-coordinate where p is the lowest input point. at most yt in Lr. Based on the x-coordinate split value in r, The recursive layout of < C,I,p > resembles the van we then proceed to left(v) or right(v) following the left(pi) Emde Boas layout: C is partitioned into a top tree C0 of ⌊h/2⌋ or right(pi) pointers. By continuing this process down the height ⌊h/2⌋ and s = 2 bottom trees C1,...,Cs of L v0 log log n i are O(Pi=0 2 )= O(log n) subtrees C rooted at the an- v0 cestors of the leaf storing q (of which up to O(log2 log2 n) 1 I0 9 subtrees can share a root). Therefore during the recursive > . . . => I layout there are at most O(log N) different recursive lay- height ⌊h/2⌋ n0 2 I > 0 > C0 ; outs < C,I,p > having an ancestor of q as the root of C and y(q) ∈ I. It follows that each point q is at most charged Lv O((log2 N)/α) dummy points. v1 vs 1 height ⌈h/2⌉ . . . Is 9 For the construction in Section 2.3 we need the following . > C1 Cs . > I . = lemma. By a similar argument as in Lemma 1 the number of ns > Is > ; base cases of the recursive layout, i.e. total number of pieces the Lv lists are cut into, becomes O(N + (N log2 N)/α), since each point in an L list can be charged a number of C C C v 0 1 s base cases created instead of the number of dummy points C C C C C C 0,1 · · · 0,n0 1,1 · · · 1,n1 ···s,1 ··· s,ns introduced.
Lemma 2. The total number of base cases in the recursive Figure 2: The recursive layout of a subtree C with layout is O(N +(N log N)/α). respect to an interval I. 2 Finally, we are ready to bound the number of memory transfers used to answer a range counting query (using the height ⌈h/2⌉. The layouts of C0,...,Cs are stored con- query proceedure described in Section 2.1): First observe secutively in memory, and the layout of each Ci consists that the dummy points ensure that a search in a layout of one or more recursive layouts. Let vi be the root of Ci < C,I,p > cannot leave the layout at internal nodes of C and hi the height of Ci. For Ci we split the interval I into using the left(pi) and right(pi) pointers, because all nodes in hi 1 ni C are guaranteed to have a dummy point with y-coordinate ni = ⌈|Lvi ∩ I|/(α2 )⌉ disjoint intervals Ii ,...,Ii , such 1 hi j hi min(I) = y(p). Next observe that the size of < C,I,p > is that |Ii ∩ Lvi |≤ α2 and |Ii ∩ Lvi | = α2 for 1 < j ≤ ni. 1 O(|C|(1 + |Lv ∩ I|)), where v is the root of C, since p and The recursive layouts of Ci are Ci,1 = < Ci,Ii ,p > and j j j each point from Lv ∩I can at most be added once as dummy then Ci,j = < Ci,Ii ,pi >, for 1 < j ≤ ni, where pi is the j points to all L lists for u ∈ C. If C has height at most point with minimum y-coordinate in I ∩ L . Note that u i vi h this is O(α22h). Thus if C has height at most 1 log B the partitioning of I depends on the points in L ∩ I and 2 2 vi and α = 1, the layout of < C,I,p > fits into O(1) blocks, is different for each C . For the base-case of the recursion i and a path through it can be traversed in O(1) memory where C is a single node, {p} ∪ (L ∩ I) is simply stored v transfers. Since a query path from the root to a leaf of T can in consecutive memory locations. The recursive layout is be covered by layouts corresponding to subtrees of height illustrated in Figure 2. between 1 log B and 1 log B, each fitting into O(1) blocks, The dummy points introduced for the example in Figure 7 4 2 2 2 it follows that a query performs O( log2 N ) = O(log N) are shown in Figure 8. Note that the introduction of p9 in (log2 B)/4 B Lleft(r) guarantees that the pointer left(p9) in Lr points to memory transfers. p9 in L , guaranteeing that following the left point of left(r) Theorem p9 at the root will end up at a (dummy) point in the same 1. There exists a cache-oblivious data struc- recursive layout of the top tree. ture for storing N points in the plane using O(N log2 N) The space required for X and Y is O(N) [25]. The space space, such that a four-sided range counting query can be answered in O(log N) memory transfers. required for L, not counting dummy points, is O(N log2 N), B since each input point p appears as a regular point in the L v 2.3 Linear space lists of each of the O(log2 N) ancestors v of the leaf storing p. What remains is to argue that the number of dummy points In this section we describe how the range counting data is at most O(N log2 N). structure in Section 2.2 using O(N log2 N) space can be com- pressed to use O(N) space (memory words) using bit ma- Lemma 1. The total number of dummy points introduced nipulation techniques; we assume that the memory consists in the recursive layout is O(N +(N log2 N)/α). of W ≥ log2 N bit words, and that it is possible to perform shifts, additions, and boolean operations in O(1) time. Proof. Initially (in the outermost recursive level) we in- Let α = ⌊log N⌋; by Lemma 1 the total number of dummy troduce the lowest input point as a dummy point for each 2 points introduced (and base cases of the recursive layout) is node of T , i.e. at most N dummy points. For a recursive layout of
xr xl Figure 3: Slabs (dotted lines) and subdivision de- fined by the x-ranges and active y-intervals (solid Figure 4: Buckets active at y . Only a constant num- lines) of the 2N/T¯ − 1 buckets. The buckets span- b ber of the buckets are intersected by the query Q. ning the slab Xi and their active y-intervals are high- lighted. scribed above with T¯ = 2i. Thus overall the structures uses ¯ O(N log2 N) space. planer (rectangular) subdivision of size 2N/T − 1. Refer to To answer a query Q we simply query C to compute the Figure 3. ¯ output size T = |Q ∩ S| and then we query the structure Ti After defining the 2N/T − 1 buckets, we are now ready where 2i points of Sv in O(log2 N) secondary structures associated 3.2 General structure with v: One structure Lv on Sv for answering three-sided Our general structure for answering three-sided queries queries with the opening to the left, one structure Rv on Sv on a set S of n points in the plane consists of a structure C for answering queries with the opening to the right, and for for three-sided range counting, as well as log2 N structures each multislab Xv [i : j] of v one cache-oblivious search tree T1, T2,..., Tlog2 N for answering queries with known approx- MXv[i:j] on the points in Sv with x-coordinates in Xv [i : j]. imate output size. The structure C is implemented using the The points in each MXv[i:j] tree are stored in y-coordinate O(N log N) space (four-sided) counting structures described order. The secondary structures are stored separately from in Section 2 and each Ti is the linear space structures de- the memory layout of the base tree T . Separately we also v (with respect to the semigroup operator, e.g. max) of the weights of the points contained within the query range. Three-sided semigroup range sum queries are supported in v v v v v 1 2 3 4 5 O(logB N) memory transfers using O(N log2 N) space, and Xv [2 : 3] four-sided semigroup range sum queries are supported in 2 X X X X X v1 v2 v3 v4 v5 O(logB N) memory transfers using O(N log2 N/ log2 log2 N) Xv space. The space bounds hold for semigroups where points can be represented in O(1) space. Figure 5: Node v of base tree T . The slab Xv as- sociated with v is divided into subslabs by the slabs 5.1 Three-sided queries associated with the children v1,...,v5. The three-sided data structure is identical to the O(N log2 N) space cache oblivious range counting data structure described in Section 2, except that a point pi in a store for each node v of T an array of pointers to v’s asso- list Lv now stores two values: leftsum(pi) and rightsum(pi). ciated structures; the node v itself stores a pointer to the The value leftsum(pi) is the sum of the weights of the array. Using this array and index calculation based on i and points in Lleft(v) with y-coordinate at most y(pi). Simi- j, we can access Lv, Rv , and any single MX [i:j] in O(1) v larly, rightsum(pi) is the sum of the weights of the points in memory transfers. Lright(v) with y-coordinate at most y(pi). Since each point in Sv is stored in O(f)= O(log N) linear 2 To perform a query Q = [x ,xr] × (−∞,yt] we follow the space search trees M , and in two O(N log N) space l Xv[i:j] 2 path to the leaf of T storing the point with the smallest x- structures Lv and Rv , the secondary structures of v occupy coordinate larger than or equal to xl, and the path to the leaf O(|Sv | log |Sv|) space in total. Since each point is stored 2 storing the largest x-coordinate less than or equal to xr. For in the secondary structures of the O(log N/ log log N) 2 2 2 each of the visited nodes v we locate the point pi in Lv with nodes on one root-leaf path of T , our structure uses 2 largest y-coordinate that is less than or equal to yt. For all O(N log2 N/ log2 log2 N) space overall. nodes on the search path to xl and xr, respectively, that are To answer a range query Q = [xl,xr] × [yb,yt], we search not nodes on the search path to xr and x , respectively, we down T using O(log N) memory transfers to find the first l B sum up rightsum(pi) and leftsum(pi), respectively. Finally, node v where xl and xr are contained in different children we add the weight of the two leaves if they are contained vi and vj of v. To answer Q on Sv, and thus on S, we then within the query rectangle. first query R to find the points from X lying in Q and vi vi Since the data structure is identical to the data struc- query L to find the points from X lying in Q. Finally, if vj vj ture in Section 2, except for the additional O(1) informa- j > i + 1, we perform a (one-dimensional) range query with tion at the nodes of the Lv lists, the O(N log N) space [y ,y ] on M to find the remaining points from 2 b t Xv[i+1:j−1] bound follows from Section 2. Similarly following each of Xvi+1 , Xvi+2 ,...,Xvj−1 lying in Q. It is easy to see that this the two root-to-leaf paths uses O(logB N) memory trans- correctly reports all T points in Q; refer to Figure 6. Since fers, i.e. a three-sided semigroup range sum query requires each of the three queries uses O(logB N + T/B) memory in total O(log N) memory transfers. access, we have obtained the following. B Theorem Theorem 5. There exists a cache-oblivious data struc- 4. There exists a cache-oblivious data ture for storing N points in the plane using O(N log N) structure for storing N points in the plane using 2 2 space, such that a three-sided semigroup range sum query O(N log2 N/ log2 log2 N) space, such that a four-sided can be answered in O(logB N) memory transfers. range query can be answered using O(logB N + T/B) memory transfers. 5.2 Four-sided queries To support four-sided semigroup range sum queries we X X [i +1 : j − 1] X apply the approach used in Section 4 for reducing four-sided vi v vj range queries to three-sided range queries, by using a fanout yt plog2 N base tree T where each node v spans a slab which is partitioned into plog2 N sub-slabs by the children of v. In the following we will adopt the notion used in Section 4. yb For each node v of T we store Sv in two three-sided struc- xl xr tures (as described in Section 5.1) Lv and Rv, respectively, to answer three-sided queries with the opening to the left Figure 6: Answering query in v by answering three- and right, respectively. For each of the O(log2 N) multislabs sided queries on points in Xvi and Xvj , as well as a Xv [i : j] we have a cache-oblivious search tree MXv[i:j] stor- range query on points in multislab Xv[i + 1, j − 1]. ing the points in S∩Xv[i : j] at the leaves sorted with respect to y-coordinate. With each node u in MXv [i:j] we store the two sums leftsum(u) and rightsum(u) of the weights of the points in the left and right subtree of u, respectively. 5. SEMIGROUP RANGE SUM QUERIES A query is performed in a similar way as described in In this section we describe how the range counting struc- Section 4. First we search T to find the node v where xl and ture in Section 2 can be modified to support semigroup range xr are contained in different sub-slabs Xvi and Xvj of v. We sum queries, where each point has an associated weight from then query Rvi and Lvj with [xl, ∞)×[yb,yt] and (−∞,xr]× some semigroup and the output of a range query is the sum [yb,yt], respectively. If i+1 < j, we query MXv[i+1:j−1] with [yb,yt], where we sum up the rightsum(u) and leftsum(u) [5] L. Arge, M. Bender, E. Demaine, B. Holland-Minkley, values for the nodes u on the search paths for yb and yt, and J. I. Munro. Cache-oblivious priority-queue and respectively, i.e. summing up the weight of the subtrees of graph algorithms. In Proc. ACM Symposium on MXv [i+1:j−1] spanned completely by the range [yb,yt]. Theory of Computation, pages 268–276, 2002. A node v in the base tree occupies O(|Sv | log2 |Sv|) space [6] L. Arge, V. Samoladas, and J. S. Vitter. On for the two three-sided structures Lv and Rv, and O(|Sv |) for two-dimensional indexability and optimal range search each of the O(log2 N) multislab structures MXv[i:j]. There- indexing. In Proc. ACM Symposium on Principles of fore each level of the base-tree T uses O(N log2 N) space, Database Systems, pages 346–357, 1999. 2 with a total of O(N log2 N/ log2 log2 N) space. A query uses [7] R. Bayer and E. McCreight. Organization and O(logB N) memory transfers since the searches in T and maintenance of large ordered indexes. Acta MXv [i+1:j−1] use O(logB M) memory transfers and the two Informatica, 1:173–189, 1972. three-sided semigroup range sum queries also use O(logB M) [8] M. Bender, R. Cole, E. Demaine, and memory transfers. M. Farach-Colton. Scanning and traversing: Maintaining data for traversals in memory hierarchy. Theorem 6. There exists a cache-oblivious data In Proc. European Symposium on Algorithms, pages structure for storing N points in the plane using 152–164, 2002. O(N log2 N/ log log N) space, such that a four-sided 2 2 2 [9] M. A. Bender, G. S. Brodal, R. Fagerberg, D. Ge, semigroup range sum query can be answered using S. He, H. Hu, J. Iacono, and A. L´opez-Ortiz. The cost O(log N) memory transfers. B of cache-oblivious searching. In Proc. 44th Annual Symposium on Foundations of Computer Science, 6. CONCLUSION pages 271–282, 2003. We have presented cache-oblivious data structures for [10] M. A. Bender, R. Cole, and R. Raman. Exponential various planar range problems all achieving optimal query structures for cache-oblivious algorithms. In Proc. time bounds. Four-sided range counting queries can be an- International Colloquium on Automata, Languages, swered in O(logB N) memory transfers using O(N) space. and Programming, pages 195–207, 2002. General semigroup range sum queries can be answered in [11] M. A. Bender, E. D. Demaine, and M. Farach-Colton. O(logB N) memory transfers, using O(N log2 N) space for Cache-oblivious B-trees. In Proc. IEEE Symposium on 2 three-sided queries and O(N log2 N/ log2 log2 N) space for Foundations of Computer Science, pages 339–409, four-sided queries. Range reporting queries can be answered 2000. in O(logB N + T/B) memory transfers, where T is the num- [12] M. A. Bender, Z. Duan, J. Iacono, and J. Wu. A ber of reported points, using space O(N log2 N) for three- locality-preserving cache-oblivious dynamic dictionary. 2 sided range queries and O(N log2 N/ log2 log2 N) space for In Proc. ACM-SIAM Symposium on Discrete four-sided range queries. Algorithms, pages 29–38, 2002. Many problems remain open. Can the space for three- [13] G. S. Brodal and R. Fagerberg. Cache oblivious sided and four-sided range queries be reduced to O(N) and distribution sweeping. In Proc. International O(N log2 N/ log2 log2 N) respectively, matching the optimal Colloquium on Automata, Languages, and space bounds for the I/O-model? Can we achieve space Programming, pages 426–438, 2002. O(N) for special cases of the semigroup range sum problem, [14] G. S. Brodal and R. Fagerberg. Funnel heap - a cache e.g. for max? Our data structures are for static point sets. oblivious priority queue. In Proc. International Can the data structures be made dynamic, while maintain- Symposium on Algorithms and Computation, LNCS ing optimal query times? Can the techniques be used for 2518, pages 219–228, 2002. higher dimensional queries? [15] G. S. Brodal and R. Fagerberg. On the limits of cache-obliviousness. In Proc. ACM Symposium on 7. REFERENCES Theory of Computation, pages 307–315, 2003. [1] P. K. Agarwal, L. Arge, A. Danner, and [16] G. S. Brodal, R. Fagerberg, and R. Jacob. Cache B. Holland-Minkley. Cache-oblivious data structures oblivious search trees via binary trees of small height. for orthogonal range searching. In Proc. ACM In Proc. ACM-SIAM Symposium on Discrete Symposium on Computational Geometry, pages Algorithms, pages 39–48, 2002. 237–245, 2003. [17] B. Chazelle. Filtering search: a new approach to [2] P. K. Agarwal and J. Erickson. Geometric range query-answering. SIAM J. Comput., 15(3):703–724, searching and its relatives. In B. Chazelle, J. E. 1986. Goodman, and R. Pollack, editors, Advances in [18] B. Chazelle. A functional approach to data structures Discrete and Computational Geometry, volume 223 of and its use in multidi mensional searching. SIAM J. Contemporary Mathematics, pages 1–56. American Comput., 17(3):427–462, 1988. Mathematical Society, Providence, RI, 1999. [19] B. Chazelle. Lower bounds for orthogonal range [3] A. Aggarwal and J. S. Vitter. The Input/Output searching: I. the reporting case. Journal of the ACM, complexity of sorting and related problems. 37(2):200–212, 1990. Communications of the ACM, 31(9):1116–1127, 1988. [20] D. Comer. The ubiquitous B-tree. ACM Computing [4] L. Arge. External memory data structures. In Surveys, 11(2):121–137, 1979. J. Abello, P. M. Pardalos, and M. G. C. Resende, [21] M. Frigo, C. E. Leiserson, H. Prokop, and editors, Handbook of Massive Data Sets, pages S. Ramachandran. Cache-oblivious algorithms. In 313–358. Kluwer Academic Publishers, 2002. Proc. IEEE Symposium on Foundations of Computer [25] H. Prokop. Cache-oblivious algorithms. Master’s Science, pages 285–298, 1999. thesis, Massachusetts Institute of Technology, [22] S. Govindarajan, P. K. Agarwal, and L. Arge. Cambridge, MA, June 1999. CRB-tree: An efficient indexing scheme for [26] N. Rahman, R. Cole, and R. Raman. Optimized range-aggregate queries. In Proc. International predecessor data structures for internal memory. In Conference on Database Theory, pages 143–157, 2003. Proc. Workshop on Algorithm Engineering, LNCS [23] G. S. Lueker. A data structure for orthogonal range 2141, pages 67–78, 2001. queries. In Proc. 19th IEEE Symposium on [27] J. Robinson. The K-D-B tree: A search structure for Foundations of Computer Science, pages 28–34, 1978. large multidimensional dynamic indexes. In Proc. [24] O. Procopiuc, P. K. Agarwal, L. Arge, and J. S. SIGMOD International Conference on Management of Vitter. Bkd-tree: A dynamic scalable kd-tree. In Proc. Data, pages 10–18, 1981. International Symposium on Spatial and Temporal [28] J. S. Vitter. External memory algorithms and data Databases, pages 46–65, 2003. structures: Dealing with MASSIVE data. ACM Computing Surveys, 33(2):209–271, 2001. 28 36 +8 35 +8 34 +7 33 +7 32 +7 31 +6 30 +6 29 +5 28 +5 27 +4 26 +4 24 25 +3 32 24 +2 35 +4 23 +1 36 +4 32 +4 22 +1 34 +3 30 +3 21 +1 33 +3 28 +2 31 +3 26 +1 29 +2 25 +1 27 +2 22 24 +1 26 30 23 +1 34 21 +1 22 +1 35 +2 30 +2 36 +2 34 +2 32 +1 26 +2 33 +2 31 +1 28 +1 25 +1 29 +2 27 +0 21 21 +1 23 25 24 +0 27 29 22 +1 31 33 23 +0 35 35 +132 +1 30 +1 26 +133 +1 36 +1 34 +1 27 +1 21 +1 28 +125 +0 24 +1 22 +029 +1 31 +1 23 +0 21,21 22,3523,28 24,32 25,30 26,25 27,2428,26 29,33 30,22 31,29 32,36 33,31 34,34 35,27 36,23 y 36 12 2 14 9 4 13 5 11 3 15 8 6 7 16 10 1 21 21 36 x Figure 7: The basic range counting structure T for 16 points. Leaves show the coordinates of the points and internal nodes show the x-coordinates for the branching. The boxes show the Lv lists, where each line is the y-coordinate of a point pi and a ’+’ followed by the leftsum(pi) value (note that points are not stored in the data structure, the y-coordinates are only included for illustrative purposes). The search path for the query Q =(−∞, 26] × (−∞, 33] is emphasized. 28 36 +8 35 +8 34 +7 33 +7 32 +7 31 +6 30 +6 29 +5 28 +5 27 +4 26 +4 24 25 +3 32 24 +2 35 +4 23 +1 36 +4 33 +3 22 +1 34 +3 32 +3 21 +1 33 +3 30 +2 31 +2 29 +2 29 +2 28 +2 27 +1 26 +1 25 +1 22 25 +1 26 30 23 +1 34 24 +1 22 +1 35 +2 21 +1 30 +2 36 +2 21 +0 34 +2 32 +1 26 +2 33 +2 31 +1 28 +1 25 +1 29 +2 27 +0 21 21 +1 23 25 24 +0 27 29 22 +1 31 33 23 +0 35 21 +0 21 +0 21 +0 35 +1 32 +1 30 +1 26 +1 33 +1 36 +1 34 +1 27 +1 21 +1 28 +1 25 +0 24 +1 22 +0 29 +1 31 +1 23 +0 21 +0 1 +0 21 +0 1 +0 1 +0 1 +0 1 +0 21,2122,35 23,28 24,32 25,30 26,25 27,24 28,26 29,33 30,22 31,29 32,36 33,31 34,34 35,27 36,23 Figure 8: Illustration of the construction of the recursive layout including all dummy points introduced for the example in Figure 7. Dummy points are shown using italic numbers. The shaded triangles depict the toplevel partitioning, and the partitioning of the Lv lists in the top tree correspond to the four recursive layouts of the top tree (there is only one recursive layout for each of the buttom trees).