## 2 Background and Motivation
### Dynamic Hashing  
Hashing is a technique that has long been employed in memory-based data storage. Dynamic hashing, in particular, is commonly used to reduce the length of string characters. This scheme operates by dynamically adjusting, rearranging, and resizing the characters to align with the data access patterns, resulting in faster and more efficient data storage. There are various dynamic hashing schemes available that utilize in-place updates for read-modify-write operations. Additionally, some schemes incorporate optimized Cuckoo hashing techniques to minimize locking for smaller key-value stores [22; 23]. Moreover, there are similar schemes like Dash [18], which have also implemented linear hashing. However, it has been observed that excessive reads occur during end-to-end operations due to the requirement of a linear scan. As a result, in this paper, we have chosen a scheme that not only increases the hash table as the data size increases but also allows for dynamic modification of the hash function to accommodate the growth or shrinking of the  
Figure 1: Optane architecture: (**a**) overview of Optane DIMMs; and (**b**) Optane DIMMs interleaving strategies. records. Therefore, we have opted for an extendible hashing scheme that possesses this unique capability. **Extendible hashing**: This is a dynamic hashing technique that performs incremental rehashing operations, minimizing the impact of hash table growth on applications when compared to standard full-table rehashing. As the size of the in-memory data grows, rehashing traditional hash tables introduces higher latency, necessitating the utilization of improved rehashing techniques for persistent memory. Various methods, such as linear probing, separate chaining, Cuckoo hashing, CCEH [14], and Dash [18], are employed to mitigate the overhead during rehashing. CCEH, a variant of extendible hashing, is specifically designed to optimize the access of hash table buckets for cache-line access, significantly reducing the number of cache-line accesses required. Additionally, CCEH minimizes the overhead in directory operations by grouping a number of buckets into intermediate-sized segments. This approach reduces the size of the directory to cache-line-sized buckets and simplifies rehashing management during failure recovery. Extendible hashing is a dynamic hashing scheme that employs a directory, known as a bucket address table, to locate specific queries and retrieve records with a given key. The hashing function used in this scheme is adaptable and can be dynamically altered to effectively manage directories and buckets for data hashing. The records themselves are stored in buckets, and these buckets are pointed to by the global directory. The directory contains bits that determine the directory entry, represented in binary form, which then points to the respective buckets. Figure 2 illustrates the arrangement of directory entries and their connections to the buckets, where each bucket stores key-value pairs. In extendible hashing schemes, the maximum number of buckets is represented as \(2^{G}\), where G denotes the global depth. Lookup and update operations navigate through the hash table by following the corresponding directory entry pointer, leading to the desired buckets. Consequently, the hash table can accommodate a maximum of \(2^{G}\) directory entries, each pointing to a specific bucket. Additionally, buckets are tracked using the local depth (L), which aids in determining when a bucket becomes full and initiates actions such as bucket splitting or directory doubling. In the depicted scenario, as illustrated in Figure 2a, when a record (e.g., 63) is inserted into the hash table and the last bucket is already full, the process of directory doubling is triggered due to the local depth being equal to the global depth (L = G). In Figure 2b, the directory entry is doubled, resulting in an increase in the local depth of the overflowing bucket. Subsequently, the records are rehashed and inserted into the newly expanded hash table.