See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/309375845

A Bulk-Loading Algorithm for the BoND-Tree Index Scheme for Non-ordered

Discrete Data Spaces

Conference Paper · September 2016

CITATIONS READS

0 66

4 authors, including:

Akm Tauhidul Islam Qiang Zhu

Michigan State University University of Michigan-Dearborn
7 PUBLICATIONS   32 CITATIONS    94 PUBLICATIONS   694 CITATIONS   

SEE PROFILE SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Genome Sequencing View project

All content following this page was uploaded by Qiang Zhu on 22 October 2016.

The user has requested enhancement of the downloaded file.

 Proc. of 25th International Conf. on Software Engineering and Data Engineering (SEDE'16), Denver, Sept. 26 - 28, 2016
A Bulk-Loading Algorithm for the BoND-Tree Index Scheme for
Non-ordered Discrete Data Spaces
Dong-Yoon Choi† , AKM Tauhidul Islam† , Sakti Pramanik† and Qiang Zhu‡
†
Computer Science and Engineering, Michigan State University, East Lansing, MI, USA
‡
Computer and Information Science, University of Michigan, Dearborn, MI, USA
Abstract
Recent years have witnessed an increasing demand
to process queries on large datasets in Non-ordered Dis-
crete Data Spaces (NDDS) from numerous applications.
A number of index trees have been proposed in the
literature to support efficient queries on large datasets
in an NDDS. However, the conventional tuple-loading
method for building the index trees, takes too much
time. Although numerous bulk-loading techniques have
been proposed to efficiently build index trees for large
datasets in Continuous Data Spaces (CDS), limited
work has been done to efficiently bulk-load an index
tree for a large dataset in an NDDS. In this paper,
we present a bulk-loading method to efficiently build
the recently proposed BoND-tree for a large dataset
in an NDDS. A number of effective strategies have
been incorporated in the method to facilitate the
efficient bulk-loading process. Experimental results
demonstrate that the proposed bulk-loading method is
quite promising in efficiently building a BoND-tree for
a large non-ordered discrete dataset.
keywords: Non-ordered discrete data space, multidi-
mensional index, bulk loading, box query, algorithm.
1 Introduction
In recent years, there is an increasing demand to
process queries on large multidimensional non-ordered
discrete datasets from numerous application domains
such as bioinformatics, network security, and social
media. For example, over the last decade, various se-
quence analysis approaches in bioinformatics have been
developed that make use of fixed-length strings/sub-
sequences, called k-mers, from genome sequences [1, 2].
A k-mer such as “aggctcaa” (an 8-mer) can be viewed as
a vector in a k-dimensional Non-ordered Discrete Data
Space (NDDS), where the value for each dimension
comes from alphabet Ω = {a, g, t, c}. There is no
natural ordering among elements/letters in Ω. Various
sequence analysis problems such as the sequential error
correction [3, 4, 5] and the back translated peptide
k-mer search and local alignment [6] can be solved
by processing queries on large k-mer datasets. To
123
efficiently process queries on such large datasets in
NDDSs, an effective index method is required.
Several index schemes for an NDDS have been pro-
posed recently. The ND-tree [7] is a data-partitioning
based index method developed to support efficient
similarity queries (e.g., range queries and k-nearest
neighbor queries) in an NDDS. The NSP-tree [8] is
a space-partitioning based index method developed to
also support efficient similarity queries in an NDDS.
The BoND-tree [9] is the most recent index method
developed to support efficient box queries in an NDDS.
Each of the above index methods adopts different sets
of heuristics to build an index structure that is most
suitable for its respective query type and assumed
scenarios. Although these index methods can support
efficient queries, using a conventional tuple-loading
(TL) approach come with the methods to build an
index tree for a large dataset often takes too much time.
Efficient index tree building techniques are desired.
A number of so-called bulk-loading techniques have
been suggested to efficiently build the multidimensional
index structures such as the R-tree [10] and its variants
[11] in Continuous Data Spaces (CDS). One set of such
techniques [12, 13, 14] apply a bottom-up approach.
The basic idea is to sort all the input vectors according
to a chosen dimension, place them in the leaf nodes in
the order, and build the target index tree recursively
from bottom up. Another set of techniques [15,
16] adopt a top-down approach. The basic idea
is to sort the input vectors according to a chosen
dimension, divide them into a number of subsets of
an approximately equal size, put each subset into a
subtree of the root, and build the target index tree
recursively from top down. Unfortunately, these sorting
based techniques cannot be directly applied to build an
index tree for NDDSs since no ordering exists for the
values on each dimension for such a space.
Another type of so-called generic bulk-loading tech-
niques [17, 18] utilizes some operations (e.g., Insert-
IntoNode, ChooseSubtree and Split) provided by the
conventional TL algorithm to bulk-load the target tree.
A representative algorithm of this type, termed GBLA
[18], adopts a buffer based approach. The key idea is
to build a temporary structure, called the buffer tree
(whose nodes are called the index nodes), first. Each
index node is associated with a buffer. Vectors are
inserted into the buffer b associated with the desired
index node n first. When buffer b is full, it is cleared
and its vectors are pushed into the buffers for the child
index nodes of n. Only the relevant index node and
buffer pages are kept in the memory. The first buffer
tree is used to appropriately place all the input vectors
into their leaf nodes of the target index tree. A second
buffer tree is then built to appropriately arrange all the
leaf nodes into their parent nodes of the target index
tree, and so on. The target index tree is, therefore, built
in a bottom-up fashion. Although the GBLA algorithm
can be applied for any index structure that supports the
required operations, it is typically not optimized for the
target index structure. Proper modifications are needed
to achieve a better efficiency.
Limited work has been done for bulk-loading the
index trees in NDDSs. A bulk-loading algorithm [19],
called NDTBL, was proposed for the ND-tree, which
is essentially an improved version of GBLA. A bulk-
loading algorithm [20], called NSPBL, was suggested for
the NSP-tree, which adopts a bottom-up space splitting
strategy based on histograms that record the space
distribution of relevant vectors. However, no bulk-
loading technique has been introduced for the most
recent BoND-tree in NDDSs.
In this paper, we introduce a bulk-loading algorithm
to efficiently build a BoND-tree in NDDSs. Our method
was inspired by GBLA [18], but optimized for the
BoND-tree in several ways: (1) buffers are associated
with the nodes of the target index tree directly instead
of employing an auxiliary buffer tree; (2) all the buffers
are kept in main memory ; (3) the buffers of non-
leaf index nodes directly above leaf index nodes can be
larger than the buffers of non-leaf nodes at levels above;
(4) auxiliary buffers are used to bulk-check vectors
for duplicates before insertion; (5) vectors are inserted
into leaf-nodes in groups. Experiments demonstrate
that the proposed bulk-loading BoND-tree algorithm
is efficient compared to the conventional TL algorithm.
The rest of this paper is organized as follows. Section
2 gives an overview of relevant concepts that are needed
for the discussion of this work. Section 3 discusses the
details of the proposed bulk-loading method. Section 4
reports our experimental results. Section 5 concludes
the paper.
2 Preliminaries
In general, a d-dimensional NDDS Ωd is defined as
a Cartesian product: Ωd = A1 × A2 × ... × Ad , where
Ai (1 ≤ i ≤ d) is the alphabet or domain for the i-th
dimension, which consists of a finite number of letters
124
with no natural ordering among them. A discrete
box/rectangle R in Ωd is defined as R = B1 × B2 × ... ×
Bd , where∏Bi ⊆ Ai . The area of rectangle R is defined
d
as |R| = i=1 |Bi |, where cardinality |Bi | is called the
edge length or span of R along the i-th dimension.
For a set of vectors, their discrete minimum bounding
rectangle/box (DMBR) is the smallest rectangle/box
that contains all the vectors. A (discrete) box query q
on a dataset S in an NDDS is defined as a query with a
specified box R that returns all the vectors from S that
lie within R.
The structure of the BoND-tree is similar to that
of the R*-tree [11], except that the discrete geometric
concepts (e.g., discrete rectangle/box) in an NDDS
are used. More specifically, a BoND-tree satisfies the
following two requirements: (1) every non-leaf node
has between m and M children unless it is the root
(which may have a minimum of two children in this
case); (2) every leaf node contains between m and M
entries unless it is the root (which may have a minimum
of one entry/vector in this case). A leaf node contains
an array of entries of the form (op, key), where key is
a vector in the NDDS and op is a pointer to the object
represented by key in the database. A non-leaf node N
contains an array of entries of the form (cp, DMBR),
where cp is a pointer to a child node Ni of N and DMBR
is the DMBR of Ni .
More concepts about the NDDS and the BoND-tree
can be found in [7, 8, 21].
Figure 1: An example of bulk-loading the BoND-tree
3 Bulk-Loading the BoND-Tree
In this section, we introduce a BoND-tree bulk-
loading algorithm, called BoNDTBL which was inspired
by the generic bulk-loading algorithm GBLA [18].
Figure 1 presents an example, illustrating the bulk-
loading process for the BoND-tree using BoNDTBL.
3.1 Key Idea
The basic idea of our algorithm is as follows. Each
node of the target BoND-tree under construction is
saved on disk. Each non-leaf node has an associated
buffer. A buffer consists of several pages. Each page of
the buffer can store at most B vectors. Hence, a buffer
with P pages can store at most B ∗ P vectors. Instead
of keeping most of buffer pages associated with each
non-leaf node on disk as in the GBLA, all pages of such
auxiliary buffers attached to the non-leaf nodes of the
BoND-tree are kept in memory until the construction
of the tree is complete. Auxiliary buffers associated
with non-leaf nodes of the BoND-tree that are directly
above the leaf-nodes are allowed to contain more buffer
pages than the auxiliary buffers of non-leaf nodes at
levels above. This is because a majority of the I/Os
spent from constructing the BoND-tree comes from
inserting vectors into the leaf-nodes. For the rest of
the paper, we will consider P ′ pages for buffers right
above the leaf level where P ′ ≥ P . In order to reduce
the number of attempts to insert duplicated vectors
into the BoND-tree, a duplicate checking is performed
before inserting vectors into the index tree. However,
using the conventional duplicate checking method to
check if each vector is already present in the index
tree one by one before the insertion as done in tuple-
loading the BoND-tree is costly and significantly slows
down the construction process of the BoND-tree. To
make this process more efficient, auxiliary buffers are
used to bulk-check vectors for duplicates in groups
before inserting vectors into the root buffer. Once an
auxiliary buffer associated with a non-leaf node directly
above the leaf nodes becomes full, the input vectors are
first grouped using findBestChild function (an existing
operation for the BoND-tree) and then inserted into the
leaf nodes.
3.2 Main Components
Our bulk-loading algorithm starts with the following
function to filter duplicate input vectors before the
bulk-loading process and inserts distinct input vectors
into the BoND-tree.
Function 3.1. StartBulkLoading
Input: A vector V in a d-dimensional NDDS
1. if (FilterBuffer is full) then
2. uniqV ectors = BulkDuplicateCheck(F ilterBuf f er)
3. for each vector V in uniqVectors do
4. InsertVector(Root, V )
5. end for
6. else
7. InsertIntoBuffer(FilterBuffer, V )
8. end if
Function StartBulkLoading initiates the duplicate
checking process at root buffer before inserting vectors
into the BoND-Tree to ensure that each vector at root in
the BoND-Tree is unique. This routine simply gathers
input vectors into a special auxiliary buffer called
FilterBuffer until it reaches capacity. Once FilterBuffer
reaches capacity, all vectors in FilterBuffer are passed
into function BulkDuplicateCheck. It returns a set of
distinct vectors which are then inserted into the BoND-
Tree. Because the algorithm for BulkDuplicateCheck
125
is similar to the bulk-loading process described in this
section, the details of the algorithm are not included.
The following function inserts the distinct vectors
passed in from StartBulkLoading to begin bulk-loading
the BoND-Tree.
Function 3.2. InsertVector
Input: A vector V in a d-dimensional NDDS
1. if (R buffer is full) then
2. newSiblings := ClearBuffer(R)
3. end if
4. if (!empty(newSiblings)) then
5. Create a new root with R and newSiblings as children
6. Create a new buffer for new root and store in BufferFrame
7. else
8. InsertIntoBuffer(R buffer, U V )
9. end if
Function InsertVector inserts a unique vector into the
root buffer R until its capacity is reached. Once the root
buffer reaches the capacity, all vectors in the root buffer
are cleared to the level below by calling ClearBuffer.
ClearBuffer returns new siblings to the current root
node if a split occurred during the clearing process. If a
new sibling(s) was created, a new root node is created
and an associated buffer is also created and stored in a
main memory list of buffers called BufferFrame.
Function 3.3. ClearInternalBuffer
Input: Buffer Entries Associated to a Non-leaf Node N
Output: newSiblings
1. overflowList := {}
2. for each of B ∗ P vectors in buffer of N do
3. BestChild := ChooseSubtree(N, UV)
4. ChildBuffer := BufferFrame(BestChild)
5. InsertIntoBuffer(ChildBuffer, UV)
6. if ChildBuffer overflows then
7. add BestChild to overflowList
8. end if
9. end for
10. newChildren := {}
11. for each Child in overflowList do
12. add ClearBuffer(Child) to newChildren
13. end for
14. newSiblings := InsertChildren(N, newChildren)
15. Store each new buffer created for a new sibling in BufferFrame
16. return newSiblings
Whenever a buffer gets full, the entries are directed
to the corresponding children nodes. A simple approach
of clearing the entries would be to determine the most
suitable child for each buffer entry in FCFS manner.
However, this technique may require more I/Os while
clearing entries to the leaf nodes as same leaf node may
need to be called more than once. To optimize the
I/O cost, first, we determined the best child node for
each buffer entry right above the leaf level and then
grouped them based on the child DMBR index. Then,
the corresponding leaf nodes are called only once to
insert the vectors. This is referred as optimized buffer
clearing in the following text.
Function ClearBuffer distinguishes between non-leaf
nodes and leaf nodes. Function ClearInternalBuffer
clears the vectors from an overflowing buffer of a non- In case of a leaf node split (via an existing operation
leaf node. It is similar to the relevant procedure Split for the BoND-tree), DMBR of the new leaf node
described in GBLA with a few changes. As in GBLA, is inserted into N and the entries of N are updated.
ClearInternalBuffer clears B ∗ P vectors in the buffer If all groups of vectors are inserted into the desired
of node N. However, there is no need to read in the data pages without causing node N to split, function
pages of the buffer from disk as they are already present ClearLeafBuffer returns the empty set, newSiblings.
in main memory in BufferFrame for our algorithm. However, during the insertion process the splitting of
ClearInternalBuffer calls ChooseSubtree function (an a leaf node may cause node N to split. In this case,
existing operation for the BoND-tree) for each vector to a new sibling of node N and a new buffer for this new
assign the vector to one of the children of N and inserts sibling is created. The block number of the new non-leaf
the vector into the buffer of the desired child node. node is added to newSiblings and the remaining vectors
The desired child node is determined by applying a in the buffer of N are then split between the buffer of
set of heuristics such as minimum overlap enlargement, N and the buffer of its new sibling. Then the vectors
minimum area enlargement, and minimum area. To in buffers of both N and the new sibling are cleared by
break a tie between two children, the heuristics are calling ClearLeafBuffer on each sibling node and any
applied in the order they are presented. If there is new sibling node resulting from this clearing process
still a tie after all the heuristics are applied, a child is is also added to newSiblings. After clearing both of
chosen randomly. If the buffer of a child node overflows, the buffers of node N and its new sibling, function
it is added to overf lowList. But it is important to ClearLeafBuffer returns the set of new siblings created
note that it can still receive vectors from the buffer of during leaf buffer clearing process.
N. Once B ∗ P vectors have been cleared, ClearBuffer
executes either ClearInternalBuffer or ClearLeafBuffer
for any child node in overf lowList based on the buffer
level in the tree. Any new children created from this
clearing process are inserted into N, and if N splits, each
new buffer created for a new sibling of N is stored in
BufferFrame. ClearInternalBuffer function returns the
newSiblings of N.
Function 3.4. ClearLeafBuffer
Input: Buffer Entries Associated to a Leaf Node N
Output: newSiblings
1. newSiblings := {}
2. for each unique vector (UV) in buffer of N do
3. DataNodeNumber := ChooseSubtree(N, UV)
(* DataNodeNumber is temporarily stored with UV *)
4. end for Figure 2: I/O comparison of buffer clearing techniques
5. Sort UVs in buffer by desired DataNodeNumber
6. for each group of UVs in buffer of N with the same desired
DataNodeNumber do 4 Experiments
7. insert the UV into the desired DataNode of N To examine the performance of the proposed bulk-
8. if DataNode overflows then
9. Split(DataNode) (* update entries of N *)
loading method BoNDTBL, we conducted extensive
10. if overflow in N then experiments. The performance was evaluated in terms
11. NewSibling := Split(N) of index creation time and I/O as well as box query
12. create buffer for NewSibling & store in BufferFrame search efficiency I/O. BoNDTBL was implemented in
13. (* split buffer of N with new buffer of NewSibling *)
14. add NewSibling to newSiblings the C++ programming language. All the experiments
15. add ClearLeafBuffer(N) to newSiblings were conducted on a virtual linux environment with
16. add ClearLeafBuffer(NewSibling) to newSiblings a 2.6 GHz Intel Core i5 CPU, 1 GB RAM and
17. end if 20 GB storage in a Macbook with a 2.6 GHz Intel
18. end if
19. end for Core i5 CPU, 8 GB RAM and 120 GB Hard Drive.
20. return newSiblings The k-mers in the test database are generated from
bacteria.105.1.genomic.fna sequences. Box queries are
Function ClearLeafBuffer inserts the vectors in buffer
created from a set of Nitrogen Reductase (Nirk) protein
of node N to the desired leaf nodes in groups. For this
sequences. The performance data was measured based
to happen, the vectors in the buffer of N are first sorted
on the average from three executions. In the remaining
based on the block number of the desired leaf node.
discussions, we use BL BoND-tree and TL BoND-tree
Once the vectors are grouped by desired leaf nodes, each
to denote the BoND-trees constructed by the bulk-
group of vectors are inserted into the relevant leaf node.
loading and tuple-loading methods, respectively.

126
4.1 Clearing Buffer Entries
We have experimented with different techniques of
clearing buffer entries. Figure 2 presents the compari-
son of FCFS and optimized buffer clearing techniques
on indexes of 4M 15-mer vectors for different buffer
sizes. It is shown that the optimized buffer clearing
reduces I/O cost significantly for any buffer size. As
buffer size increases, the optimized approach reduces
I/O proportionately because more vectors could be
inserted into children nodes at once.
62
BL BoND-tree Buffer Size vs. Time
61
Index Ceation Time (min)
60
59
58
57
56
55
100 150 200
Buffer Size (# Entries)
Figure 3: Buffer size effect on index construction time
4.2 Buffer Size Effect
The buffer size used in creating the BL BoND-tree
was determined by constructing indexes using different
buffer sizes and picking the buffer size that constructed
the tree in the least amount of time. The buffer size
is defined by the total number of vectors it can hold.
Figure 3 shows average BL BoND-tree construction
time for a dataset of 20 million 15-mer vectors using
different buffer sizes. Increasing buffer sizes has a
trade-off between reduced time for I/Os and increased
processing time for grouping vectors. Our experiments
showed that, buffer size of 280 entries required lowest
tree construction time for the datasets. We have
also experimented with different size of datasets to
validate optimum buffer size. The difference of index
construction time increases over a range of buffer sizes
with increasing dataset size. However, in figure 3, we
put index construction time of only one dataset so that
the effect of buffer sizes can be seen explicitly.
4.3 Index Creation Time and I/O
We have compared the index creation performances
of the BL BoND-tree algorithm and the TL BoND-tree
approach. The evaluation was based on the number
of disk I/Os and construction time in minutes. The
disk block size was set to 4 KB. The minimum space
utilization for a disk block was set to 30%. Figure
4(a) and 4(b) show the number of of I/Os and time in
minutes, respectively, needed to construct the BoND-
trees for datasets of different sizes using tuple-loading
and bulk-loading methods.
Both figures show that the proposed bulk-loading
algorithm for the BoND-Tree outperformed the con-
ventional tuple-loading algorithm in terms of disk I/Os
which is translated to better construction time. For
example, BoNDTBL with bulk duplicate-checking was
able to reduce construction time by 51% when loading
20 million genomic vectors in our experiments. The
bulk-loading algorithm consistently performed better
with an increasing database size, which shows our
strategies via keeping buffers in main memory, using
auxiliary buffers for bulk-checking duplicates as well as
optimized buffer clearing technique for leaf nodes were
effective.
4.4 Quality of the Index
We have also compared quality of BL BoND-trees
with TL BoND-trees by examining box query search
performance. The evaluation was based on the box
query search I/Os. We have generated 1000 15-mer box
queries from a set Nirk query sequences and executed
the queries on both 15-mer BL BoND-trees and TL
250 300 350 400
BoND-trees. Table 1 shows the query search I/Os for
different index sizes. Though, BL BoND-trees and TL
BoND-trees may construct different index structures,
the resulting k-mer vectors are exactly same which
shows the correctness of the proposed method. Same
set of singleton k-mer vectors are stored at the leaf level
and the box queries search all the relevant paths in the
index. On the other hand, the numbers of I/Os of both
trees are almost same. Hence, the qualities of the trees
are comparable.
Table 1: Comparison of Box-query Search I/Os
between BoNDTBL and BoND-tree
k-mers k-mer Hits # BoxQuery I/Os
(M ) BL BoND-tree TL BoND-tree
4 2006 4516 4516
20 9492 4695 4679
36 13249 4742 4734
52 16675 4794 4786
5 Conclusions
Although many bulk-loading techniques have been
proposed to construct index trees in CDSs, limited
similar work has been done specifically for NDDSs.
In this paper, we have presented a bulk-loading algo-
rithm to bulk-load the BoND-tree for large datasets in
NDDSs. The algorithm incorporates various effective
strategies including use of available memory to store
all buffers associated with non-leaf nodes, applying
an efficient duplicate bulk-checking mechanism, and
grouping entries before inserting into leaf-nodes of the
index tree. Experiments show that the proposed bulk-
loading algorithm outperforms the conventional tuple-
loading algorithm regarding disk I/Os and construction
time of the index tree. Future work includes using
127
 Figure 4: Comparison of Bulk-loading and Tuple-loading BoND-tree index construction a) I/Os and b) time
