private UIntPtr FreshAlloc(UIntPtr bytes, uint alignment,
Thread currentThread)
{
#if SINGULARITY_KERNEL
Kernel.Waypoint(702);
#endif
this.Truncate();
UIntPtr paddedBytes =
PageTable.PagePad(bytes + alignment - UIntPtr.Size);
BaseCollector.IncrementNewBytesSinceGC(paddedBytes);
UIntPtr pages = PageTable.PageCount(paddedBytes);
bool fCleanPages = CLEAR_POOL_PAGES();
// We may eventually want to ask for specific pages
// between asking if any pages are reusable and asking the
// OS for any possible page.
UIntPtr startPage =
PageManager.EnsurePages(currentThread, pages, this.pageType,
ref fCleanPages);
UIntPtr startAddr = PageTable.PageAddr(startPage);
UIntPtr limitAddr = PageTable.PageAddr(startPage + pages);
startAddr = Allocator.AlignedAllocationPtr(startAddr, limitAddr,
alignment);
this.allocNew = startAddr;
this.allocPtr = startAddr + bytes;
if (fCleanPages)
{
this.zeroedLimit = limitAddr;
}
else
{
Util.MemClear(startAddr, bytes);
this.zeroedLimit = this.allocPtr;
}
this.reserveLimit = limitAddr;
UIntPtr resultAddr = startAddr + PreHeader.Size;
InteriorPtrTable.SetFirst(resultAddr);
#if !SINGULARITY || SEMISPACE_COLLECTOR || ADAPTIVE_COPYING_COLLECTOR || SLIDING_COLLECTOR
if (GC.remsetType == RemSetType.Cards)
{
UIntPtr nextPageAddr = startAddr + PageTable.PageSize;
VTable.Assert(resultAddr < nextPageAddr);
if (this.allocPtr > nextPageAddr)
{
#if DONT_RECORD_OBJALLOC_IN_OFFSETTABLE
#else
OffsetTable.SetLast(resultAddr);
#endif
}
}
#endif
#if SINGULARITY_KERNEL
Kernel.Waypoint(703);
#endif
return(resultAddr);
}
private UIntPtr growFreeList(UIntPtr blockSize, Thread t)
{
UIntPtr pageCount = PageTable.PageCount(blockSize);
bool fCleanPages = true;
UIntPtr startPage = PageManager.EnsurePages(t, pageCount,
PageType.Owner0,
ref fCleanPages);
UIntPtr newBlockSize = PageTable.RegionSize(pageCount);
UIntPtr newBlockAddr = PageTable.PageAddr(startPage);
return(FreeBlock(newBlockAddr, newBlockSize));
}
private void AdvanceWritePage()
{
UIntPtr pageAddr;
if (UnmanagedPageList.pageCache.IsEmpty)
{
bool fCleanPages = true;
UIntPtr page = PageManager.EnsurePages(null, (UIntPtr)1,
PageType.System,
ref fCleanPages);
pageAddr = PageTable.PageAddr(page);
}
else
{
pageAddr = UnmanagedPageList.pageCache.RemoveHead();
}
this.pageList.AddTail(pageAddr);
this.writeCursor =
new PageCursor(UnmanagedPageList.FirstPageAddr(pageAddr),
UnmanagedPageList.EndPageAddr(pageAddr));
}
private void AdvancePage()
{
if (this.stackPage != UIntPtr.Zero)
{
this.pageList.AddHead(this.stackPage);
}
if (UnmanagedPageList.pageCache.IsEmpty)
{
bool fCleanPages = true;
UIntPtr page = PageManager.EnsurePages(null, (UIntPtr)1,
PageType.System,
ref fCleanPages);
this.stackPage = PageTable.PageAddr(page);
}
else
{
this.stackPage = UnmanagedPageList.pageCache.RemoveHead();
}
this.stackBottom = UnmanagedPageList.FirstPageAddr(this.stackPage);
this.stackPtr = this.stackBottom;
this.stackTop = UnmanagedPageList.EndPageAddr(this.stackPage);
}
// Interface with the compiler!
internal static unsafe UIntPtr AllocateBig(UIntPtr numBytes,
uint alignment,
Thread currentThread)
{
// Pretenure Trigger
pretenuredSinceLastFullGC += numBytes;
if (pretenuredSinceLastFullGC > PretenureHardGCTrigger)
{
GC.InvokeMajorCollection(currentThread);
}
// Potentially Join a collection
GC.CheckForNeededGCWork(currentThread);
int maxAlignmentOverhead = unchecked ((int)alignment) - UIntPtr.Size;
UIntPtr pageCount =
PageTable.PageCount(numBytes + maxAlignmentOverhead);
bool fCleanPages = true;
UIntPtr page = PageManager.EnsurePages(currentThread, pageCount,
largeObjectGeneration,
ref fCleanPages);
int unusedBytes =
unchecked ((int)(PageTable.RegionSize(pageCount) - numBytes));
int unusedCacheLines =
unchecked ((int)(unusedBytes - maxAlignmentOverhead)) >> 5;
int pageOffset = 0;
if (unusedCacheLines != 0)
{
pageOffset = (bigOffset % unusedCacheLines) << 5;
bigOffset++;
}
UIntPtr pageStart = PageTable.PageAddr(page);
for (int i = 0; i < pageOffset; i += UIntPtr.Size)
{
Allocator.WriteAlignment(pageStart + i);
}
UIntPtr unalignedStartAddr = pageStart + pageOffset;
UIntPtr startAddr =
Allocator.AlignedAllocationPtr(unalignedStartAddr,
pageStart + unusedBytes,
alignment);
pageOffset +=
unchecked ((int)(uint)(startAddr - unalignedStartAddr));
if (pageOffset < unusedBytes)
{
BumpAllocator.WriteUnusedMarker(pageStart + pageOffset + numBytes);
}
UIntPtr resultAddr = startAddr + PreHeader.Size;
InteriorPtrTable.SetFirst(resultAddr);
VTable.Assert(PageTable.Page(resultAddr) <
PageTable.Page(startAddr + numBytes - 1),
"Big object should cross pages");
if (GC.remsetType == RemSetType.Cards)
{
#if DONT_RECORD_OBJALLOC_IN_OFFSETTABLE
#else
OffsetTable.SetLast(resultAddr);
#endif
}
return(resultAddr);
}
