- Hash function used
in traditional hash techniques:
Hash( key ) = RandomNumGen( key ) % Bwhere:
- B = a prime number (so that Hash(key) is uniformly distributed)
- Hash function used
in extensible hashing:
Hash( key ) = RandomNumGen( key ) % 2i
Graphically:
- Comment:
- These concepts are not in the text book....
I introduced the concepts of
- Logical hash buck
- Physical hash bucket
- I think this make the material easier to understand....
- These concepts are not in the text book....
- Physical hash bucket:
- Physical hash bucket = a disk block used to store the index entries
- Logical hash bucket:
- Logical hash bucket = a entry in the bucket array
Graphically:
- In "normal" hashing:
- The number of
logical hash bucket
is equal to the
number of
physical hash bucket
and
- Every logical hash bucket is mapped to a different physical hash bucket
Graphically:
- The number of
logical hash bucket
is equal to the
number of
physical hash bucket
and
- In Extensible hashing:
- The number of
logical hash bucket
is ≥ the
number of
physical hash bucket
and
- Every logical hash bucket
is mapped to
a physical hash bucket
- "Related" logical hash buckets can be mapped to the same physical hash bucket !!!
Graphically:
- The number of
logical hash bucket
is ≥ the
number of
physical hash bucket
and
- Doubling the
hash table size
in "normal" hashing
- Consider the
following state
using
"normal" hashing:
- If we double the
size of the
logical hash table in
normal hashing:
- We must re-hash all keys stored in the hash table
Example:
(Because otherwise we cannot find the index entries !!!)
- Consider the
following state
using
"normal" hashing:
- Important property
of Extensive hashing:
- In Extensive hashing, we can double the size of the logical hash table without having to re-hash any keys !!!
- Example:
- Consider the
following state using
extensive hashing:
- We can double the
size of the
logical hash table
without
having to
re-hash any
key as follows:
- Consider the
following state using
extensive hashing:
- Important consequence of
Extensive hashing
- When
a disk block (= physical hash bucket)
becomes full in
Extensive hashing:
- We can re-hash only the keys in the overflowed disk block without having to rehash any other disk block !!!
- When
a disk block (= physical hash bucket)
becomes full in
Extensive hashing:
- Example:
- Consider the
following state in
extensible hashing:
- We can re-hash
only the
key in the
overflow block
using i = 3 (3 bits):
-
Then
fix the
logical ⇒ physical
hash bucket mapping:
- Consider the
following state in
extensible hashing:
- Parameter i:
the number of
logical hash buckets
- Recall:
the
hash function used in
extensible hashing
Hash( key ) = RandomNumGen( key ) % 2iGraphically:
- i =
the number of bits
used in the
hash function value
in extensible hashing
Also: the number of logical hash buckets is
# 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 bucket = # bits in RandonNumGen(key) used to find the physical bucket
- Each physical bucket
has its own
parameter i':
-
How is
parameter i'
updated:
- When we split
a physical hash bucket
(and use one more bit
in the hash function value):
- We increase the bucket parameter i' by 1
Graphically:
- When we split
a physical hash bucket
(and use one more bit
in the hash function value):
- Initial state in
extensible hashing:
- Initially,
we can use 2 buckets and
use i = 1 bit in
RandomNumGen( )
to find the buckets:
- In fact,
you can use
any value for
i:
- As long as physical bucket i' = i for all buckets !!!
- Initially,
we can use 2 buckets and
use i = 1 bit in
RandomNumGen( )
to find the buckets:
- Notation:
- The logical hash table
(= the array stored in memory)
is called
bucket[ ]
in the Extensible hashing
insert algorithm:
- The logical hash table
(= the array stored in memory)
is called
bucket[ ]
in the Extensible hashing
insert 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 ------------------------------------- */ Let i' = integer label of physical bucket[j] block; /* ======================================================== Check if we need to increase the logical hash table size ========================================================= */ if ( i' == i ) { Double the logical hash table; i = i + 1; // We use 1 more bit to hash Before:
After:
}
/* ===========================================================
We now have: i > i'
** At least 2 different logical hash entries are mapped
** to the (one) overflowed physical hash bucket !!
We can re-hash the overflowed physical hash bucket
into 2 (separate) physical hash buckets to remove
the overflow condition
============================================================ */
Re-hash bucket[j] disk block (physical bucket) into
2 block (physical buckets) using i'+1 bits
Label each block (physical buckets) with i'+1
Graphically:
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:
Insert( x, recordPtr(x) ); // Try again with an extended hash table size !
}
- Example:
Extensible Hash Table
- Initial State:
- Insert a record
X such that:
h(X) = 0101:
Bucket 1 is full !!!
- Because
i == i' :
- Double the logical hash table
Result:
- Re-hash
all keys in
the full bucket "1" into
buckets "01" and "11"
using 2 bits (because i' = 1) in
RandomNum:
- Adjust
the Bucket[01]
and Bucket[11]:
- Insert the
key
again ---
now using
i = 2:
Result:
- Initial State:
- Example continued:
Insert a record
X
such that:
h(X) = 0010:
- Initial State:
- Inserting a record
X
such that:
h(X) = 0010:
Result:
Note:
- Hash values
ending in
xxxxxxx00 xxxxxxx10will both hash into the same physical hash bucket !!!
- That's because
both logical hash buckets
bucket[00] and
bucket[01] are
mapped to the
same physical hash bucket
!!!
- Initial State:
- Example continued:
Insert a record
X
such that:
h(X) = 0000:
- Initial State:
- Inserting a record
X
such that:
h(X) = 0000:
- Because:
i > i'
- We do not need to double the logical hash table !!!
-
Re-hash
all keys in
the full bucket "0" into
buckets "00" and "01"
using 2 bits (because i' = 1) in
RandomNum:
Adjust the Bucket[ ]:
- Insert again using the
new configuration:
Result:
- Initial State:
- The delete algorithm is
the same as
the standard
delete algorithm
for hashing
- We do not
consolidate
buckets in
deletion
(Because the ossicilation problem can cause severe performance degradation in Extensible Hashing)
- We do not
consolidate
buckets in
deletion
- Instead of
consolidating:
- Periodically perform rehashing on all search keys in the Extensible Hash Table
- Advantage:
- Always access 1 hash table block to lookup a record
- Problem:
- The size of the
hash table
will double each time
when we extend the table.
- Exponential rate of increase....
Better solution:
- Increase the
hash table size
linearly !!!
- Linear hashing !!! (discussed next)
- The size of the
hash table
will double each time
when we extend the table.