Per-index Memfile Locking Contention (hashtag2626)

[vikramsubramanian]

After hashtag2615, we lock a shared in-memory file for string keys in the hash index. Though this works, it is likely (?) a point of contention when strings are long. As mentioned in [this comment]( one solution is to let each thread grab a page at a time. )

[mayil-ai[bot]]

We're not sure how to solve this one.

but here are some ideas that might help you get started -

Summary: Locking contention issue with shared in-memory file for string keys in the hash index.

Possible Solution

Based on the provided information and code snippets, the following solution can be implemented to address the contention issue with long strings in the shared in-memory file:

• Implement a more granular locking mechanism at the page level rather than locking the entire shared in-memory file. This can be done by introducing a mutex or a lock for each page within the InMemFile class.
• Modify the InMemFile::appendString method to acquire a lock on the specific page it intends to modify before performing any write operations. Ensure that the lock is released after the operation is completed.
• If the string to be appended spans multiple pages, acquire locks on all the pages that will be affected in the order of their page indices to avoid deadlocks.
• Update the InMemHashIndexUtils::insertFuncForString method to work with the new per-page locking mechanism. Ensure that the lock is acquired before calling InMemFile::appendString and released afterward.
• Optimize the hash index implementation to minimize the number of long string comparisons. This can be done by using a more efficient hash function or by storing a prefix of the string along with its full hash to quickly eliminate non-matching strings.
• Consider using a read-write lock (shared-exclusive lock) if the workload is read-heavy, allowing multiple readers to access the same page concurrently while still ensuring exclusive access for writers.
• Review and test the changes thoroughly to ensure that the new locking mechanism does not introduce deadlocks or significantly degrade performance for other operations.

By implementing these changes, each thread will be able to grab and lock only the pages it needs, reducing contention and potentially improving the performance of the system when dealing with long strings.

Code snippets to check

• src/include/storage/index/hash_index_utils.h

  This file contains the logic for inserting and checking equality of string keys in the hash index, which is related to the issue of locking contention for long strings.

• src/include/storage/storage_structure/in_mem_file.h

  This file defines the InMemFile class, which is used for storing string keys in memory and may be involved in the locking contention issue.

• src/storage/storage_structure/in_mem_file.cpp

  This file contains the implementation of the InMemFile class, including the appendString method, which is relevant to how strings are stored and could be part of the contention issue.