information in buffers at time of a node split for a better
splitting process and exploring the multi-way splitting
of leaf nodes as proposed in NDTBL [19].
Acknowledgment: Research was supported by the US
National Science Foundation (NSF) (under Grants IIS-
1319909 and IIS-1320078) for Research Experiences for
Undergraduates (REU).
References
[1] M. Metzker. Sequencing technologies - the next
generation. Nat Rev Genet, 11:31–46, 2010.
[2] T. J. Treangen, S. L. Salzberg. Repetitive DNA and
next-generation sequencing: computational challenges
and solutions. Nature Reviews Genetics, 13(1):36–46,
2012.
[3] Y. Gu, Q. Zhu, X. Liu, Y. Dong, C. T. Brown, S.
Pramanik. Using Disk Based Index and Box Queries
for Genome Sequencing Error Correction. Proc. of
BICoB’16, pp. 69 – 76, 2016.
[4] Y. Gu, X. Liu, Q. Zhu, Y. Dong, C. T. Brown, S.
Pramanik. A new method for DNA sequencing error
verification and correction via an on-disk index tree.
Proc. of ACM BCB’15, pp. 503–504, 2015.
[5] D. R. Kelley, M. C. Schatz, et al. Quake: quality-aware
detection and correction of sequencing errors. Genome
Biol, 11(11):R116, 2010.
[6] AKM T. Islam, S. Pramanik, X. Ji, J. R. Cole, Q.
Zhu. Back Translated Peptide k-mer Search and Local
Alignment in Large DNA Sequence Databases Using
BoND-SD-tree Indexing. Proc. of BIBE’15, pp. 1 – 6,
2015.
[7] G. Qian, Q. Zhu, Q. Xue, S. Pramanik. The ND-tree:
A dynamic indexing technique for multidimensional
non-ordered discrete data spaces. Proc. of VLDB’03,
pp. 620–631, 2003.
[8] G. Qian, Q. Zhu, Q. Xue, S. Pramanik. A space-
partitioning-based indexing method for multidimen-
sional non-ordered discrete data spaces. ACM Trans.
on Info. Syst., 23(1):79–110, 2006.
[9] C. Chen, A. Watve, S. Pramanik, Q. Zhu. The BoND-
tree: an efficient indexing method for box queries
128
View publication stats
in nonordered discrete data spaces. IEEE Trans. on
Knowl. and Data Eng., 25(11):2629–2643, 2013.
[10] A. Guttman. R-tree: a Dynamic Index Structure for
Spatial Searching. Proc of SIGMOD’84, pp.47–57, ’84.
[11] N. Beckmann, H.P. Kriegel, R. Schneider and B.
Seeger. The R*-tree: an efficient and robust
access method for points and rectangles.. Proc. of
SIGMOD’90, pp. 322–331, 1990.
[12] D. DeWitt, N. Kabra, J. Luo, J. Patel, J. Yu. Client-
Server Paradise. Proc. of VLDB’94, pp. 558–569, 1994.
[13] I. Kamel, C. Faloutsos. On packing R-trees. Proc. of
CIKM’93, pp. 490–499, 1993.
[14] N. Roussopoulos, D. Leifker. Direct spatial search
on pictorial databases using packed R-trees. Proc. of
SIGMOD’85, pp. 17–31, 1985.
[15] Y. Garcia, M. Lopez, S. Leutenegger. A greedy
algorithm for bulk loading R-trees. Proc. of ACM-
GIS’98, pp. 02–07, 1998.
[16] S. Leutenegger, J. Edgington, M. Lopez. STR: A
Simple and Efficient Algorithm for R-Tree Packing.
Proc. of ICDE’97, pp. 497–506, 1997.
[17] S. Berchtold, C. Bohm, H.-P. Kriegel. Improving
the Query Performance of High-Dimensional Index
Structures by Bulk-Load Operations. Proc. of
EDBT’98, pp. 216–230, 1998.
[18] J. Bercken, B. Seeger, P. Widmayer. A Generic
Approach to Bulk Loading Multidimensional Index
Structures. Proc. of VLDB’97, pp. 406–415, 1997.
[19] H.-J. Seok, G. Qian, Q. Zhu, A. Oswald, S. Pramanik.
Bulk-loading the ND-tree in non-ordered discrete data
spaces. Proc. of DASFAA’08, pp. 156–171, 2008.
[20] G. Qian, H.-J. Seok, Q. Zhu, S. Pramanik. Space-
partitioning-based bulk-loading for the NSP-tree in
non-ordered discrete data spaces. Proc. of DEXA’08,
pp. 404–418, 2008.
[21] G. Qian, Q. Zhu, Q. Xue, S. Pramanik. Dynamic
indexing for multidimensional non-ordered discrete
data spaces using a data-partitioning approach. ACM
Trans. on Database Syst., 31(2):439–484, 2006.