Skip to content

Commit 089ad39

Browse files
LinHu2016LinHu2016
committed
Update
Signed-off-by: lhu <linhu@ca.ibm.com>
1 parent 60f410f commit 089ad39

9 files changed

+334
-115
lines changed

‎runtime/gc_base/RootScanner.cpp

Lines changed: 29 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,10 @@
6060
#include "ParallelDispatcher.hpp"
6161
#include "PointerArrayIterator.hpp"
6262
#include "SlotObject.hpp"
63+
#if defined(J9VM_GC_SPARSE_HEAP_ALLOCATION)
64+
#include "SparseVirtualMemory.hpp"
65+
#include "SparseAddressOrderedFixedSizeDataPool.hpp"
66+
#endif /* defined(J9VM_GC_SPARSE_HEAP_ALLOCATION) */
6367
#include "StringTable.hpp"
6468
#include "StringTableIncrementalIterator.hpp"
6569
#include "Task.hpp"
@@ -944,15 +948,32 @@ void
944948
MM_RootScanner::scanObjectsInVirtualLargeObjectHeap(MM_EnvironmentBase *env)
945949
{
946950
if (_singleThread || J9MODRON_HANDLE_NEXT_WORK_UNIT(env)) {
947-
GC_HeapRegionIteratorVLHGC regionIterator(_extensions->heap->getHeapRegionManager());
948-
MM_HeapRegionDescriptorVLHGC *region = NULL;
951+
PORT_ACCESS_FROM_ENVIRONMENT(env);
952+
j9tty_printf(PORTLIB, "scanObjectsInVirtualLargeObjectHeap _singleThread=%zu, env=%p\n", _singleThread, env);
949953
reportScanningStarted(RootScannerEntity_virtualLargeObjectHeapObjects);
950-
while (NULL != (region = regionIterator.nextRegion())) {
951-
if (region->isArrayletLeaf()) {
952-
if (region->_sparseHeapAllocation) {
953-
J9Object *spineObject = (J9Object *)region->_allocateData.getSpine();
954-
Assert_MM_true(NULL != spineObject);
955-
doObjectInVirtualLargeObjectHeap(spineObject, &region->_sparseHeapAllocation);
954+
if (_extensions->isVirtualLargeObjectHeapEnabled) {
955+
MM_SparseVirtualMemory *largeObjectVirtualMemory = _extensions->largeObjectVirtualMemory;
956+
J9HashTableState walkState;
957+
958+
MM_SparseDataTableEntry *sparseDataEntry = (MM_SparseDataTableEntry *)hashTableStartDo(largeObjectVirtualMemory->getSparseDataPool()->getObjectToSparseDataTable(), &walkState);
959+
j9tty_printf(PORTLIB, "hashTableStartDo sparseDataEntry=%p, env=%p\n", sparseDataEntry, env);
960+
while (NULL != sparseDataEntry) {
961+
J9Object *spineObject = (J9Object *)sparseDataEntry->_proxyObjPtr;
962+
Assert_MM_true(NULL != spineObject);
963+
doObjectInVirtualLargeObjectHeap(spineObject, NULL);
964+
j9tty_printf(PORTLIB, "hashTableNextDo &walkState=%p, spineObject=%p, size=%zu, env=%p\n", &walkState, spineObject, )sparseDataEntry->_size, env);
965+
sparseDataEntry = (MM_SparseDataTableEntry *)hashTableNextDo(&walkState);
966+
}
967+
} else {
968+
GC_HeapRegionIteratorVLHGC regionIterator(_extensions->heap->getHeapRegionManager());
969+
MM_HeapRegionDescriptorVLHGC *region = NULL;
970+
while (NULL != (region = regionIterator.nextRegion())) {
971+
if (region->isArrayletLeaf()) {
972+
if (region->_sparseHeapAllocation) {
973+
J9Object *spineObject = (J9Object *)region->_allocateData.getSpine();
974+
Assert_MM_true(NULL != spineObject);
975+
doObjectInVirtualLargeObjectHeap(spineObject, &region->_sparseHeapAllocation);
976+
}
956977
}
957978
}
958979
}

‎runtime/gc_vlhgc/CollectionSetDelegate.cpp

Lines changed: 73 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,6 +48,10 @@
4848
#include "MarkMap.hpp"
4949
#include "MemoryPool.hpp"
5050
#include "RegionValidator.hpp"
51+
#if defined(J9VM_GC_SPARSE_HEAP_ALLOCATION)
52+
#include "SparseVirtualMemory.hpp"
53+
#include "SparseAddressOrderedFixedSizeDataPool.hpp"
54+
#endif /* defined(J9VM_GC_SPARSE_HEAP_ALLOCATION) */
5155

5256
MM_CollectionSetDelegate::MM_CollectionSetDelegate(MM_EnvironmentBase *env, MM_HeapRegionManager *manager)
5357
: MM_BaseNonVirtual()
@@ -539,7 +543,7 @@ MM_CollectionSetDelegate::rateOfReturnCalculationBeforeSweep(MM_EnvironmentVLHGC
539543
if(!region->getRememberedSetCardList()->isAccurate()) {
540544
stats->_reclaimStats._regionCountOverflow += 1;
541545
}
542-
} else if(region->isArrayletLeaf()) {
546+
} else if(region->isArrayletLeaf() && !_extensions->isVirtualLargeObjectHeapEnabled) {
543547
MM_HeapRegionDescriptorVLHGC *parentRegion = (MM_HeapRegionDescriptorVLHGC *)_regionManager->regionDescriptorForAddress((void *)region->_allocateData.getSpine());
544548
Assert_MM_true(parentRegion->containsObjects());
545549
SetSelectionData *stats = &_setSelectionDataTable[MM_CompactGroupManager::getCompactGroupNumber(env, parentRegion)];
@@ -556,6 +560,41 @@ MM_CollectionSetDelegate::rateOfReturnCalculationBeforeSweep(MM_EnvironmentVLHGC
556560
}
557561
}
558562
}
563+
564+
#if defined(J9VM_GC_SPARSE_HEAP_ALLOCATION)
565+
if (_extensions->isVirtualLargeObjectHeapEnabled) {
566+
const uintptr_t arrayletLeafSize = env->getOmrVM()->_arrayletLeafSize;
567+
MM_SparseVirtualMemory *largeObjectVirtualMemory = _extensions->largeObjectVirtualMemory;
568+
uintptr_t arrayletLeafCount = 0;
569+
J9HashTableState walkState;
570+
571+
MM_SparseDataTableEntry *sparseDataEntry = (MM_SparseDataTableEntry *)hashTableStartDo(largeObjectVirtualMemory->getSparseDataPool()->getObjectToSparseDataTable(), &walkState);
572+
while (NULL != sparseDataEntry) {
573+
J9Object *spineObject = (J9Object *)sparseDataEntry->_proxyObjPtr;
574+
uintptr_t dataSize = sparseDataEntry->_size;
575+
/* TODO: how fraction is counting here? */
576+
// arrayletLeafCount = MM_Math::roundToFloor(arrayletLeafSize, dataSize) / arrayletLeafSize;
577+
arrayletLeafCount = MM_Math::roundToCeiling(arrayletLeafSize, dataSize) / arrayletLeafSize;
578+
MM_HeapRegionDescriptorVLHGC *parentRegion = (MM_HeapRegionDescriptorVLHGC *)_regionManager->regionDescriptorForAddress((void *)spineObject);
579+
Assert_MM_true(parentRegion->containsObjects());
580+
SetSelectionData *stats = &_setSelectionDataTable[MM_CompactGroupManager::getCompactGroupNumber(env, parentRegion)];
581+
582+
stats->_reclaimStats._regionCountBefore += arrayletLeafCount;
583+
stats->_reclaimStats._regionCountArrayletLeafBefore += arrayletLeafCount;
584+
585+
if(!parentRegion->_sweepData._alreadySwept) {
586+
stats->_reclaimStats._reclaimableRegionCountBefore += arrayletLeafCount;
587+
stats->_reclaimStats._reclaimableRegionCountArrayletLeafBefore += arrayletLeafCount;
588+
}
589+
if(!parentRegion->getRememberedSetCardList()->isAccurate()) {
590+
stats->_reclaimStats._regionCountArrayletLeafOverflow += arrayletLeafCount;
591+
}
592+
593+
sparseDataEntry = (MM_SparseDataTableEntry *)hashTableNextDo(&walkState);
594+
}
595+
596+
}
597+
#endif /* defined(J9VM_GC_SPARSE_HEAP_ALLOCATION) */
559598
}
560599
}
561600

@@ -580,7 +619,7 @@ MM_CollectionSetDelegate::rateOfReturnCalculationAfterSweep(MM_EnvironmentVLHGC
580619
stats->_reclaimStats._regionBytesFreeAfter += memoryPool->getActualFreeMemorySize();
581620
stats->_reclaimStats._regionDarkMatterAfter += memoryPool->getDarkMatterBytes();
582621
}
583-
} else if(region->isArrayletLeaf()) {
622+
} else if(region->isArrayletLeaf() && !_extensions->isVirtualLargeObjectHeapEnabled) {
584623
MM_HeapRegionDescriptorVLHGC *parentRegion = (MM_HeapRegionDescriptorVLHGC *)_regionManager->regionDescriptorForAddress((void *)region->_allocateData.getSpine());
585624
Assert_MM_true(parentRegion->containsObjects());
586625
SetSelectionData *stats = &_setSelectionDataTable[MM_CompactGroupManager::getCompactGroupNumber(env, parentRegion)];
@@ -595,6 +634,38 @@ MM_CollectionSetDelegate::rateOfReturnCalculationAfterSweep(MM_EnvironmentVLHGC
595634
}
596635
}
597636

