SCHEMES FOR SRTREE PACKING Jayendra G Venkateswaran

1
SCHEMES FOR SR-TREE PACKINGJayendra G
Venkateswaran

• Advisor Dr.S.R.Subramanya
• Co-Advisor Dr.Daniel St.Clair
• Committee Member Dr. Jagannathan Sarangapani

2
Outline

• Introduction
• Motivation
• SR-Tree
• Problem Statement
• Proposed Packing Schemes
• Experimental Results
• Conclusions and Future Directions

3

• Introduction

4
Introduction

• Multidimensional Index structures and access
  schemes have been active research areas.
• Need for Multidimensional access method
• Indices are multidimensional.
• Methods one-dimensional access methods are
  inefficient.
• Classification
• Point Access Methods
• Hashing Methods Grid File.
• Hierarchical Structures KDB-Tree.
• Spatial Access Methods
• Transformation Methods UB-Tree.
• Overlapping Methods R-Tree, SR-Tree.
• Clipping Methods R-Tree.

5
Rectangle-Tree or R-Tree

• R-Tree
• Guttman in 1984.
• Height balanced structure.
• Minimum-bounding rectangle (MBR) are used to
  represent the enclosed objects.
• Root has at least two children( unless its is
  leaf node).
• Every non-leaf node has between m and M children,
  unless it is the root, of the form MBR,
  Child_Pointer.
• M maximum number of entries per node
• m minimum number of entries 2 m M/2
• Every leaf-node has between m and M entries of
  the form MBR, Object_Pointer.
• Tries to minimize the area of enclosing
  rectangles in index nodes.
• All leaves appear on the same level.

6
R-Tree (Contd.)
R-Tree Structure
7
R-Tree

• R-Tree
• Successful variant of R-Tree.
• Optimization Criteria Area Covered, Overlap,
  Margin and Storage utilization.
• Defers split by Forced Re-insertion Part of the
  entries are re-inserted during insertion.

8
R-Tree (Contd.)
R-Tree
9
SS-Tree

• SS-Tree
• White and Jain in 1996
• Similar to R-Tree, but uses bounding spheres.
• Stores fewer information than bounding
  rectangle-larger fanout.
• Disadvantage bounding sphere occupy larger
  volume resulting in more overlap.
• The entries of the non-leaf nodes are of the form
  Centroid, Radius, Child_Pointer.

10
SS-Tree (Contd.)
SS-Tree
11
Motivation

• Modern Database Systems use large amount of
  Multidimensional datasets.
• Some areas of application
• Geographic Information Systems (GIS)
• Multimedia Database Systems
• Digital Libraries
• Incremental construction of index structures has
  poor utilization and query performance.
• Pre-processing of static datasets improves the
  query performance.

12

• SR-Tree

13
Sphere/Rectangle Tree or SR-Tree

• Katayama in 1997.
• Extension of R-Tree and SS-Tree.
• Region specified by the intersection of a
  bounding sphere and a bounding rectangle.
• Reduces the volume of the bounding sphere and
  diameter of the bounding rectangle.
• Improves the search performances for
  high-dimensional datasets.
• Thus outperforms both SS-Tree and R-Tree.
• Entries in non-leaf nodes are of the form
  Centroid, Radius, MBR, n, Child_Pointer.
• MBR minimum bounding rectangle of the entries.
• n total number of objects stored in the
  sub-tree.

14
SR-Tree (Contd.)
SR-Tree Structure
15
SR-Tree (Contd.)

• Center of the bounding-sphere
• Ek kth entry in the child node
• Ek.w total number of objects in the sub-tree
  rooted at Ek
• n number of entries in the node.

16
SR-Tree (Contd.)

• Radius,
• r MINIMUM (ds, dr)
• ds MAX x - Ek.x Ek.r 1
  k n
• dr MAX MAXDIST(x, Ek.MBR )
  1 k n
• Where MAXDIST ( ) computes the maximum
• distance from a point to the centre of a
• Minimum-bounding rectangle.

17

• Problem Statement

18
Problem Statement

• Building SR-Tree from scratch by inserting
  objects one by one has the following
  disadvantages
• Increasing load time,
• Inefficient space utilization and
• Poor SR-Tree Structure resulting in poor search
  performance.
• To design and implement packing schemes for
  SR-Tree.

19
Goals

• Implement Hilbert and STR ordering schemes for
  SR-Tree packing
• Evaluate the performances of the packing schemes.
• Compare the performances of packed structures of
  SR-Tree with those of R-Tree structures.

20

• Proposed Packing Schemes

21
Packing

• Grouping of similar objects together.
• For static dataset, packing the structure with
  pre-processed data yields better utilization and
  query performance.
• Methods for grouping the objects
• Space-filling curves Z-Ordering, Hilbert-Curve.
• Sort-Tile-Recursive Ordering.

22
Space-filling Curve

• Map multi-dimensional data space into
  one-dimensional space.
• Visit all points in the d-dimensional space
  exactly once without crossing itself.
