Assignment:
Please download the starter code from here (https://canvas.vt.edu/courses/185343/files/33260937?
wrap=1)
(https://canvas.vt.edu/courses/185343/files/33260937/download?download_frd=1) .
For your last project, you will write a memory management package for storing variable length records in a large memory space, and you will use a hash table to access the records by a simple key value. (The records will be a serialized version of the seminar information.) For background on memory managers, see Chapter 11 in OpenDSA
(https://canvas.vt.edu/courses/190133/modules/items/2703411) . Your memory manager will use the buddy method for allocating space from the memory pool, as described in Module 11.9.1.1
(https://canvas.vt.edu/courses/190133/modules/items/2703420) .
Your memory pool will consist of a large array of bytes. Initially, this array will be some power of two specified by a command line parameter. If a request comes to store a record that there is no room to store, then you will replace the current byte array with a new one that is twice as long, and copy all of the contents of the old byte array to the new one before attempting again to satisfy the request. (check the sample output file for a suitable message to print in this case). When a record is to be removed from the database, its associated block of bytes is given back to the freeblock list maintained by the memory manager. Be sure when a block is released to merge it with its buddy if the buddy is free, as shown in the Buddy Method visualization at OpenDSA. Potentially, this could cause a cascade of buddy merges.
Aside from the memory manager’s memory pool and freeblock list, the other major data structure for your project will be a closed hash table ( Module 10.6
(https://canvas.vt.edu/courses/190133/assignments/1965092?module_item_id=2703402) ) for storing an integer as the search key (this will be the ID field for the records being stored), and a memory manager handle as the data. For information on hash tables, see the chapter on Hashing in the OpenDSA textbook ( Chapter 10 (https://canvas.vt.edu/courses/190133/modules/items/2703392) ).
You will use double hashing as described in Module 10.7.4
(https://canvas.vt.edu/courses/190133/assignments/1965093?module_item_id=2703404) . In particular, you will use the approach shown in the second slideshow of that section. The hash table size will always be a power of two. When hashing key value k (the ID value) h ( k ) = k mod M which is simply the ID mod the table size, and h ( k ) = ((( k/M ) mod ( M/ 2)) ∗ 2) + 1. The key difference from what OpenDSA describes is that your hash tables must be extensible. That is, you will start with a hash table of a certain size (defined when the program starts). This must be a power of two,
or the program should immediately terminate with an error message. If the hash table exceeds 50% full, then you will replace the array with another that is twice the size, and rehash all of the records from the old array For example, say that the hash table has 32 slots. Inserting 16 records is OK. When you try to insert the 17th record, you would first re-hash all of the original 16 records
into a table of 64 slots.
The hash table will somehow need to distinguish each record’s key from the rest of that record’s value. Ideally, it is shielded from the fact that records are stored in a memory manager. One possible design is to store the key (one field of the record) and some sort of reference to the rest of the record, Another is to store the memory manager’s “Handle” to the data record. (A handle is the value returned by the memory manager when a request is made to insert a new record into the memory pool. This handle is used to recover the record.) Another design is to hide all of these implementation details behind a Record object (with key and data), and let the Hash system get its necessary information through the Record’s methods.
)