637+
#if defined(J9VM_GC_SPARSE_HEAP_ALLOCATION)
638+
if (_extensions->isVirtualLargeObjectHeapEnabled) {
639+
const uintptr_t arrayletLeafSize = env->getOmrVM()->_arrayletLeafSize;
640+
MM_SparseVirtualMemory *largeObjectVirtualMemory = _extensions->largeObjectVirtualMemory;
641+
uintptr_t arrayletLeafCount = 0;
642+
J9HashTableState walkState;
643+
644+
MM_SparseDataTableEntry *sparseDataEntry = (MM_SparseDataTableEntry *)hashTableStartDo(largeObjectVirtualMemory->getSparseDataPool()->getObjectToSparseDataTable(), &walkState);
645+
while (NULL != sparseDataEntry) {
646+
J9Object *spineObject = (J9Object *)sparseDataEntry->_proxyObjPtr;
647+
uintptr_t dataSize = sparseDataEntry->_size;
648+
/* TODO: how fraction is counting here? */
649+
// arrayletLeafCount = MM_Math::roundToFloor(arrayletLeafSize, dataSize) / arrayletLeafSize;
650+
arrayletLeafCount = MM_Math::roundToCeiling(arrayletLeafSize, dataSize) / arrayletLeafSize;
651+
MM_HeapRegionDescriptorVLHGC *parentRegion = (MM_HeapRegionDescriptorVLHGC *)_regionManager->regionDescriptorForAddress((void *)spineObject);
652+
Assert_MM_true(parentRegion->containsObjects());
653+
SetSelectionData *stats = &_setSelectionDataTable[MM_CompactGroupManager::getCompactGroupNumber(env, parentRegion)];
654+
655+
stats->_reclaimStats._regionCountAfter += arrayletLeafCount;
656+
stats->_reclaimStats._regionCountArrayletLeafAfter += arrayletLeafCount;
657+
658+
if(!parentRegion->_sweepData._alreadySwept) {
659+
stats->_reclaimStats._reclaimableRegionCountAfter += arrayletLeafCount;
660+
stats->_reclaimStats._reclaimableRegionCountArrayletLeafAfter += arrayletLeafCount;
661+
}
662+
663+
sparseDataEntry = (MM_SparseDataTableEntry *)hashTableNextDo(&walkState);
664+
}
665+
666+
}
667+
#endif /* defined(J9VM_GC_SPARSE_HEAP_ALLOCATION) */
668+
598669
/* We now have an expected change as a result of tracing and sweeping (parts of) the heap. Calculate the rate-of-return (ROR) on
599670
* tracing for age groups where work was done.
600671
* Use a weighted running average to calculate the ROR, where the weight is the % of regions in an age group that we are examining.

‎runtime/gc_vlhgc/CopyForwardScheme.cpp

Lines changed: 48 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -305,7 +305,7 @@ MM_CopyForwardScheme::initialize(MM_EnvironmentVLHGC *env)
305305
_maxCacheSize = _extensions->scavengerScanCacheMaximumSize;
306306

307307
/* Cached pointer to the inter region remembered set */
308-
_interRegionRememberedSet = MM_GCExtensions::getExtensions(env)->interRegionRememberedSet;
308+
_interRegionRememberedSet = _extensions->interRegionRememberedSet;
309309

