Slideshow:
Parameters in the Extensible Hashing Algorithm
Note: each physical bucket (disk block) has its own parameter i'
Parameter i:
# bits used in the hash function
Note: # logical buckets = 2i
Parameter i' of a physical bucket:
minimum # bits needed
to find keys in this physical bucket
Parameter i' of a physical bucket:
minimum # bits needed
to find keys in this physical bucket
Example:
How many bits in the hash key do you need to find the search keys in each physical bucket ?
Parameter i' of a physical bucket:
minimum # bits needed
to find keys in this physical bucket
Example:
Answer in the figure above...
2 items in the algorithm that we need to discuss....
2 important items of dicussion in the Extensible Hashing Algorithm:
|
How to update the parameter i' of a physical bucket
Initial state: keys in the physical buckets hashed using i' = 2 bits
How to update the parameter i' of a physical bucket
In a physical bucket split operation, we will use (i'+1) bits to split the keys over 2 physical buckets:
How to update the parameter i' of a physical bucket
After the split, the parameter i' of each bucket is set to i'+1:
How to update the (global) parameter i of Extensible Hashing
Example 1: initial state
How to update the (global) parameter i of Extensible Hashing
Example 1: insert a key and split bucket
How to update the (global) parameter i of Extensible Hashing
Example 1: we can re-map logical → physical to fix the hash index
How to update the (global) parameter i of Extensible Hashing
Example 1: we can solve a split without increasing the logical bucket size if new i' ≤ i
How to update the (global) parameter i of Extensible Hashing
Example 2: initial state
How to update the (global) parameter i of Extensible Hashing
Example 2: insert a key and split bucket
How to update the (global) parameter i of Extensible Hashing
Example 2: we must increase i (and the # logical buckets) to fix the hash index when new i' > i !!
The Extensible Hashing Algorithm
We are now ready to present the Extensible Hashing Algorithm
The Extensible Hashing Algorithm is below in this webpage
- Extensible hashing uses
2 parameters:
- i
=
the number of bits used in the
hash value
(= size of the logical hash table)
- Each physical bucket
has its own
parameter i'.
i' of a physical hash bucket = the minimum number of bits used in the hash value to find (locate) the keys in the physical hash bucket)
- i
=
the number of bits used in the
hash value
-
Parameter i:
the number of bits used in the
hash value
Parameter i determines the number of logical hash buckets
- Recall:
the
hash function used in
extensible hashing
Hash( key ) = RandomNumGen( key ) % 2iGraphically:
-
The number of
logical hash buckets is
equal to:
B = # logical hash buckets = 2i
- Recall:
the
hash function used in
extensible hashing
- The physical bucket's parameter i':
- Each physical bucket
has its own
parameter i':
i' of a physical hash bucket = min # bits in Hash value used to find the index records stored in the physical hash bucket
- Each physical bucket
has its own
parameter i':
- Example:
- Consider the
last example
after we split the
physical hash bucket 01
into the
buckets
001 and
101:
Notice that:
- The search keys
in the physical buckets
00,
10 and
11
requires
only the
last 2 bits in the
hash value to be
found because
- The 3 bits hash values 000 and 100 both map to physical bucket 00 -- so you only need to use the last 2 bits
- The 3 bits hash values 010 and 110 both map to physical bucket 10 -- so you only need to use the last 2 bits
- The 3 bits hash values 011 and 111 both map to physical bucket 11 -- so you only need to use the last 2 bits
- The search keys in the physical buckets 01 requires the last 3 bits in the hash value to be found
- The search keys
in the physical buckets
00,
10 and
11
requires
only the
last 2 bits in the
hash value to be
found because
- Therefore,
the parameter i' of
each of
the physical hash bucket is
as follows:
- Consider the
last example
after we split the
physical hash bucket 01
into the
buckets
001 and
101:
-
How is
parameter i'
updated:
- When we split
a physical hash bucket
in to
2 (physical) hash buckets,
we must
distribute
the hash values
using
one more bit
in the hash function value
Then:
- Each of the new physical hash buckets must use the bucket parameter i'+1
Example:
- Before we
split the
physical hash bucket 01:
- Because
i'=2:
- If we
split the
physical hash bucket
01,
we must
use the
last 3 (= 2+1) bits in
the hash value:
- If we
split the
physical hash bucket
01,
we must
use the
last 3 (= 2+1) bits in
the hash value:
- After the
split,
we update the
parameter i' of
the new physical hash buckets
to i+1:
- When we split
a physical hash bucket
in to
2 (physical) hash buckets,
we must
distribute
the hash values
using
one more bit
in the hash function value
- Recall:
- We can always
double
the size
of the logical hash buckets
in Extensible Hashing:
Schematically:
$64,000 question:
- When do we need to increase (= double) the size of the logical hash buckets ???
Answer:
- The logical hash buckets are
used to
link to
the physical hash buckets:
- When insertion causes
an overflow condition,
a physical hash bucket:
The physical hash bucket is split into 2 buckets:
We must make the link to the new physical hash bucket (data block) in the logical hash table:
- We must increase the logical hash buckets if the link cannot be made !!!!
- We can always
double
the size
of the logical hash buckets
in Extensible Hashing:
- Example 1:
where you do not
need to increase (double) the
logical hash buckets:
- Suppose we have
the following state:
And we insert a search key K that hashes to the full bucket 01010:
After the split, we can link the new data block into the logical hash table by separating the 2 pointers to the same block:
- Suppose we have
the following state:
- Example 2:
where you must
increase (double) the
logical hash buckets:
- Suppose we have
the following state:
And we insert a search key K that hashes to the full bucket 01101:
We must increase (= double) the size of the logical hash buckets (so that we will have duplicate links to the overflow bucket)
- Suppose we have
the following state:
- $64,000 question:
- How can you
tell if you
need to
increase (= double) the
logical hash buckets ???
(I.e.: hwo can you tell when there are more than 1 pointer pointing to the same physical hash bucket ???
Answer:
- If i = i' (of the overflow bucket) then we must increase (= double) the logical hash buckets !!!
- How can you
tell if you
need to
increase (= double) the
logical hash buckets ???
- Notation:
- The logical hash buckets
(= the array of
block numbers)
is called
bucket[ ]
in the Extensible hashing
algorithm:
- The logical hash buckets
(= the array of
block numbers)
is called
bucket[ ]
in the Extensible hashing
algorithm:
- Extensible Hashing
Insert Algorithm:
Parameter: i = # bits used in RandomNumGen Insert( x, recordPtr(x) ) { k = h(x); // Genenral Hash function value j = k % 2i ; // Extensible hash function value Read disk block at bucket[j] (1 block) into memory; if ( bucket[j] block has space for a search key ) { Insert (x, recordPtr(x) ) into the block; Write block back to disk; return; // Done ! } /* ------------------------------------- bucket[j] disk block is full We must allocate a new disk block ------------------------------------- */ /* ======================================================== Check if we need to double the logical hash table size ========================================================= */ Let i' = integer label of physical bucket[j] block; if ( i' == i ) { Double the logical hash table; i = i + 1; // We use 1 more bit to hash Before:
After:
}
/* ===========================================================
Here: we KNOW that we can link the new disk block to
the logical hash table
============================================================ */
Re-hash all search keys in bucket[j] (physical bucket) into
2 block (physical buckets) using i'+1 bits
Update block label in each block (physical buckets) to i'+1
Graphically:
/* ==========================================================
Link the new (split) blocks) to the correct
logical hash buckets
========================================================== */
Let j0 and j1 be the 2 hash values used in the re-hash operation;
// In the figure: j0 = 001 and j1 = 101
Let B0 and B1 be the block addresses of the 2 (new) block (physical buckets)
Bucket[j0] = B0; // Update logical ⇒ physical mapping
Bucket[j1] = B1;
Graphically:
/* ====================================================================
We made space in buckets, try inserting the new key again....
Note: this can recurse further (if all keys hashed into ONE bucket)
==================================================================== */
Insert( x, recordPtr(x) ); // Try again with an extended hash table size !
}