## 3 Related Work  
Persistent memory, with its durability, byte-addressable nature, and access latency similar to DRAM, offers significant advantages for building applications that rely on extensive memory systems. However, the shift in memory architectures has rendered traditional data indexing methods inefficient in terms of data consistency [13]. To address this challenge, several existing studies have focused on enhancing tree-based indexing structures for persistent memory. These advancements aim to achieve reasonable lookup times and improved recovery capabilities [3; 11; 13; 17; 41]. With the increase in the size of in-memory data, the process of rehashing traditional hash tables introduces higher latency, necessitating the development of improved rehashing techniques tailored for persistent memory. To mitigate the overhead during rehashing, various techniques such as linear probing, separate chaining, Cuckoo hashing, CCEH [14], and Dash [18] have been employed. CCEH, a variant of extendible hashing, has been specifically designed to optimize the access of hash table buckets by enabling cache-line access, thereby minimizing the number of cache-line accesses. Additionally, CCEH reduces the overhead in directory operations by grouping a number of buckets into intermediate sizes known as segments. This approach helps to reduce the size of the directory to cache-line-sized buckets and also streamlines the rehashing management during failure recovery [42; 43; 44]. Extendible hashing was initially developed to address the needs of time-sensitive applications that utilize a trie for efficient bucket lookup. It employs a process called rehashing, which is an incremental hierarchical operation aimed at populating the hash table effectively. To achieve this, it is crucial to track the dynamic allocation of buckets and their corresponding pointers within the hash table. Several research efforts have been dedicated to enhancing the efficiency of rehashing schemes, given that time-sensitive applications are particularly susceptible to the impact of hash table rehashing compared to the growth of the tables themselves. The growth of the table size also significantly influences the performance of record lookups. Since extendible hashing employs a directory to index dynamically added or removed buckets during runtime, the process involves splitting existing buckets and creating new ones with reorganized values. This expansion of the directory is necessary to accommodate additional storage for pointers to the new buckets. Typically, this can be achieved linearly by organizing the buckets using directory entries that point to individual buckets. Designing an appropriate splitting and rehashing strategy tailored to different workloads is a fundamental approach to achieving optimal in-memory systems [45; 46]. Cuckoo-based hashing, as explored in [47], offers a way to reduce write operations to PCM (phase change memory) while maintaining higher memory efficiency. It achieves this by displacing randomly chosen records to alternative buckets [47]. The insertion of records into buckets is carried out using independent hash functions. However, it is important to note that the performance of this approach is still slower compared to linear probing and Cuckoo hashing [48; 49; 41]. To further improve the lookup cost, binary trees have been employed to achieve logarithmic scale efficiency [50]. Additionally, these binary trees have been divided into two-level hashes for enhanced performance [15]. The primary focus of many research studies is to reduce the cost associated with full-table rehashing and improve the load factor of hash tables. Some proposals have explored the idea of incorporating additional levels [47] to store records that are actively maintained in memory rather than being directly stored in the hash table. Another notable approach gaining popularity is the use of cache-line-level indexing with a failure atomic structure, as described in [14].