310310
_cacheLineAlignment = CACHE_LINE_SIZE;
311311

@@ -412,7 +412,7 @@ MM_CopyForwardScheme::raiseAbortFlag(MM_EnvironmentVLHGC *env)
412412

413413
Trc_MM_CopyForwardScheme_abortFlagRaised(env->getLanguageVMThread());
414414
PORT_ACCESS_FROM_ENVIRONMENT(env);
415-
TRIGGER_J9HOOK_MM_PRIVATE_COPY_FORWARD_ABORT(MM_GCExtensions::getExtensions(env)->privateHookInterface, env->getOmrVMThread(), j9time_hires_clock(), J9HOOK_MM_PRIVATE_COPY_FORWARD_ABORT);
415+
TRIGGER_J9HOOK_MM_PRIVATE_COPY_FORWARD_ABORT(_extensions->privateHookInterface, env->getOmrVMThread(), j9time_hires_clock(), J9HOOK_MM_PRIVATE_COPY_FORWARD_ABORT);
416416
}
417417
}
418418
}
@@ -434,9 +434,9 @@ MM_CopyForwardScheme::updateLeafRegions(MM_EnvironmentVLHGC *env)
434434
GC_HeapRegionIteratorVLHGC regionIterator(_regionManager);
435435
MM_HeapRegionDescriptorVLHGC *region = NULL;
436436

