Slideshow:
Storing the internals of
a kd-tree
Storing the internals of
a kd-tree -
method 1: pointer swizzling
An internal node is just a record that is identified by a database address:
Storing the internals of
a kd-tree -
method 1: pointer swizzling
A node pointer in an internal node is a database address (pointing to an internal node record):
Storing the internals of
a kd-tree -
method 1: pointer swizzling
We can store multiple internal nodes into one disk block as follows:
Storing the internals of
a kd-tree -
method 1: pointer swizzling
Replace the database address by a memory address (= pointer !) when disk block is in memory:
Storing the internals of
a kd-tree -
method 2: multi-way kd-tree
Storing the internals of
a kd-tree -
method 2: multi-way kd-tree
- Notice that, the
internal nodes of
the kd-tree is
rather
smaller in
size:
Internal nodes of a kd-tree are not suitable to be stored on disk (waste a lot of disk space)
- Problem statement:
- The kd-tree was
developed
as a
main-memory data structure
and not suitable to
be stored on
disk
- We need to adapt (modify) the kd-tree so that it can be stored efficiently on disk
- The kd-tree was
developed
as a
main-memory data structure
and not suitable to
be stored on
disk
- Notice that
we only need to
adapt (= modify)
the storage of the
internal nodes:
Because the leaf nodes are already stored in data (disk) blocks !!!
- Storing
the internal nodes
- Each internal node is a
record identified
by a
database address
(See: Identifying blocks/records on disks and in memory for details)
- The node pointers in
each internal node is a
database address (to
a record):
- We store multiple
internal nodes into
one disk block:
- When the
disk block
(containing
database addresses is
read into
memory:
- We
swizzle
all the
database addresses to
memory addresses
(And the kd-tree stored on disk) has become a memory data structure !!!)
- We
swizzle
all the
database addresses to
memory addresses
- Each internal node is a
record identified
by a
database address
- Swizzling the
kd-tree into
a memory data structure:
- When a block of
internal nodes is
read into
main memory,
do this:
Note: 1 disk block will contain multiple (internal) kd-nodes !!! /* ======================================== Update the translation table ======================================== */ for ( each (internal) kd-node "N" in the disk block ) do { Enter N's database address into the translation table; (See: this webpage for details) } /* ================================================== Swizzle the parent and child pointers if possible ================================================== */ for ( each (internal) node N in block ) do { if ( N.left child is in memory ) { swizzle N.left pointer; swizzle N.left's parent pointer to N; } if ( N.right child is in memory ) { swizzle N.right pointer; swizzle N.right's parent pointer to N; } if ( N.parent is in memory ) { swizzle N.parent pointer; swizzle N's parent's child pointer to N; } }
- When a block of
internal nodes is
read into
main memory,
do this:
- If pointer swizzling is
not available, we can
implement a
multi-way kd-tree
that is similar to
the B-tree:
- A multi-way kd-node
(Different levels will store a different type of search keys; so the tree is still multi-way.
- Each node is
stored in 1 disk block
- Just like the B-tree, we can impose the requirement that at least half of the pointers must be used !!!
- A multi-way kd-node
- Note:
- The search and insert algorithms are similar to the B-tree algorithms !!!