• Objects in the one-dimensional space are likely
  to preserve the spatial proximity.
• Z-Ordering, Gray Code and Hilbert-curve.

23
Z-Ordering

• Peano space-filling curve.
• Bit-interleaving of binary representation of the
  coordinates.
• Example
• x 0011 and y 1010 Z-Value 01001110

Z-Ordering
24
Hilbert-Curve

• Rotation and reflection of a basic pattern.
• Complex computation.
• Superior to gray code and Z-ordering.
• Hilbert curve of order i is obtained by
  replacing vertices of H1 with Hi-1 after rotation
  and reflection.

2-D Hilbert Curves of Order 1, 2 and 3
25
Sort-Tile Recursive Method

• Leutenegger, Edgington and Lopez in 1997.
• STR Method
• Leaf level pages P and number of slices
  let S
• Sort the rectangles by first dimension of the
  center point and partition them into S vertical
  slices, each consisting of a run of (
  b) consecutive rectangles from the sorted list.
• Each slice is recursively processed with the
  remaining (n-1) coordinates.

26

• Packing Algorithm

27
SR-Tree Packing

• Packing for static datasets.
• Sort the objects in the dataset.
• By a sequential scan, each set of b nodes are
  assigned to a leaf node at level 0.(last node can
  have less than b entries).
• SR-Tree is built recursively. At each step b
  entries of level l is assigned to a level (l1)
  node.

28
Notations

• Queues A and B To store the intermediate nodes
  during creation of SR-Tree.
• Enque( ) Adds a node to the end of a queue.
• Deque( ) Returns the first element in the
  queue.
• Not_Empty( ) Returns 1 if queue has entries and
  0 otherwise.
• Count( ) Returns total number of entries in a
  queue.
• b Number of entries in a node.

29
Algorithm Outline

• Sort N objects using Hilbert/STR Ordering.
• Each set of b entries in the sorted list is
  assigned to a node X and X is added to queue A.
• Assign set of b entries from queue A to node X
  and add X to queue B.
• Move contents of queue B to queue A.
• Steps 3 and 4 are followed until A has only one
  entry, the root.
• Return the root node from queue A.

30
Algorithm Pseudo Code

• Input Dataset of N objects.
  Output Root Node N of the Packed SR-Tree.
• // Order by Hilbert-values/ Sort-Tile Recursive
  Method.
• Sort the N objects in ascending order.
• //Assign the entries to Leaf- Nodes. Uses a Queue
  A
• For i 1 to (N/b) do
• Assign b objects to node X
• Enque X in A.
• //Build SR-Tree from the leaf-nodes to the root
  by Bottom-Up. Uses the Queues A and B.
• Do
• While(Not_Empty(A))
• Remove b entries from A and assign them to Node X
• Enque X in B
• Move contents of B to A.
• While (Count (A) gt 1)
• N Deque (A).
• Return N

31
Analysis

• Height
• Number of nodes
• Number of Entries
• Probability of retrieving a node Ni
• ( Area for 2-d object)
• Where
• N Size of the dataset
• b Number of entries per node

32

• Experimental Results

33
Experimental Setup

• Structures implemented in C.
• Comparison Metrics
• Space Utilization -
• Height
• Query Performance Number of nodes accessed
• Average Volume/Diameter
• Parameters
• Entries per node, b.
• Dataset size 1000 to 3000 objects.
• Datasets
• Uniformly distributed synthetic dataset
  containing 3000 objects.
• Mildly skewed VLSI dataset containing 2200
  objects.
• Highly skewed VLSI dataset containing 1024
  objects.

34
Height
35
Disjointness Average Area/Diameter of Leaf-level
regions.
36
Disjointness Visual Representation Z-Ordering
Uniformly distributed Data
37
Hilbert-Ordering
Uniformly distributed Data
38
STR-Ordering
Uniformly distributed Data
39
Space Utilization
40
Query Performance Point Query
Nodes Accessed
41
Range Queries
42
SR-Tree Vs R-Tree Packing Uniformly Distributed
Data
43
Mildly skewed data
44
Highly skewed data
45

• Conclusions and Future Directions

46
Conclusions

• Schemes for SR-Tree packing
• Hilbert and STR Orderings outperformed Z-Ordering
  Consistently.
• For uniformly and mildly skewed datasets,
  STR-Ordering accessed fewer nodes for range
  queries.
• For highly skewed data, Hilbert-Ordering gave
  better query performance than STR-Ordering.
• Packing scheme used depends on the application
  and distribution of data.
• SR-Tree Vs R-Tree Packing Schemes
• SR-Tree Packing consistently performed better
  than the corresponding schemes proposed for
  packing of R-Tree.
• The schemes can be generalized for higher
  dimensions.

47
Future Directions

• Develop space-filling curve with better space
  partitioning and preserving spatial proximity.
• Other packing strategies Buffering Techniques,
  Bulk-loading into existing Structures can be
  developed.
• Architectures and schemes for parallel query
  processing and data partitioning.

48
Questions ?

• Thank You !