437-
if (MM_GCExtensions::getExtensions(env)->isVirtualLargeObjectHeapEnabled) {
437+
if (_extensions->isVirtualLargeObjectHeapEnabled) {
438438
const uintptr_t arrayletLeafSize = env->getOmrVM()->_arrayletLeafSize;
439-
MM_SparseVirtualMemory *largeObjectVirtualMemory = MM_GCExtensions::getExtensions(env)->largeObjectVirtualMemory;
439+
MM_SparseVirtualMemory *largeObjectVirtualMemory = _extensions->largeObjectVirtualMemory;
440440
uintptr_t arrayletLeafCount = 0;
441441
J9HashTableState walkState;
442442

@@ -3944,7 +3944,7 @@ class MM_CopyForwardSchemeRootScanner : public MM_RootScanner
39443944
}
39453945
} else {
39463946
/* double check that there really was no work to do */
3947-
Assert_MM_true(!MM_GCExtensions::getExtensions(env)->finalizeListManager->isFinalizableObjectProcessingRequired());
3947+
Assert_MM_true(!_extensions->finalizeListManager->isFinalizableObjectProcessingRequired());
39483948
}
39493949
reportScanningEnded(RootScannerEntity_FinalizableObjects);
39503950
}
@@ -4172,7 +4172,9 @@ class MM_CopyForwardSchemeRootClearer : public MM_RootScanner
41724172
env->_copyForwardStats._offHeapRegionsCleared += 1;
41734173
void *dataAddr = _extensions->indexableObjectModel.getDataAddrForContiguous((J9IndexableObject *)objectPtr);
41744174
_extensions->largeObjectVirtualMemory->freeSparseRegionAndUnmapFromHeapObject(_env, dataAddr, objectPtr, _extensions->indexableObjectModel.getDataSizeInBytes((J9IndexableObject *)objectPtr));
4175-
*sparseHeapAllocation = false;
4175+
if (NULL != sparseHeapAllocation) {
4176+
*sparseHeapAllocation = false;
4177+
}
41764178
} else {
41774179
void *dataAddr = _extensions->indexableObjectModel.getDataAddrForContiguous((J9IndexableObject *)fwdOjectPtr);
41784180
if (NULL != dataAddr) {
@@ -4755,17 +4757,19 @@ MM_CopyForwardScheme::verifyCopyForwardResult(MM_EnvironmentVLHGC *env)
47554757

47564758
while (NULL != (region = regionIterator.nextRegion())) {
47574759
if (region->isArrayletLeaf()) {
4758-
J9Object *spineObject = (J9Object *)region->_allocateData.getSpine();
4759-
Assert_MM_true(NULL != spineObject);
4760-
/* the spine must be marked if it was copied as a live object or if we aborted the copy-forward */
4761-
/* otherwise, it must not be forwarded (since that would imply that the spine survived but the pointer wasn't updated) */
4762-
if (!_markMap->isBitSet(spineObject)) {
4763-
MM_ForwardedHeader forwardedSpine(spineObject, _extensions->compressObjectReferences());
4764-
if (forwardedSpine.isForwardedPointer()) {
4765-
PORT_ACCESS_FROM_ENVIRONMENT(env);
4766-
j9tty_printf(PORTLIB, "Spine pointer is not marked and is forwarded (leaf region's pointer to spine not updated)! Region %p Spine %p (should be %p)\n", region, spineObject, forwardedSpine.getForwardedObject());
4767-
verifyDumpObjectDetails(env, "spineObject", spineObject);
4768-
Assert_MM_unreachable();
4760+
if (!_extensions->isVirtualLargeObjectHeapEnabled) {
4761+
J9Object *spineObject = (J9Object *)region->_allocateData.getSpine();
4762+
Assert_MM_true(NULL != spineObject);
4763+
/* the spine must be marked if it was copied as a live object or if we aborted the copy-forward */
4764+
/* otherwise, it must not be forwarded (since that would imply that the spine survived but the pointer wasn't updated) */
4765+
if (!_markMap->isBitSet(spineObject)) {
4766+
MM_ForwardedHeader forwardedSpine(spineObject, _extensions->compressObjectReferences());
4767+
if (forwardedSpine.isForwardedPointer()) {
4768+
PORT_ACCESS_FROM_ENVIRONMENT(env);
4769+
j9tty_printf(PORTLIB, "Spine pointer is not marked and is forwarded (leaf region's pointer to spine not updated)! Region %p Spine %p (should be %p)\n", region, spineObject, forwardedSpine.getForwardedObject());
4770+
verifyDumpObjectDetails(env, "spineObject", spineObject);
4771+
Assert_MM_unreachable();
4772+
}
47694773
}
47704774
}
47714775
} else {
@@ -4793,6 +4797,32 @@ MM_CopyForwardScheme::verifyCopyForwardResult(MM_EnvironmentVLHGC *env)
47934797
}
47944798
}
47954799

4800+
#if defined(J9VM_GC_SPARSE_HEAP_ALLOCATION)
4801+
if (_extensions->isVirtualLargeObjectHeapEnabled) {
4802+
MM_SparseVirtualMemory *largeObjectVirtualMemory = _extensions->largeObjectVirtualMemory;
4803+
J9HashTableState walkState;
4804+
4805+
MM_SparseDataTableEntry *sparseDataEntry = (MM_SparseDataTableEntry *)hashTableStartDo(largeObjectVirtualMemory->getSparseDataPool()->getObjectToSparseDataTable(), &walkState);
4806+
while (NULL != sparseDataEntry) {
4807+
J9Object *spineObject = (J9Object *)sparseDataEntry->_proxyObjPtr;
4808+
Assert_MM_true(NULL != spineObject);
4809+
/* the spine must be marked if it was copied as a live object or if we aborted the copy-forward */
4810+
/* otherwise, it must not be forwarded (since that would imply that the spine survived but the pointer wasn't updated) */
4811+
if (!_markMap->isBitSet(spineObject)) {
4812+
MM_ForwardedHeader forwardedSpine(spineObject, _extensions->compressObjectReferences());
4813+
if (forwardedSpine.isForwardedPointer()) {
4814+
PORT_ACCESS_FROM_ENVIRONMENT(env);
4815+
j9tty_printf(PORTLIB, "Spine pointer is not marked and is forwarded (leaf region's pointer to spine not updated)! Region %p Spine %p (should be %p)\n", region, spineObject, forwardedSpine.getForwardedObject());
4816+
verifyDumpObjectDetails(env, "spineObject", spineObject);
4817+
Assert_MM_unreachable();
4818+
}
4819+
}
4820+
4821+
sparseDataEntry = (MM_SparseDataTableEntry *)hashTableNextDo(&walkState);
4822+
}
4823+
}
4824+
#endif /* defined(J9VM_GC_SPARSE_HEAP_ALLOCATION) */
4825+
47964826
MM_CopyForwardVerifyScanner scanner(env, this);
47974827
scanner.scanAllSlots(env);
47984828

@@ -5209,7 +5239,7 @@ MM_CopyForwardScheme:: cleanOverflowInRange(MM_EnvironmentVLHGC *env, uintptr_t
52095239
{
52105240
/* At this point, no copying should happen, so that reservingContext is irrelevant */
52115241
MM_AllocationContextTarok *reservingContext = _commonContext;
5212-
MM_HeapMapIterator objectIterator = MM_HeapMapIterator(MM_GCExtensions::getExtensions(env), env->_cycleState->_markMap, lowAddress, highAddress);
5242+
MM_HeapMapIterator objectIterator = MM_HeapMapIterator(_extensions, env->_cycleState->_markMap, lowAddress, highAddress);
52135243

52145244
J9Object *object = NULL;
52155245
while (NULL != (object = objectIterator.nextObject())) {

‎runtime/gc_vlhgc/GlobalMarkingScheme.cpp

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1421,7 +1421,9 @@ class MM_GlobalMarkingSchemeRootClearer : public MM_RootScanner
14211421
if (NULL != dataAddr) {
14221422
_extensions->largeObjectVirtualMemory->freeSparseRegionAndUnmapFromHeapObject(_env, dataAddr, objectPtr, _extensions->indexableObjectModel.getDataSizeInBytes((J9IndexableObject *)objectPtr));
14231423

1424-
*sparseHeapAllocation = false;
1424+
if (NULL != sparseHeapAllocation) {
1425+
*sparseHeapAllocation = false;
1426+
}
14251427
}
14261428
}
14271429
}

‎runtime/gc_vlhgc/ParallelSweepSchemeVLHGC.cpp

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -59,8 +59,10 @@
5959
#include "SparseVirtualMemory.hpp"
6060
#include "SparseAddressOrderedFixedSizeDataPool.hpp"
6161
#include "SweepHeapSectioningVLHGC.hpp"
62+
#if defined(J9VM_GC_SPARSE_HEAP_ALLOCATION)
6263
#include "SweepPoolManagerVLHGC.hpp"
6364
#include "SweepPoolManagerAddressOrderedList.hpp"
65+
#endif /* defined(J9VM_GC_SPARSE_HEAP_ALLOCATION) */
6466
#include "SweepPoolState.hpp"
6567

6668

@@ -1008,9 +1010,10 @@ MM_ParallelSweepSchemeVLHGC::recycleFreeRegions(MM_EnvironmentVLHGC *env)
10081010
GC_HeapRegionIteratorVLHGC regionIterator(_regionManager);
10091011
MM_HeapRegionDescriptorVLHGC *region = NULL;
10101012

1011-
if (MM_GCExtensions::getExtensions(env)->isVirtualLargeObjectHeapEnabled) {
1013+
#if defined(J9VM_GC_SPARSE_HEAP_ALLOCATION)
1014+
if (_extensions->isVirtualLargeObjectHeapEnabled) {
10121015
const uintptr_t arrayletLeafSize = env->getOmrVM()->_arrayletLeafSize;
1013-
MM_SparseVirtualMemory *largeObjectVirtualMemory = MM_GCExtensions::getExtensions(env)->largeObjectVirtualMemory;
1016+
MM_SparseVirtualMemory *largeObjectVirtualMemory = _extensions->largeObjectVirtualMemory;
10141017
uintptr_t arrayletLeafCount = 0;
10151018
J9HashTableState walkState;
10161019

@@ -1034,7 +1037,9 @@ MM_ParallelSweepSchemeVLHGC::recycleFreeRegions(MM_EnvironmentVLHGC *env)
10341037
}
10351038
Assert_MM_true(0 == arrayletLeafCount);
10361039

1037-
} else {
1040+
} else
1041+
#endif /* defined(J9VM_GC_SPARSE_HEAP_ALLOCATION) */
1042+
{
10381043
while(NULL != (region = regionIterator.nextRegion())) {
10391044
/* Region must be marked for sweep */
10401045
if (!region->_sweepData._alreadySwept && region->hasValidMarkMap()) {

0 commit comments

Comments
 (0)