Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Remove deprecated outlined new on X86 #2446

Merged
merged 1 commit into from
Jul 26, 2018
Merged

Remove deprecated outlined new on X86 #2446

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 0 additions & 6 deletions runtime/compiler/runtime/Runtime.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -291,8 +291,6 @@ JIT_HELPER(prefetchTLH);
JIT_HELPER(newPrefetchTLH);
JIT_HELPER(outlinedNewObject);
JIT_HELPER(outlinedNewArray);
JIT_HELPER(outlinedNewObjectNoZeroInit);
JIT_HELPER(outlinedNewArrayNoZeroInit);

JIT_HELPER(_arrayTranslateTRTO);
JIT_HELPER(_arrayTranslateTROTNoBreak);
Expand Down Expand Up @@ -1113,10 +1111,6 @@ void initializeCodeRuntimeHelperTable(J9JITConfig *jitConfig, char isSMP)
SET(TR_X86interpreterUnresolvedFieldGlue, (void *)interpreterUnresolvedFieldGlue, TR_Helper);
SET(TR_X86interpreterUnresolvedFieldSetterGlue, (void *)interpreterUnresolvedFieldSetterGlue, TR_Helper);

SET(TR_X86OutlinedNew, (void *)outlinedNewObject, TR_Helper);
SET(TR_X86OutlinedNewArray, (void *)outlinedNewArray, TR_Helper);
SET(TR_X86OutlinedNewNoZeroInit, (void *)outlinedNewObjectNoZeroInit, TR_Helper);
SET(TR_X86OutlinedNewArrayNoZeroInit, (void *)outlinedNewArrayNoZeroInit, TR_Helper);
SET(TR_X86prefetchTLH, (void *)prefetchTLH, TR_Helper);
SET(TR_X86newPrefetchTLH, (void *)newPrefetchTLH, TR_Helper);
SET(TR_X86CodeCachePrefetchHelper, (void *)prefetchTLH, TR_Helper); // needs to be set while compiling
Expand Down
157 changes: 9 additions & 148 deletions runtime/compiler/x/codegen/J9TreeEvaluator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9288,7 +9288,6 @@ J9::X86::TreeEvaluator::VMnewEvaluator(

bool realTimeGC = comp->getOptions()->realTimeGC();
bool generateArraylets = comp->generateArraylets();
bool outlineNew = false;

TR::Register *segmentReg = NULL;
TR::Register *tempReg = NULL;
Expand Down Expand Up @@ -9394,43 +9393,6 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
}
}

bool disableOutlinedNew = comp->getOption(TR_DisableOutlinedNew);

if (generateArraylets)
{
if (comp->getOption(TR_TraceCG))
traceMsg(comp, "OUTLINED NEW: Disable for %s %p because outlined allocation can't deal with arraylets\n", node->getOpCode().getName(), node);
disableOutlinedNew = true;
cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "cg.new/refusedToOutline/arraylets/%s", node->getOpCode().getName()), 1, TR::DebugCounter::Undetermined);
}
else if (comp->getMethodHotness() > warm)
{
if (comp->getOption(TR_TraceCG))
traceMsg(comp, "OUTLINED NEW: Disable for %p because opt level is %s\n", node, comp->getHotnessName());
disableOutlinedNew = true;
cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "cg.new/refusedToOutline/optlevel/%s", comp->getHotnessName()), 1, TR::DebugCounter::Undetermined);
}
else if (objectSize !=0 && objectSize <=0x40)
{
if (comp->getOption(TR_TraceCG))
traceMsg(comp, "OUTLINED NEW: Disable for %p because allocation size is small %d\n", node, objectSize);

disableOutlinedNew = true;
}
else if (comp->getDebug() &&
comp->getOptions()->getPackedTestRegex() &&
TR::SimpleRegex::match(comp->getOptions()->getPackedTestRegex(), "disablePackedOutlineNew"))
{
disableOutlinedNew = true;
}
else if(!comp->getOption(TR_EnableOutlinedNew) && cg->getX86ProcessorInfo().isGenuineIntel() && !cg->getX86ProcessorInfo().isIntelOldMachine())
{
disableOutlinedNew = true; //disable outlinednew for new machines
}

if (!disableOutlinedNew && performTransformation(comp, "O^O OUTLINED NEW: outlining %s %p, size %d\n", node->getOpCode().getName(), node, allocationSize))
outlineNew = true;

TR::LabelSymbol *startLabel = generateLabelSymbol(cg);
TR::LabelSymbol *fallThru = generateLabelSymbol(cg);
startLabel->setStartInternalControlFlow();
Expand Down Expand Up @@ -9523,104 +9485,15 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
if (skipOutlineZeroInit && !performTransformation(comp, "O^O OUTLINED NEW: skip outlined zero init on %s %p\n", cg->getDebug()->getName(node), node))
skipOutlineZeroInit = false;

if (skipOutlineZeroInit)
{
// The NoZeroInit outlined allocation causes sanity failures. If we
// can't do outlined allocation without zero init, just do it inline instead.
// TODO: Figure this out and fix it.
//
outlineNew = false;
if (comp->getOption(TR_TraceCG))
traceMsg(comp, "OUTLINED NEW: Disable for %p because we can't do it without zero-init\n", node);
disableOutlinedNew = true;
cg->generateDebugCounter("cg.new/refusedToOutline/noZeroInitBug", 1, TR::DebugCounter::Undetermined);
}

if (outlineNew)
// Faster inlined sequence. It does not understand arraylet shapes yet.
//
if (canUseFastInlineAllocation)
{
// Detect overflow in array size and let jitNewArray JIT helper handle overflow
//
if (sizeReg && !node->getFirstChild()->isNonNegative())
{
TR::Register *elementCountReg = sizeReg;
uintptrj_t maxObjectSize = cg->getMaxObjectSizeGuaranteedNotToOverflow();
uintptrj_t maxObjectSizeInElements = maxObjectSize / elementSize;
// 64 bit and max array size is larger than 0x7fffffff
if (TR::Compiler->target.is64Bit() && !(maxObjectSizeInElements > 0 && maxObjectSizeInElements <= (uintptrj_t)INT_MAX))
{
generateRegImm64Instruction(MOV8RegImm64, node, tempReg, maxObjectSizeInElements, cg);
generateRegRegInstruction(CMP8RegReg, node, elementCountReg, tempReg, cg);
}
else
{
generateRegImmInstruction(CMPRegImm4(), node, elementCountReg, (int32_t)maxObjectSizeInElements, cg);
}
generateLabelInstruction(JAE4, node, failLabel, cg);
}

if (sizeReg)
{
int32_t round = (elementSize < fej9->getObjectAlignmentInBytes()) ?
fej9->getObjectAlignmentInBytes() : 0;
int32_t disp = round ? (round-1) : 0;

// Now compute size of object in bytes
//
generateRegMemInstruction(LEARegMem(),
node,
segmentReg,
generateX86MemoryReference(NULL,
sizeReg,
TR::MemoryReference::convertMultiplierToStride(elementSize),
allocationSize + disp, cg), cg);
if (round)
{
generateRegImmInstruction(ANDRegImms(), node, segmentReg, -round, cg);
}
}
else
{
// make sure the allocationSize is aligned
//
allocationSize = (allocationSize + fej9->getObjectAlignmentInBytes()-1) & (-fej9->getObjectAlignmentInBytes());
generateRegImmInstruction(MOV4RegImm4, node, segmentReg, allocationSize, cg);
}

if (skipOutlineZeroInit)
{
TR_RuntimeHelper helper;
if (isArrayNew && sizeReg)
helper = TR_X86OutlinedNewArrayNoZeroInit;
else
helper = TR_X86OutlinedNewNoZeroInit;
cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "cg.new/outlined/noZeroInit/%s", node->getOpCode().getName()), 1, TR::DebugCounter::Undetermined);
generateHelperCallInstruction(node, helper, NULL, cg)->setAdjustsFramePointerBy(0);
}
else
{
TR_RuntimeHelper helper;
if (isArrayNew && sizeReg)
helper = TR_X86OutlinedNewArray;
else
helper = TR_X86OutlinedNew;
cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "cg.new/outlined/zeroInit/%s", node->getOpCode().getName()), 1, TR::DebugCounter::Undetermined);
generateHelperCallInstruction(node, helper, NULL, cg)->setAdjustsFramePointerBy(0);
}
generateRegRegInstruction(TESTRegReg(), node, targetReg, targetReg, cg);
generateLabelInstruction(JE4, node, failLabel, cg);
genHeapAlloc2(node, clazz, allocationSize, elementSize, sizeReg, targetReg, segmentReg, tempReg, failLabel, cg);
}
else
{
// Faster inlined sequence. It does not understand arraylet shapes yet.
//
if (canUseFastInlineAllocation)
{
genHeapAlloc2(node, clazz, allocationSize, elementSize, sizeReg, targetReg, segmentReg, tempReg, failLabel, cg);
}
else
{
genHeapAlloc(node, clazz, allocationSize, elementSize, sizeReg, targetReg, segmentReg, tempReg, failLabel, cg);
}
genHeapAlloc(node, clazz, allocationSize, elementSize, sizeReg, targetReg, segmentReg, tempReg, failLabel, cg);
}

