Skip to content

Commit ca152c6

Browse files
rwy7rwy7
committed
Remove J9VM_GC_HYBRID_ARRAYLETS
Signed-off-by: Robert Young <rwy0717@gmail.com>
1 parent f9f19a2 commit ca152c6

19 files changed

+20
-116
lines changed

‎buildspecs/combogc.feature

-1
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,6 @@
3838
<flag id="gc_fragmentedHeap" value="true"/>
3939
<flag id="gc_generational" value="true"/>
4040
<flag id="gc_heapCardTable" value="true"/>
41-
<flag id="gc_hybridArraylets" value="true"/>
4241
<flag id="gc_jniArrayCache" value="true"/>
4342
<flag id="gc_largeObjectArea" value="true"/>
4443
<flag id="gc_leafBits" value="true"/>

‎buildspecs/j9.flags

-8
Original file line numberDiff line numberDiff line change
@@ -330,7 +330,6 @@ Currently only available on linux_x86 and win_x96 32 bit builds.</description>
330330
<ifRemoved></ifRemoved>
331331
<requires>
332332
<require flag="gc_heapCardTable"/>
333-
<require flag="gc_hybridArraylets"/>
334333
<require flag="gc_modronStandard"/>
335334
<require flag="gc_realtime"/>
336335
</requires>
@@ -398,13 +397,6 @@ Currently only available on linux_x86 and win_x96 32 bit builds.</description>
398397
<require flag="gc_modronGC"/>
399398
</requires>
400399
</flag>
401-
<flag id="gc_hybridArraylets">
402-
<description>Arraylet header has bimodal shape in runtime, separate for contiguous and discontiguous arraylets </description>
403-
<ifRemoved>Arraylet header has only one shape (same for contiguous and discontiguous arraylets)</ifRemoved>
404-
<requires>
405-
<require flag="gc_arraylets"/>
406-
</requires>
407-
</flag>
408400
<flag id="gc_idleHeapManager">
409401
<description>Enable VM idle java heap management(decommit excess free java heap pages)</description>
410402
<ifRemoved>GC on VM idle not supported</ifRemoved>

‎runtime/cmake/caches/common.cmake

-1
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,6 @@ set(J9VM_GC_FINALIZATION ON CACHE BOOL "")
130130
set(J9VM_GC_FRAGMENTED_HEAP ON CACHE BOOL "")
131131
set(J9VM_GC_GENERATIONAL ON CACHE BOOL "")
132132
set(J9VM_GC_HEAP_CARD_TABLE ON CACHE BOOL "")
133-
set(J9VM_GC_HYBRID_ARRAYLETS ON CACHE BOOL "")
134133
set(J9VM_GC_INLINED_ALLOC_FIELDS ON CACHE BOOL "")
135134
set(J9VM_GC_JNI_ARRAY_CACHE ON CACHE BOOL "")
136135
set(J9VM_GC_LARGE_OBJECT_AREA ON CACHE BOOL "")

‎runtime/ddr/overrides-vm

-1
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,6 @@ fieldoverride.J9BuildFlags.J9VM_GC_COMPRESSED_POINTERS=gc_compressedPointers
4444
fieldoverride.J9BuildFlags.J9VM_GC_DYNAMIC_CLASS_UNLOADING=gc_dynamicClassUnloading
4545
fieldoverride.J9BuildFlags.J9VM_GC_FINALIZATION=gc_finalization
4646
fieldoverride.J9BuildFlags.J9VM_GC_GENERATIONAL=gc_generational
47-
fieldoverride.J9BuildFlags.J9VM_GC_HYBRID_ARRAYLETS=gc_hybridArraylets
4847
fieldoverride.J9BuildFlags.J9VM_GC_INLINED_ALLOC_FIELDS=gc_inlinedAllocFields
4948
fieldoverride.J9BuildFlags.J9VM_GC_LEAF_BITS=gc_leafBits
5049
fieldoverride.J9BuildFlags.J9VM_GC_MINIMUM_OBJECT_SIZE=gc_minimumObjectSize

‎runtime/gc_base/GCExtensions.cpp

