Redefer function bodies that are not currently being executed and are

eligible for deferred parsing (e.g., not arrow functions, not functions-in-block). This is experimental behavior, off by default. Define an 'on' mode in which all eligible functions are redeferred on GC, as well as a 'stress' mode in which all candidates are redeferred on each stack probe. This change is built on a previous PR that refactors the FunctionBody hierarchy to make it easier to toggle between deferred and fully-compiled states.
chakra-core · Sep 28, 2016 · f15f3c4 · f15f3c4
1 parent 8df3f80
commit f15f3c4
Show file tree

Hide file tree

Showing 30 changed files with 776 additions and 484 deletions.
diff --git a/lib/Backend/Inline.cpp b/lib/Backend/Inline.cpp
@@ -497,7 +497,7 @@ uint Inline::FillInlineesDataArray(
         }
 
         Js::FunctionBody *inlineeFunctionBody = inlineeJitTimeData->GetFunctionBody();
-        if (!PHASE_OFF(Js::PolymorphicInlinePhase, inlineeFunctionBody))
+        if (inlineeFunctionBody && !PHASE_OFF(Js::PolymorphicInlinePhase, inlineeFunctionBody))
         {
             const Js::FunctionCodeGenJitTimeData* rightInlineeJitTimeData = inlineeJitTimeData->GetJitTimeDataFromFunctionInfo(inlineeFunctionBody->GetFunctionInfo());
             const Js::FunctionCodeGenRuntimeData* rightInlineeRuntimeData = inlineeRuntimeData->GetRuntimeDataFromFunctionInfo(inlineeFunctionBody->GetFunctionInfo());
@@ -549,14 +549,15 @@ void Inline::FillInlineesDataArrayUsingFixedMethods(
     while (inlineeJitTimeData)
     {
         inlineeFuncBody = inlineeJitTimeData->GetFunctionBody();
-        if (!PHASE_OFF(Js::PolymorphicInlinePhase, inlineeFuncBody) && !PHASE_OFF(Js::PolymorphicInlineFixedMethodsPhase, inlineeFuncBody))
+        if (inlineeFuncBody && !PHASE_OFF(Js::PolymorphicInlinePhase, inlineeFuncBody) && !PHASE_OFF(Js::PolymorphicInlineFixedMethodsPhase, inlineeFuncBody))
         {
             const Js::FunctionCodeGenJitTimeData* jitTimeData = inlineeJitTimeData->GetJitTimeDataFromFunctionInfo(inlineeFuncBody->GetFunctionInfo());
             if (jitTimeData)
             {
                 for (uint16 i = 0; i < cachedFixedInlineeCount; i++)
                 {
-                    if (inlineeFuncBody == ((Js::JavascriptFunction*)(fixedFieldInfoArray[i].fieldValue))->GetFunctionBody())
+                    Js::ParseableFunctionInfo *info = ((Js::JavascriptFunction*)(fixedFieldInfoArray[i].fieldValue))->GetParseableFunctionInfo();
+                    if (info->IsFunctionBody() && inlineeFuncBody == info->GetFunctionBody())
                     {
                         inlineesDataArray[i].inlineeJitTimeData = inlineeJitTimeData->GetJitTimeDataFromFunctionInfo(inlineeFuncBody->GetFunctionInfo());
                         inlineesDataArray[i].inlineeRuntimeData = inlineeRuntimeData->GetRuntimeDataFromFunctionInfo(inlineeFuncBody->GetFunctionInfo());

diff --git a/lib/Backend/Opnd.cpp b/lib/Backend/Opnd.cpp
@@ -3234,7 +3234,7 @@ Opnd::GetAddrDescription(__out_ecount(count) char16 *const description, const si
 
         case IR::AddrOpndKindDynamicFunctionInfo:
             DumpAddress(address, printToConsole, skipMaskedAddress);
-            DumpFunctionInfo(&buffer, &n, (Js::FunctionInfo *)address, printToConsole);
+            DumpFunctionInfo(&buffer, &n, ((Js::FunctionBody *)address)->GetFunctionInfo(), printToConsole);
             break;
 
         case IR::AddrOpndKindDynamicFunctionBody:

diff --git a/lib/Common/ConfigFlagsList.h b/lib/Common/ConfigFlagsList.h
@@ -10,6 +10,7 @@ PHASE(All)
     PHASE(Parse)
         PHASE(RegexCompile)
         PHASE(DeferParse)
+        PHASE(Redeferral)
         PHASE(DeferEventHandlers)
         PHASE(FunctionSourceInfoParse)
         PHASE(StringTemplateParse)

diff --git a/lib/Common/Memory/CustomHeap.cpp b/lib/Common/Memory/CustomHeap.cpp
@@ -243,6 +243,10 @@ Allocation* Heap::Alloc(size_t bytes, ushort pdataCount, ushort xdataSize, bool
         {
             page = AllocNewPage(bucket, canAllocInPreReservedHeapPageSegment, isAnyJittedCode, isAllJITCodeInPreReservedRegion);
         }
+        else if (!canAllocInPreReservedHeapPageSegment && isAnyJittedCode)
+        {
+            *isAllJITCodeInPreReservedRegion = false;
+        }
 
         // Out of memory
         if (page == nullptr)

diff --git a/lib/Parser/Parse.cpp b/lib/Parser/Parse.cpp
@@ -4881,7 +4881,7 @@ bool Parser::ParseFncDeclHelper(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, usho
         BOOL isDeferredFnc = IsDeferredFnc();
         AnalysisAssert(isDeferredFnc || pnodeFnc);
         isTopLevelDeferredFunc =
-            (!isDeferredFnc
+            (!fLambda
              && DeferredParse(pnodeFnc->sxFnc.functionId)
              && (!pnodeFnc->sxFnc.IsNested() || CONFIG_FLAG(DeferNested))
             // Don't defer if this is a function expression not contained in a statement or other expression.
@@ -4892,6 +4892,9 @@ bool Parser::ParseFncDeclHelper(ParseNodePtr pnodeFnc, LPCOLESTR pNameHint, usho
              && !fModule
             );
 
+        pnodeFnc->sxFnc.SetCanBeDeferred(isTopLevelDeferredFunc && !pnodeFnc->sxFnc.IsGenerator());
+        isTopLevelDeferredFunc = isTopLevelDeferredFunc && !isDeferredFnc;
+
         if (!fLambda &&
             !isDeferredFnc &&
             !isLikelyIIFE &&
@@ -6364,6 +6367,11 @@ ParseNodePtr Parser::GenerateEmptyConstructor(bool extends)
     pnodeFnc->sxFnc.deferredStub        = nullptr;
     pnodeFnc->sxFnc.funcInfo            = nullptr;
 
+    // In order to (re-)defer the default constructor, we need to, for instance, track
+    // deferred class expression the way we track function expression, since we lose the part of the source
+    // that tells us which we have.
+    pnodeFnc->sxFnc.canBeDeferred       = false;
+
 #ifdef DBG
     pnodeFnc->sxFnc.deferredParseNextFunctionId = *(this->m_nextFunctionId);
 #endif
@@ -10306,6 +10314,7 @@ void Parser::ParseStmtList(ParseNodePtr *ppnodeList, ParseNodePtr **pppnodeLast,
                         // i.e. smEnvironment == SM_OnFunctionCode
                         Assert(m_currentNodeFunc != nullptr);
                         m_currentNodeFunc->sxFnc.SetAsmjsMode();
+                        m_currentNodeFunc->sxFnc.SetCanBeDeferred(false);
                         m_InAsmMode = true;
 
                         CHAKRATEL_LANGSTATS_INC_LANGFEATURECOUNT(AsmJSFunctionCount, m_scriptContext);
@@ -10560,7 +10569,7 @@ void Parser::InitPids()
     wellKnownPropertyPids._star = m_phtbl->PidHashNameLen(_u("*"), sizeof("*") - 1);
 }
 
-void Parser::RestoreScopeInfo(Js::FunctionBody* functionBody)
+void Parser::RestoreScopeInfo(Js::ParseableFunctionInfo* functionBody)
 {
     if (!functionBody)
     {
@@ -10616,7 +10625,7 @@ void Parser::RestoreScopeInfo(Js::FunctionBody* functionBody)
     scopeInfo->GetScopeInfo(this, nullptr, nullptr, scope);
 }
 
-void Parser::FinishScopeInfo(Js::FunctionBody *functionBody)
+void Parser::FinishScopeInfo(Js::ParseableFunctionInfo *functionBody)
 {
     if (!functionBody)
     {

diff --git a/lib/Parser/Parse.h b/lib/Parser/Parse.h
@@ -967,8 +967,8 @@ class Parser
     void RemovePrevPidRef(IdentPtr pid, PidRefStack *lastRef);
     void SetPidRefsInScopeDynamic(IdentPtr pid, int blockId);
 
-    void RestoreScopeInfo(Js::FunctionBody* functionBody);
-    void FinishScopeInfo(Js::FunctionBody* functionBody);
+    void RestoreScopeInfo(Js::ParseableFunctionInfo* functionBody);
+    void FinishScopeInfo(Js::ParseableFunctionInfo* functionBody);
 
     BOOL PnodeLabelNoAST(IdentToken* pToken, LabelId* pLabelIdList);
     LabelId* CreateLabelId(IdentToken* pToken);

diff --git a/lib/Parser/ptree.h b/lib/Parser/ptree.h
@@ -246,6 +246,7 @@ struct PnFnc
 #endif
     RestorePoint *pRestorePoint;
     DeferredFunctionStub *deferredStub;
+    bool canBeDeferred;
 
     static const int32 MaxStackClosureAST = 800000;
 
@@ -316,6 +317,7 @@ struct PnFnc
     void SetUsesArguments(bool set = true) { SetFlags(kFunctionUsesArguments, set); }
     void SetIsDefaultModuleExport(bool set = true) { SetFlags(kFunctionIsDefaultModuleExport, set); }
     void SetNestedFuncEscapes(bool set = true) { nestedFuncEscapes = set; }
+    void SetCanBeDeferred(bool set = true) { canBeDeferred = set; }
 
     bool CallsEval() const { return HasFlags(kFunctionCallsEval); }
     bool ChildCallsEval() const { return HasFlags(kFunctionChildCallsEval); }
@@ -353,6 +355,7 @@ struct PnFnc
     bool UsesArguments() const { return HasFlags(kFunctionUsesArguments); }
     bool IsDefaultModuleExport() const { return HasFlags(kFunctionIsDefaultModuleExport); }
     bool NestedFuncEscapes() const { return nestedFuncEscapes; }
+    bool CanBeDeferred() const { return canBeDeferred; }
 
     size_t LengthInBytes()
     {