perf: Enhance Memory Management with Lock-Free Allocator, Preallocation, and Optimized Thread-Local Caching

[beats-dh]

Detailed Description for PR:

1. Introduction of Static Preallocation

preallocate Method: Added functionality to preallocate a fixed number of memory blocks (STATIC_PREALLOCATION_SIZE = 500) during the initialization of the LockfreePoolingAllocator. This minimizes runtime dynamic allocations, boosting overall system performance.

Thread-Safe Initialization: Ensured preallocation occurs only once using std::call_once combined with std::once_flag, guaranteeing thread-safe initialization.

2. Optimization of Thread-Local Cache

Efficient Caching Mechanism:

Introduced thread_local caches for each thread, significantly reducing contention for shared resources.

Configured the thread-local cache size to optimize memory usage while maintaining high throughput, with a default batch size of 128.

Prefetching for Performance: Implemented memory prefetching (PREFETCH) within caching logic to improve cache line utilization and reduce latency.

3. Enhancements to Allocation Process

Streaming Allocation Logic:

Allocations prioritize the thread-local cache for speed.

If the local cache is empty, memory is fetched in batches from the lock-free shared list. As a fallback, dynamic allocation ensures availability.

Dynamic Growth: The try_grow method dynamically expands capacity when approaching allocation limits, ensuring scalability.

4. Improvements to Deallocation

Balanced Deallocation Strategy:

Memory is first returned to the thread-local cache.

If the cache is full, excess memory is flushed back to the lock-free shared list, maintaining a balance between local and global resources.

False Sharing Prevention: Cache-line alignment and proper struct padding minimize false sharing, further optimizing deallocation.

5. Integration with Custom Memory Management

Polymorphic Allocators Support: Enabled integration with std::pmr::memory_resource for flexible custom memory management. This allows seamless use of LockfreeFreeList in modern memory resource-based systems.

Allocator Design: A custom LockfreePoolingAllocator was introduced to replace standard allocation mechanisms, offering finer control over memory operations.

---

Key Benefits of the New Implementation

1. Enhanced Performance in Multithreaded Environments

The lock-free design significantly reduces contention between threads. Thread-local caching ensures low-latency memory allocation and deallocation, critical for high-performance applications.

2. Precise Memory Management

The separation of allocation and deallocation logic between thread-local and global resources allows granular control over memory reuse, reducing fragmentation and improving predictability.

3. Dynamic Adaptability

The implementation scales dynamically with thread count and workload. Adjustments to preallocation size, batch size, and growth behavior ensure the system adapts to varying demands efficiently.

4. Flexibility for Future Extensions

This design provides a robust foundation for further enhancements. Future optimizations (e.g., adaptive batch sizes, priority-based allocation) can be easily incorporated without disrupting the core architecture.

---

Rationale for Replacing std::make_shared

1. Finer Control Over Memory

Unlike std::make_shared, which combines object and reference counter allocation, the new system separates and optimizes these processes. This is crucial for scenarios demanding thread-local caching and preallocation.

2. Thread-Specific Optimization

The use of thread-local caches ensures minimal contention and faster memory reuse, which std::make_shared cannot accommodate.

3. Improved Scalability

The lock-free shared list and dynamic growth capabilities enable efficient scaling in high-concurrency environments, outperforming the general-purpose design of std::make_shared.

4. Reduced Overhead

Granular memory management reduces memory fragmentation and overhead, offering predictable performance even under high load.

5. Customizability

The system supports advanced features such as prefetching, cache-line alignment, and integration with polymorphic memory resources, none of which are possible with std::make_shared.

---

In summary, this implementation introduces a high-performance, scalable memory management solution tailored for multithreaded environments. It replaces std::make_shared to offer greater flexibility, precision, and efficiency in memory allocation and deallocation.

[github-actions]

This PR is stale because it has been open 45 days with no activity.

[sonarqubecloud]

Quality Gate passed

Issues
5 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarCloud

[github-actions]

This PR is stale because it has been open 45 days with no activity.

[sonarqubecloud]

Quality Gate passed

Issues
4 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud