implement NumberAllocator for OOP JIT

     Allocate pages in JIT process with VirtualAllocEx. Initially reserve 0x20 pages(required by recycler leaf page allocator), then commit 2 pages (small block) incrementally.
     Main process send over the available page through RPC, JIT process will use the free part of the page before committing new pages.
     Number chunks are allocated after JIT is done, use same allocating mechanism as in-proc JIT
     The pageSegment is created when integrating to recycler page allocator

Author: leirocks

lib/Backend/CodeGenNumberAllocator.cpp

@@ -211,6 +211,8 @@ CodeGenNumberThreadAllocator::Integrate()
 
     while (!pendingIntegrationChunkBlock.Empty())
     {
+        // REVIEW: the above number block integration can be moved into this loop
+
         TRACK_ALLOC_INFO(recycler, CodeGenNumberChunk, Recycler, 0, (size_t)-1);
 
         BlockRecord& record = pendingIntegrationChunkBlock.Head();
@@ -287,3 +289,235 @@ CodeGenNumberAllocator::Finalize()
     this->currentChunkNumberCount = 0;
     return finalizedChunk;
 }
+
+
+Js::JavascriptNumber* XProcNumberPageSegmentImpl::AllocateNumber(HANDLE hProcess, double value, Js::StaticType* numberTypeStatic, void* javascriptNumberVtbl)
+{
+    XProcNumberPageSegmentImpl* tail = this;
+
+    if (this->pageAddress != 0)
+    {
+        while (tail->nextSegment)
+        {
+            tail = (XProcNumberPageSegmentImpl*)tail->nextSegment;
+        }
+
+        if (tail->pageAddress + tail->committedEnd - tail->allocEndAddress >= sizeCat)
+        {
+            auto number = tail->allocEndAddress;
+            tail->allocEndAddress += sizeCat;
+
+            Js::JavascriptNumber localNumber(value, numberTypeStatic, true);
+
+            // change vtable to the remote one
+            *(void**)&localNumber = javascriptNumberVtbl;
+
+            // initialize number by WriteProcessMemory
+            SIZE_T bytesWritten;
+            WriteProcessMemory(hProcess, (void*)number, &localNumber, sizeof(localNumber), &bytesWritten);
+
+            return (Js::JavascriptNumber*) number;
+        }
+
+        // alloc blocks
+        if ((void*)tail->committedEnd < tail->GetEndAddress())
+        {
+            Assert((unsigned int)((char*)tail->GetEndAddress() - (char*)tail->committedEnd) >= tail->blockSize);
+            // TODO: implement guard pages (still necessary for OOP JIT?)
+            auto ret = ::VirtualAllocEx(hProcess, tail->GetCommitEndAddress(), tail->blockSize, MEM_COMMIT, PAGE_READWRITE);
+            if (!ret)
+            {
+                Js::Throw::OutOfMemory();
+            }
+            tail->committedEnd += tail->blockSize;
+            return AllocateNumber(hProcess, value, numberTypeStatic, javascriptNumberVtbl);
+        }
+    }
+
+    // alloc new segment
+    void* pages = ::VirtualAllocEx(hProcess, nullptr, this->pageCount * AutoSystemInfo::PageSize, MEM_RESERVE, PAGE_READWRITE);
+    if (pages == nullptr)
+    {
+        Js::Throw::OutOfMemory();
+    }
+
+    if (tail->pageAddress == 0)
+    {
+        tail = new (tail) XProcNumberPageSegmentImpl();
+        tail->pageAddress = (int)pages;
+        tail->allocStartAddress = this->pageAddress;
+        tail->allocEndAddress = this->pageAddress;
+        tail->nextSegment = nullptr;
+        return AllocateNumber(hProcess, value, numberTypeStatic, javascriptNumberVtbl);
+    }
+    else
+    {
+        XProcNumberPageSegmentImpl* seg = new (midl_user_allocate(sizeof(XProcNumberPageSegment))) XProcNumberPageSegmentImpl();
+        tail->nextSegment = seg;
+        return seg->AllocateNumber(hProcess, value, numberTypeStatic, javascriptNumberVtbl);
+    }
+}
+
+
+XProcNumberPageSegmentImpl::XProcNumberPageSegmentImpl()
+{
+    this->pageCount = Memory::IdleDecommitPageAllocator::DefaultMaxAllocPageCount;
+    this->sizeCat = HeapInfo::GetAlignedSizeNoCheck(sizeof(Js::JavascriptNumber));
+    this->blockSize = SmallAllocationBlockAttributes::PageCount*AutoSystemInfo::PageSize;
+    this->blockIntegratedSize = 0;
+    this->pageSegment = 0;
+}
+
+CodeGenNumberChunk* ::XProcNumberPageSegmentManager::RegisterSegments(XProcNumberPageSegment* segments)
+{
+    Assert(segments->pageAddress && segments->allocStartAddress && segments->allocEndAddress);
+
+
+    XProcNumberPageSegmentImpl* segmentImpl = (XProcNumberPageSegmentImpl*)segments;
+
+    auto temp = segmentImpl;
+    CodeGenNumberChunk* chunk = nullptr;
+    int numberCount = CodeGenNumberChunk::MaxNumberCount;
+    while (temp)
+    {
+        auto start = temp->allocStartAddress;
+
+        if (temp->GetChunkAllocator() == nullptr)
+        {
+            temp->chunkAllocator = (intptr_t)HeapNew(CodeGenNumberThreadAllocator, this->recycler);
+        }
+
+        while (start < temp->allocEndAddress)
+        {
+            if (numberCount == CodeGenNumberChunk::MaxNumberCount)
+            {
+                auto newChunk = temp->GetChunkAllocator()->AllocChunk();
+                newChunk->next = chunk;
+                chunk = newChunk;
+                numberCount = 0;
+            }
+            chunk->numbers[numberCount++] = (Js::JavascriptNumber*)start;
+            start += temp->sizeCat;
+        }
+
+        temp->GetChunkAllocator()->FlushAllocations();
+
+        temp = (XProcNumberPageSegmentImpl*)temp->nextSegment;
+    }
+
+    AutoCriticalSection autoCS(&cs);
+    if (this->segmentsList == nullptr)
+    {
+        this->segmentsList = segmentImpl;
+    }
+    else
+    {
+        auto temp = segmentsList;
+        while (temp->nextSegment)
+        {
+            temp = (XProcNumberPageSegmentImpl*)temp->nextSegment;
+        }
+        temp->nextSegment = segmentImpl;
+    }
+
+    return chunk;
+}
+
+void XProcNumberPageSegmentManager::GetFreeSegment(XProcNumberPageSegment& seg)
+{
+    AutoCriticalSection autoCS(&cs);
+
+    memset(&seg, 0, sizeof(seg));
+
+    if (segmentsList == nullptr)
+    {
+        new (&seg) XProcNumberPageSegmentImpl();
+        return;
+    }
+
+    auto temp = segmentsList;
+    auto prev = &segmentsList;
+    while (temp)
+    {
+        if (temp->allocEndAddress != temp->pageAddress + (int)(temp->pageCount*AutoSystemInfo::PageSize)) // not full
+        {
+            *prev = (XProcNumberPageSegmentImpl*)temp->nextSegment;
+
+            // remove from the list
+            memcpy(&seg, temp, sizeof(seg));
+            midl_user_free(temp);
+            return;
+        }
+        prev = (XProcNumberPageSegmentImpl**)&temp->nextSegment;
+        temp = (XProcNumberPageSegmentImpl*)temp->nextSegment;
+    }
+}
+
+void XProcNumberPageSegmentManager::Integrate()
+{
+    AutoCriticalSection autoCS(&cs);
+
+    auto temp = this->segmentsList;
+    auto prev = &this->segmentsList;
+    while (temp)
+    {
+        if (temp->pageSegment == 0)
+        {
+            auto leafPageAllocator = recycler->GetRecyclerLeafPageAllocator();
+            DListBase<PageSegment> segmentList;
+            temp->pageSegment = (intptr_t)leafPageAllocator->AllocPageSegment(segmentList, leafPageAllocator,
+                (void*)temp->pageAddress, temp->pageCount, temp->committedEnd / AutoSystemInfo::PageSize);
+            leafPageAllocator->IntegrateSegments(segmentList, 1, temp->pageCount);
+
+            this->integratedSegmentCount++;
+        }
+
+        if (!temp->GetChunkAllocator()->pendingIntegrationChunkBlock.Empty())
+        {
+            Assert(sizeof(CodeGenNumberChunk) == sizeof(Js::JavascriptNumber));
+            size_t minIntegrateSize = temp->blockSize*CodeGenNumberChunk::MaxNumberCount;
+            for (; temp->pageAddress + temp->blockIntegratedSize + minIntegrateSize < (unsigned int)temp->allocEndAddress;
+                temp->blockIntegratedSize += minIntegrateSize)
+            {
+                TRACK_ALLOC_INFO(recycler, Js::JavascriptNumber, Recycler, 0, (size_t)-1);
+
+                if (!recycler->IntegrateBlock<LeafBit>((char*)temp->pageAddress + temp->blockIntegratedSize, (PageSegment*)temp->pageSegment, temp->sizeCat, sizeof(Js::JavascriptNumber)))
+                {
+                    Js::Throw::OutOfMemory();
+                }
+            }
+        }
+
+        temp->GetChunkAllocator()->Integrate();
+
+        if (temp->blockIntegratedSize >= temp->pageCount*AutoSystemInfo::PageSize)
+        {
+            // all pages are integrated, don't need this segment any more
+            *prev = (XProcNumberPageSegmentImpl*)temp->nextSegment;
+            HeapDelete(temp->GetChunkAllocator());
+            midl_user_free(temp);
+            temp = *prev;
+        }
+        else
+        {
+            prev = (XProcNumberPageSegmentImpl**)&temp->nextSegment;
+            temp = (XProcNumberPageSegmentImpl*)temp->nextSegment;
+        }
+
+    }
+}
+
+XProcNumberPageSegmentManager::~XProcNumberPageSegmentManager()
+{
+    auto temp = segmentsList;
+    while (temp)
+    {
+        auto next = temp->nextSegment;
+        if (temp->chunkAllocator)
+        {
+            HeapDelete((CodeGenNumberThreadAllocator*)temp->chunkAllocator);
+        }
+        midl_user_free(temp);
+        temp = (XProcNumberPageSegmentImpl*)next;
+    }
+}

lib/Backend/CodeGenNumberAllocator.h

@@ -63,6 +63,7 @@ CompileAssert(
 
 class CodeGenNumberThreadAllocator
 {
+    friend struct XProcNumberPageSegmentManager;
 public:
     CodeGenNumberThreadAllocator(Recycler * recycler);
     ~CodeGenNumberThreadAllocator();
@@ -144,3 +145,41 @@ class CodeGenNumberAllocator
     bool finalized;
 #endif
 };
+
+namespace Js
+{
+    class StaticType;
+}
+
+struct XProcNumberPageSegmentImpl : public XProcNumberPageSegment
+{
+    XProcNumberPageSegmentImpl();
+    Js::JavascriptNumber* AllocateNumber(HANDLE hProcess, double value, Js::StaticType* numberTypeStatic, void* javascriptNumberVtbl);
+    unsigned int GetTotalSize() { return this->pageCount * AutoSystemInfo::PageSize; }
+    void* GetEndAddress() { return (void*)(this->pageAddress + this->pageCount * AutoSystemInfo::PageSize); }
+    void* GetCommitEndAddress() { return (void*)(this->pageAddress + this->committedEnd); }
+    // TODO: using CodeGenNumberThreadAllocator to allocate the chunks only, abstract chunk alloc code out of CodeGenNumberThreadAllocator
+    CodeGenNumberThreadAllocator* GetChunkAllocator() { return (CodeGenNumberThreadAllocator*) this->chunkAllocator; }
+};
+
+static_assert(sizeof(XProcNumberPageSegmentImpl) == sizeof(XProcNumberPageSegment), "should not have data member in XProcNumberPageSegmentImpl");
+
+struct XProcNumberPageSegmentManager
+{
+    CriticalSection cs;
+    XProcNumberPageSegmentImpl* segmentsList;
+    Recycler* recycler;
+    unsigned int integratedSegmentCount;
+    XProcNumberPageSegmentManager(Recycler* recycler)
+        :segmentsList(nullptr), recycler(recycler), integratedSegmentCount(0)
+    {
+    }
+
+    ~XProcNumberPageSegmentManager();
+
+    void GetFreeSegment(XProcNumberPageSegment& seg);
+    CodeGenNumberChunk* RegisterSegments(XProcNumberPageSegment* segments);
+
+    void Integrate();
+};
+

lib/Backend/Encoder.cpp

@@ -312,7 +312,7 @@ Encoder::Encode()
     {
 
         // TODO: OOP JIT, inlinee frame map
-        if (false) // in-proc JIT
+        if (!m_func->IsOOPJIT()) // in-proc JIT
         {
             entryPointInfo->RecordInlineeFrameMap(m_inlineeFrameMap);
         }

lib/Backend/Func.cpp

@@ -1505,6 +1505,15 @@ Func::GetFunctionEntryInsertionPoint()
     return insertInsert->m_next;
 }
 
+Js::JavascriptNumber* 
+Func::AllocateOOPNumber(double value)
+{
+    return this->GetXProcNumberAllocator()->AllocateNumber(this->GetThreadContextInfo()->GetProcessHandle(), 
+        value, 
+        (Js::StaticType*)this->GetScriptContextInfo()->GetNumberTypeStaticAddr(),
+        (void*)this->GetScriptContextInfo()->GetVTableAddress(VTableValue::VtableJavascriptNumber));
+}
+
 #ifdef ENABLE_DEBUG_CONFIG_OPTIONS
 void
 Func::DumpFullFunctionName()

lib/Backend/Func.h

@@ -100,6 +100,10 @@ class Func
     {
         return &this->m_codeGenAllocators->emitBufferManager;
     }
+    XProcNumberPageSegmentImpl* GetXProcNumberAllocator()
+    {
+        return (XProcNumberPageSegmentImpl*)this->GetJITOutput()->GetOutputData()->numberPageSegments;
+    }
 
     Js::ScriptContextProfiler *GetCodeGenProfiler() const
     {
@@ -110,6 +114,8 @@ class Func
 #endif
     }
 
+    bool IsOOPJIT() { return true; }
+
     void InitLocalClosureSyms();
 
     bool HasAnyStackNestedFunc() const { return this->hasAnyStackNestedFunc; }
@@ -435,6 +441,8 @@ static const unsigned __int64 c_debugFillPattern8 = 0xcececececececece;
         return this->isTJLoopBody;
     }
 
+    Js::JavascriptNumber* AllocateOOPNumber(double value);
+
     Js::ObjTypeSpecFldInfo* GetObjTypeSpecFldInfo(const uint index) const;
     Js::ObjTypeSpecFldInfo* GetGlobalObjTypeSpecFldInfo(uint propertyInfoId) const;
     void SetGlobalObjTypeSpecFldInfo(uint propertyInfoId, Js::ObjTypeSpecFldInfo* info);

lib/Backend/IR.cpp

@@ -3439,7 +3439,7 @@ IR::Instr* IR::Instr::NewConstantLoad(IR::RegOpnd* dstOpnd, intptr_t varConst, J
             {
                 // TODO (michhol): OOP JIT. we may need to unbox before sending over const table                
 
-                if (false)
+                if (!func->IsOOPJIT())
                 {
                     srcOpnd = IR::FloatConstOpnd::New((Js::Var)varConst, TyFloat64, func);
                 }

lib/Backend/InlineeFrameInfo.cpp

@@ -42,15 +42,29 @@ Js::Var BailoutConstantValue::ToVar(Func* func, Js::ScriptContext* scriptContext
     }
     else if (this->type == TyFloat64)
     {
-        varValue = Js::JavascriptNumber::NewCodeGenInstance(func->GetNumberAllocator(), (double)this->u.floatConst.value, scriptContext);
+        if (!func->IsOOPJIT()) // in-proc jit
+        {
+            varValue = Js::JavascriptNumber::NewCodeGenInstance(func->GetNumberAllocator(), (double)this->u.floatConst.value, scriptContext);
+        }
+        else // OOP JIT
+        {
+            varValue = func->AllocateOOPNumber((double)this->u.floatConst.value);
+        }
     }
     else if (IRType_IsSignedInt(this->type) && TySize[this->type] <= 4 && !Js::TaggedInt::IsOverflow((int32)this->u.intConst.value))
     {
         varValue = Js::TaggedInt::ToVarUnchecked((int32)this->u.intConst.value);
     }
     else
-    {
-        varValue = Js::JavascriptNumber::NewCodeGenInstance(func->GetNumberAllocator(), (double)this->u.intConst.value, scriptContext);
+    {       
+        if (!func->IsOOPJIT()) // in-proc jit
+        {
+            varValue = Js::JavascriptNumber::NewCodeGenInstance(func->GetNumberAllocator(), (double)this->u.intConst.value, scriptContext);
+        }
+        else // OOP JIT
+        {
+            varValue = func->AllocateOOPNumber((double)this->u.intConst.value);
+        }
     }
     return varValue;