// --------------------------------------------------------------------------------
Expand All @@ -9647,7 +9520,7 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
maxZeroInitWordsPerIteration = MAX_ZERO_INIT_WORDS_PER_ITERATION; // Use default value
}

if (initInfo && initInfo->zeroInitSlots && !outlineNew)
if (initInfo && initInfo->zeroInitSlots)
{
// If there are too many words to be individually initialized, initialize
// them all
Expand Down Expand Up @@ -9742,7 +9615,7 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
monitorSlotIsInitialized = true;
}
else if ((!initInfo || initInfo->numZeroInitSlots > 0) &&
!node->canSkipZeroInitialization() && !outlineNew)
!node->canSkipZeroInitialization())
{
// Initialize all slots
//
Expand Down Expand Up @@ -9773,7 +9646,7 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
// for non-native 64-bit targets where the discontiguous length slot is already initialized
// via the contiguous length slot.
//
if (node->getOpCodeValue() != TR::New && !outlineNew &&
if (node->getOpCodeValue() != TR::New &&
(TR::Compiler->target.is32Bit() || comp->useCompressedPointers()))
{
generateMemImmInstruction(SMemImm4(), node,
Expand Down Expand Up @@ -9878,11 +9751,6 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
numDeps += 2;
}

if (outlineNew)
{
numDeps++;
}

// Create dependencies for the allocation registers here.
// The size and class registers, if they exist, must be the first
// dependencies since the heap allocation snippet needs to find them to grab
Expand All @@ -9898,7 +9766,7 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
deps->addPostCondition(targetReg, TR::RealRegister::eax, cg);
deps->addPostCondition(cg->getVMThreadRegister(), TR::RealRegister::ebp, cg);

if (useRepInstruction || outlineNew)
if (useRepInstruction)
{
deps->addPostCondition(tempReg, TR::RealRegister::ecx, cg);
deps->addPostCondition(segmentReg, TR::RealRegister::edi, cg);
Expand All @@ -9916,13 +9784,6 @@ J9::X86::TreeEvaluator::VMnewEvaluator(
cg->stopUsingRegister(scratchReg);
}

if (outlineNew)
{
TR::Register *dummyReg = cg->allocateRegister();
deps->addPostCondition(dummyReg, TR::RealRegister::esi, cg);
cg->stopUsingRegister(dummyReg);
}

if (outlinedHelperCall)
{
TR::Node *callNode = outlinedHelperCall->getCallNode();
Expand Down
Loading