-5
Original file line numberDiff line numberDiff line change
@@ -89,13 +89,8 @@ MM_GCExtensions::initialize(MM_EnvironmentBase *env)
8989
}
9090

9191
#if defined(J9VM_GC_REALTIME)
92-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
9392
/* only ref slots, size in bytes: 2 * minObjectSize - header size */
9493
minArraySizeToSetAsScanned = 2 * (1 << J9VMGC_SIZECLASSES_LOG_SMALLEST) - sizeof(J9IndexableObjectContiguous);
95-
#else /* J9VM_GC_HYBRID_ARRAYLETS */
96-
/* only ref slots, size in bytes: 2 * minObjectSize - header size) - 1 * sizeof(arraylet pointer) */
97-
minArraySizeToSetAsScanned = 2 * (1 << J9VMGC_SIZECLASSES_LOG_SMALLEST) - sizeof(J9IndexableObjectDiscontiguous) - sizeof(fj9object_t*);
98-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
9994
#endif /* J9VM_GC_REALTIME */
10095

10196
#if defined(J9VM_GC_JNI_ARRAY_CACHE)

‎runtime/gc_base/IndexableObjectAllocationModel.cpp

-6
Original file line numberDiff line numberDiff line change
@@ -131,22 +131,16 @@ MM_IndexableObjectAllocationModel::initializeIndexableObject(MM_EnvironmentBase
131131
switch (_layout) {
132132
case GC_ArrayletObjectModel::InlineContiguous:
133133
Assert_MM_true(1 == _numberOfArraylets);
134-
if (NULL != spine) {
135-
/* Establish arraylet pointers */
136-
spine = layoutContiguousArraylet(env, spine);
137-
}
138134
break;
139135

140136
case GC_ArrayletObjectModel::Discontiguous:
141137
case GC_ArrayletObjectModel::Hybrid:
142138
if (NULL != spine) {
143-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
144139
if(0 == _numberOfIndexedFields) {
145140
/* Don't try to initialize the arrayoid for an empty NUA */
146141
Trc_MM_allocateAndConnectNonContiguousArraylet_Exit(env->getLanguageVMThread(), spine);
147142
break;
148143
}
149-
#endif /* defined(J9VM_GC_HYBRID_ARRAYLETS) */
150144
Trc_MM_allocateAndConnectNonContiguousArraylet_Summary(env->getLanguageVMThread(),
151145
_numberOfIndexedFields, getAllocateDescription()->getContiguousBytes(), _numberOfArraylets);
152146
spine = layoutDiscontiguousArraylet(env, spine);

‎runtime/gc_base/ObjectAccessBarrier.hpp

+1
Original file line numberDiff line numberDiff line change
@@ -200,6 +200,7 @@ class MM_ObjectAccessBarrier : public MM_BaseVirtual
200200
ARRAY_COPY_SUCCESSFUL = -1,
201201
ARRAY_COPY_NOT_DONE = -2
202202
};
203+
203204
virtual I_32 doCopyContiguousForward(J9VMThread *vmThread, J9IndexableObject *srcObject, J9IndexableObject *destObject, I_32 srcIndex, I_32 destIndex, I_32 lengthInSlots);
204205
virtual I_32 doCopyContiguousBackward(J9VMThread *vmThread, J9IndexableObject *srcObject, J9IndexableObject *destObject, I_32 srcIndex, I_32 destIndex, I_32 lengthInSlots);
205206
virtual I_32 backwardReferenceArrayCopyIndex(J9VMThread *vmThread, J9IndexableObject *srcObject, J9IndexableObject *destObject, I_32 srcIndex, I_32 destIndex, I_32 lengthInSlots) { return -2; }

‎runtime/gc_base/ScavengerForwardedHeader.hpp

-3
Original file line numberDiff line numberDiff line change
@@ -332,14 +332,11 @@ class MM_ScavengerForwardedHeader
332332
#else /* defined (OMR_GC_COMPRESSED_POINTERS) */
333333
U_32 size = ((J9IndexableObjectContiguous *)_objectPtr)->size;
334334
#endif /* defined (OMR_GC_COMPRESSED_POINTERS) */
335-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
336335
if (0 == size) {
337336
/* Discontiguous */
338337
size = ((J9IndexableObjectDiscontiguous *)_objectPtr)->size;
339338
}
340-
#endif
341339
return size;
342-
343340
}
344341

345342
MMINLINE I_32 computeObjectHash(J9VMThread* vmThread)

‎runtime/gc_glue_java/ArrayletObjectModel.cpp

-7
Original file line numberDiff line numberDiff line change
@@ -50,13 +50,8 @@ GC_ArrayletObjectModel::getArrayletLayout(J9Class* clazz, UDATA dataSizeInBytes,
5050
MM_GCExtensionsBase* extensions = MM_GCExtensionsBase::getExtensions(_omrVM);
5151
UDATA objectAlignmentInBytes = extensions->getObjectAlignmentInBytes();
5252

53-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
5453
/* the spine need not contain a pointer to the data */
5554
const UDATA minimumSpineSize = 0;
56-
#else
57-
/* the spine always contains a single pointer to the data */
58-
const UDATA minimumSpineSize = J9GC_REFERENCE_SIZE(this);
59-
#endif
6055
UDATA minimumSpineSizeAfterGrowing = minimumSpineSize;
6156
if (extensions->isVLHGC()) {
6257
/* CMVC 170688: Ensure that we don't try to allocate an inline contiguous array of a size which will overflow the region if it ever grows
@@ -69,12 +64,10 @@ GC_ArrayletObjectModel::getArrayletLayout(J9Class* clazz, UDATA dataSizeInBytes,
6964
/* CMVC 135307 : when checking for InlineContiguous layout, perform subtraction as adding to dataSizeInBytes could trigger overflow. */
7065
if ((largestDesirableSpine == UDATA_MAX) || (dataSizeInBytes <= (largestDesirableSpine - minimumSpineSizeAfterGrowing - contiguousHeaderSize()))) {
7166
layout = InlineContiguous;
72-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
7367
if(0 == dataSizeInBytes) {
7468
/* Zero sized NUA uses the discontiguous shape */
7569
layout = Discontiguous;
7670
}
77-
#endif /* defined(J9VM_GC_HYBRID_ARRAYLETS) */
7871
} else {
7972
UDATA arrayletLeafSize = _omrVM->_arrayletLeafSize;
8073
UDATA lastArrayletBytes = dataSizeInBytes & (arrayletLeafSize - 1);

‎runtime/gc_glue_java/ArrayletObjectModel.hpp

+1-28
Original file line numberDiff line numberDiff line change
@@ -192,12 +192,8 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
192192
MMINLINE bool
193193
hasArrayletLeafPointers(J9IndexableObject *objPtr)
194194
{
195-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
196195
/* Contiguous arraylet has no implicit leaf pointer */
197196
return !isInlineContiguousArraylet(objPtr);
198-
#else /* J9VM_GC_HYBRID_ARRAYLETS */
199-
return true;
200-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
201197
}
202198

203199

@@ -286,14 +282,10 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
286282
MMINLINE UDATA
287283
getHeaderSize(J9Class *clazzPtr, ArrayLayout layout)
288284
{
289-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
290285
UDATA headerSize = contiguousHeaderSize();
291286
if (layout != InlineContiguous) {
292287
headerSize = discontiguousHeaderSize();
293288
}
294-
#else
295-
UDATA headerSize = discontiguousHeaderSize();
296-
#endif
297289
return headerSize;
298290
}
299291

@@ -353,12 +345,10 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
353345
getArrayLayout(J9IndexableObject *objPtr)
354346
{
355347
GC_ArrayletObjectModel::ArrayLayout layout = GC_ArrayletObjectModel::InlineContiguous;
356-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
357348
/* Trivial check for InlineContiguous. */
358349
if (0 != getArraySize(objPtr)) {
359350
return GC_ArrayletObjectModel::InlineContiguous;
360351
}
361-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
362352

363353
/* Check if the objPtr is in the allowed arraylet range. */
364354
if (((UDATA)objPtr >= (UDATA)_arrayletRangeBase) && ((UDATA)objPtr < (UDATA)_arrayletRangeTop)) {
@@ -390,16 +380,13 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
390380
MMINLINE void
391381
memcpyArray(J9IndexableObject *destObject, J9IndexableObject *srcObject)
392382
{
393-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
394383
if (InlineContiguous == getArrayLayout(srcObject)) {
395384
/* assume that destObject must have the same shape! */
396385
UDATA sizeInBytes = getSizeInBytesWithoutHeader(srcObject);
397386
UDATA* srcData = (UDATA*)getDataPointerForContiguous(srcObject);
398387
UDATA* destData = (UDATA*)getDataPointerForContiguous(destObject);
399388
copyInWords(destData, srcData, sizeInBytes);
400-
} else
401-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
402-
{
389+
} else {
403390
UDATA arrayletCount = numArraylets(srcObject);
404391
fj9object_t *srcArraylets = getArrayoidPointer(srcObject);
405392
fj9object_t *destArraylets = getArrayoidPointer(destObject);
@@ -759,11 +746,9 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
759746
getSizeInBytesWithHeader(J9Class *clazz, UDATA numberOfElements)
760747
{
761748
ArrayLayout layout = InlineContiguous;
762-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
763749
if(0 == numberOfElements) {
764750
layout = Discontiguous;
765751
}
766-
#endif /* defined(J9VM_GC_HYBRID_ARRAYLETS) */
767752
return getSizeInBytesWithHeader(clazz, layout, numberOfElements);
768753
}
769754

@@ -800,7 +785,6 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
800785
MMINLINE UDATA
801786
getHeaderSize(J9IndexableObject *arrayPtr)
802787
{
803-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
804788
UDATA headerSize = 0;
805789
if (compressObjectReferences()) {
806790
UDATA size = ((J9IndexableObjectContiguousCompressed *)arrayPtr)->size;
@@ -815,9 +799,6 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
815799
headerSize = sizeof(J9IndexableObjectDiscontiguousFull);
816800
}
817801
}
818-
#else
819-
UDATA headerSize = discontiguousHeaderSize();
820-
#endif
821802
return headerSize;
822803
}
823804

@@ -840,13 +821,7 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
840821
MMINLINE void *
841822
getDataPointerForContiguous(J9IndexableObject *arrayPtr)
842823
{
843-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
844824
return (void *)((UDATA)arrayPtr + contiguousHeaderSize());
845-
#else /* J9VM_GC_HYBRID_ARRAYLETS */
846-
fj9object_t* arrayoidPointer = getArrayoidPointer(arrayPtr);
847-
fj9object_t firstArrayletLeaf = arrayoidPointer[0];
848-
return mmPointerFromToken((J9JavaVM*)_omrVM->_language_vm, firstArrayletLeaf);
849-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
850825
}
851826

852827

@@ -861,11 +836,9 @@ class GC_ArrayletObjectModel : public GC_ArrayletObjectModelBase
861836
getHashcodeOffset(J9Class *clazzPtr, UDATA numberOfElements)
862837
{
863838
ArrayLayout layout = InlineContiguous;
864-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
865839
if(0 == numberOfElements) {
866840
layout = Discontiguous;
867841
}
868-
#endif /* defined(J9VM_GC_HYBRID_ARRAYLETS) */
869842
return getHashcodeOffset(clazzPtr, layout, numberOfElements);
870843
}
871844

‎runtime/gc_glue_java/ArrayletObjectModelBase.cpp

-5
Original file line numberDiff line numberDiff line change
@@ -81,7 +81,6 @@ GC_ArrayletObjectModelBase::getSpineSizeWithoutHeader(ArrayLayout layout, UDATA
8181
* In hybrid specs, the spine may also include padding for a secondary size field in empty arrays
8282
*/
8383
UDATA const slotSize = J9GC_REFERENCE_SIZE(this);
84-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
8584
MM_GCExtensionsBase* extensions = MM_GCExtensionsBase::getExtensions(_omrVM);
8685
UDATA spineArrayoidSize = 0;
8786
UDATA spinePaddingSize = 0;
@@ -92,10 +91,6 @@ GC_ArrayletObjectModelBase::getSpineSizeWithoutHeader(ArrayLayout layout, UDATA
9291
spineArrayoidSize = numberArraylets * slotSize;
9392
}
9493
}
95-
#else
96-
UDATA spinePaddingSize = alignData ? slotSize : 0;
97-
UDATA spineArrayoidSize = numberArraylets * slotSize;
98-
#endif
9994
UDATA spineDataSize = 0;
10095
if (InlineContiguous == layout) {
10196
spineDataSize = dataSize; // All data in spine

‎runtime/gc_glue_java/ArrayletObjectModelBase.hpp

-4
Original file line numberDiff line numberDiff line change
@@ -107,20 +107,16 @@ class GC_ArrayletObjectModelBase
107107
UDATA size = 0;
108108
if (compressObjectReferences()) {
109109
size = ((J9IndexableObjectContiguousCompressed *)arrayPtr)->size;
110-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
111110
if (0 == size) {
112111
/* Discontiguous */
113112
size = ((J9IndexableObjectDiscontiguousCompressed *)arrayPtr)->size;
114113
}
115-
#endif /* defined(J9VM_GC_HYBRID_ARRAYLETS) */
116114
} else {
117115
size = ((J9IndexableObjectContiguousFull *)arrayPtr)->size;
118-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
119116
if (0 == size) {
120117
/* Discontiguous */
121118
size = ((J9IndexableObjectDiscontiguousFull *)arrayPtr)->size;
122119
}
123-
#endif /* defined(J9VM_GC_HYBRID_ARRAYLETS) */
124120
}
125121
return size;
126122
}

‎runtime/gc_glue_java/MetronomeDelegate.hpp

-4
Original file line numberDiff line numberDiff line change
@@ -347,15 +347,13 @@ class MM_MetronomeDelegate : public MM_BaseNonVirtual
347347
return pointerFields;
348348
}
349349

350-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
351350
/* if NUA is enabled, separate path for contiguous arrays */
352351
UDATA sizeInElements = _extensions->indexableObjectModel.getSizeInElements(objectPtr);
353352
if (isContiguous || (0 == sizeInElements)) {
354353
fj9object_t *startScanPtr = (fj9object_t *)_extensions->indexableObjectModel.getDataPointerForContiguous(objectPtr);
355354
fj9object_t *endScanPtr = startScanPtr + sizeInElements;
356355
pointerFields += scanPointerRange(env, startScanPtr, endScanPtr);
357356
} else {
358-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
359357
fj9object_t *arrayoid = _extensions->indexableObjectModel.getArrayoidPointer(objectPtr);
360358
UDATA numArraylets = _extensions->indexableObjectModel.numArraylets(objectPtr);
361359
for (UDATA i=0; i<numArraylets; i++) {
@@ -375,9 +373,7 @@ class MM_MetronomeDelegate : public MM_BaseNonVirtual
375373
}
376374
}
377375
}
378-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
379376
}
380-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
381377

382378
/* check for yield if we've actually scanned a leaf */
383379
if (0 != pointerFields) {

‎runtime/gc_glue_java/ObjectModel.hpp

-2
Original file line numberDiff line numberDiff line change
@@ -607,7 +607,6 @@ class GC_ObjectModel : public GC_ObjectModelBase
607607
getPreservedArrayLayout(MM_ForwardedHeader *forwardedHeader)
608608
{
609609
GC_ArrayletObjectModel::ArrayLayout layout = GC_ArrayletObjectModel::InlineContiguous;
610-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
611610
uint32_t size = 0;
612611
#if defined (OMR_GC_COMPRESSED_POINTERS)
613612
if (compressObjectReferences()) {
@@ -621,7 +620,6 @@ class GC_ObjectModel : public GC_ObjectModelBase
621620
if (0 != size) {
622621
return layout;
623622
}
624-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
625623

626624
/* we know we are dealing with heap object, so we don't need to check against _arrayletRangeBase/Top, like getArrayLayout does */
627625
J9Class *clazz = getPreservedClass(forwardedHeader);

‎runtime/gc_glue_java/ObjectModelDelegate.hpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -363,11 +363,11 @@ class GC_ObjectModelDelegate
363363
#else /* defined (OMR_GC_COMPRESSED_POINTERS) */
364364
uintptr_t elements = ((J9IndexableObjectContiguous *)forwardedHeader->getObject())->size;
365365
#endif /* defined (OMR_GC_COMPRESSED_POINTERS) */
366-
#if defined(J9VM_GC_HYBRID_ARRAYLETS)
366+
367367
if (0 == elements) {
368368
elements = ((J9IndexableObjectDiscontiguous *)forwardedHeader->getObject())->size;
369369
}
370-
#endif
370+
371371
uintptr_t dataSize = _arrayObjectModel->getDataSizeInBytes(clazz, elements);
372372
GC_ArrayletObjectModel::ArrayLayout layout = _arrayObjectModel->getArrayletLayout(clazz, dataSize);
373373
size = _arrayObjectModel->getSizeInBytesWithHeader(clazz, layout, elements);

‎runtime/gc_realtime/RealtimeAccessBarrier.cpp

+13-32
Original file line numberDiff line numberDiff line change
@@ -872,38 +872,19 @@ MM_RealtimeAccessBarrier::scanContiguousArray(MM_EnvironmentRealtime *env, J9Ind
872872
}
873873
#endif /* J9VM_GC_DYNAMIC_CLASS_UNLOADING */
874874

875-
#if !defined(J9VM_GC_HYBRID_ARRAYLETS)
876-
/* Since we are already in gc_realtime, not defined GC_HYBRID_ARRAYLET implies GC_ARRAYLETS is defined.
877-
* first (and only) arraylet address
878-
*/
879-
fj9object_t *arrayoid = _extensions->indexableObjectModel.getArrayoidPointer(objectPtr);
880-
GC_SlotObject slotObject(vm->omrVM, &arrayoid[0]);
881-
fj9object_t *startScanPtr = (fj9object_t*) (slotObject.readReferenceFromSlot());
882-
883-
if (NULL != startScanPtr) {
884-
/* Very small arrays cannot be set as scanned (no scanned bit in Mark Map reserved for them) */
885-
UDATA arrayletSize = _extensions->indexableObjectModel.arrayletSize(objectPtr, /* arraylet index */ 0);
886-
887-
fj9object_t *endScanPtr = startScanPtr + arrayletSize / sizeof(fj9object_t);
888-
fj9object_t *scanPtr = startScanPtr;
889-
#else /* J9VM_GC_HYBRID_ARRAYLETS */
890-
/* if NUA is enabled, separate path for contiguous arrays */
891-
fj9object_t *scanPtr = (fj9object_t*) _extensions->indexableObjectModel.getDataPointerForContiguous(objectPtr);
892-
fj9object_t *endScanPtr = scanPtr + _extensions->indexableObjectModel.getSizeInElements(objectPtr);
893-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
894-
while(scanPtr < endScanPtr) {
895-
/* since this is done from an external thread, we do not markObject, but rememberObject */
896-
GC_SlotObject slotObject(vm->omrVM, scanPtr);
897-
J9Object *field = slotObject.readReferenceFromSlot();
898-
rememberObject(env, field);
899-
scanPtr++;
900-
}
901-
902-
/* this method assumes the array is large enough to set scan bit */
903-
_markingScheme->setScanAtomic((J9Object *)objectPtr);
904-
#if !defined(J9VM_GC_HYBRID_ARRAYLETS)
905-
}
906-
#endif /* J9VM_GC_HYBRID_ARRAYLETS */
875+
/* if NUA is enabled, separate path for contiguous arrays */
876+
fj9object_t *scanPtr = (fj9object_t*) _extensions->indexableObjectModel.getDataPointerForContiguous(objectPtr);
877+
fj9object_t *endScanPtr = scanPtr + _extensions->indexableObjectModel.getSizeInElements(objectPtr);
878+
879+
while(scanPtr < endScanPtr) {
880+
/* since this is done from an external thread, we do not markObject, but rememberObject */
881+
GC_SlotObject slotObject(vm->omrVM, scanPtr);
882+
J9Object *field = slotObject.readReferenceFromSlot();
883+
rememberObject(env, field);
884+
scanPtr++;
885+
}
886+
/* this method assumes the array is large enough to set scan bit */
887+
_markingScheme->setScanAtomic((J9Object *)objectPtr);
907888
}
908889

909890
bool

0 commit comments

Comments
 (0)