Allocate RS Control Blocks for Balanced as virtual memory

Currently, all Control Blocks (kind of a header structure) for
Remembered Set Buffers, for all possible regions, are allocated upfront
with one big malloc. This is suboptimal from footprint perspective.
Also, in extreme cases with very large heaps the allocation may not even
succeed.

We will now allocate that space as Virtual Memory which will be lazily
committed as needed (as regions are first time used and their RSCL is
first time initialized).

RS Buffers themselves are already allocated incrementally/gradually, as
regions are first time used, although still malloced. In future, we may
want to allocate them as virtual memory too, but currently that is less
important (relative to Control Blocks) due to their incremental
allocation.

Signed-off-by: Aleksandar Micic <Aleksandar_Micic@ca.ibm.com>

Author: Aleksandar Micic

runtime/gc_vlhgc/InterRegionRememberedSet.cpp

@@ -47,6 +47,7 @@
 
 MM_InterRegionRememberedSet::MM_InterRegionRememberedSet(MM_HeapRegionManager *heapRegionManager)
 	: _heapRegionManager(heapRegionManager)
+	, _rsclBufferControlBlockPoolMemoryHandle()
 	, _rsclBufferControlBlockPool(NULL)
 	, _rsclBufferControlBlockHead(NULL)
 	, _freeBufferCount(0)
@@ -239,7 +240,7 @@ MM_InterRegionRememberedSet::allocateRegionBuffers(MM_EnvironmentVLHGC* env, MM_
 }
 
 bool
-MM_InterRegionRememberedSet::initialize(MM_EnvironmentVLHGC* env)
+MM_InterRegionRememberedSet::initialize(MM_EnvironmentVLHGC *env)
 {
 	MM_GCExtensions *ext = MM_GCExtensions::getExtensions(env);
 
@@ -255,8 +256,17 @@ MM_InterRegionRememberedSet::initialize(MM_EnvironmentVLHGC* env)
 	UDATA bufferSize = MM_RememberedSetCardBucket::MAX_BUFFER_SIZE * cardSize;
 	Assert_MM_true(((UDATA)1 << MM_Bits::leadingZeroes(bufferSize)) == bufferSize);
 
-	/* All Buffer Control Block are pre-allocated on startup. Buffers themselves are allocated as regions are commited */
-	_rsclBufferControlBlockPool = (MM_CardBufferControlBlock *)ext->getForge()->allocate(rsclBufferControlBlockPoolSize, MM_AllocationCategory::REMEMBERED_SET, J9_GET_CALLSITE());
+	/* All Buffer Control Block are pre-allocated on startup, based on maximum heap size. Buffers themselves are allocated as regions are used first time.
+	 * Since Control Blocks consume considerable amount of memory, they are allocated as virtual memory,
+	 * so they can be lazily committed as regions are effectively used (when their RSCL is first time initialized). */
+	MM_MemoryManager *memoryManager = ext->memoryManager;
+	if (memoryManager->createVirtualMemoryForMetadata(env, &_rsclBufferControlBlockPoolMemoryHandle, ext->heapAlignment, rsclBufferControlBlockPoolSize)) {
+		_rsclBufferControlBlockPool = (MM_CardBufferControlBlock *)memoryManager->getHeapBase(&_rsclBufferControlBlockPoolMemoryHandle);
+		if (!memoryManager->commitMemory(&_rsclBufferControlBlockPoolMemoryHandle, _rsclBufferControlBlockPool, rsclBufferControlBlockPoolSize)) {
+			_rsclBufferControlBlockPool = NULL;
+		}
+	}
+
 	if (NULL == _rsclBufferControlBlockPool) {
 		return false;
 	}
@@ -468,15 +478,15 @@ MM_InterRegionRememberedSet::releaseCardBufferControlBlockLocalPools(MM_Environm
 
 
 void
-MM_InterRegionRememberedSet::tearDown(MM_EnvironmentBase* env)
+MM_InterRegionRememberedSet::tearDown(MM_EnvironmentBase *env)
 {
 	MM_GCExtensions *ext = MM_GCExtensions::getExtensions(env);
 
 	if (NULL != _rsclBufferControlBlockPool) {
-		ext->getForge()->free(_rsclBufferControlBlockPool);
+		ext->memoryManager->destroyVirtualMemory(env, &_rsclBufferControlBlockPoolMemoryHandle);
+		_rsclBufferControlBlockPool = NULL;
 	}
 
-	/* TODO: _lock initialize might have failed */
 	_lock.tearDown();
 }
 

runtime/gc_vlhgc/InterRegionRememberedSet.hpp

@@ -57,6 +57,8 @@ class MM_InterRegionRememberedSet : public MM_BaseVirtual
 public:
 	MM_HeapRegionManager *_heapRegionManager;				/**< cached pointer to heap region manager */
 
+	MM_MemoryHandle _rsclBufferControlBlockPoolMemoryHandle;	/**< memory handle for Control Blocks (but not Buffers) backing store */
+
 	MM_CardBufferControlBlock *_rsclBufferControlBlockPool; /**< starting address of the global pool of control blocks (kept around to be able to release memory at the end) */
 	MM_CardBufferControlBlock * volatile _rsclBufferControlBlockHead; /**< current head of BufferControlBlock global pool list */
 	volatile UDATA _freeBufferCount;							/**< current count of Buffers in the global free pool */
@@ -69,7 +71,7 @@ class MM_InterRegionRememberedSet : public MM_BaseVirtual
 
 	UDATA _regionSize;  			/**< Cached region size */
 
-	bool _shouldFlushBuffersForDecommitedRegions;			/**< set to true at the end of a GC, if contraction occured. this is a signal for the next GC to perform flush buffers from regions contracted */
+	bool _shouldFlushBuffersForDecommitedRegions;			/**< set to true at the end of a GC, if contraction occurred. this is a signal for the next GC to perform flush buffers from regions contracted */
 
 	volatile UDATA _overflowedRegionCount;					/**< count of regions overflowed as full */
 	UDATA _stableRegionCount;								/**< count of regions overflowed as stable */