// Value-Type.types will be boxed
public static tAsyncCall *Internal_SetValue(tJITCallNative *pCallNative, byte *pThis_, byte *pParams, byte *pReturnValue)
{
tSystemArray * pArray = (tSystemArray *)pThis_;
tMD_TypeDef * pArrayType, pObjType;
uint index, elementSize;
/*HEAP_PTR*/ byte *obj;
tMD_TypeDef * pElementType;
byte * pElement;
pArrayType = Heap.GetType(pThis_);
obj = (*((byte **)(pParams + 0)));
pObjType = Heap.GetType(obj);
pElementType = pArrayType->pArrayElementType;
// Check to see if the Type is ok to put in the array
if (!(Type.IsAssignableFrom(pElementType, pObjType) != 0 ||
(pElementType->pGenericDefinition == Type.types[Type.TYPE_SYSTEM_NULLABLE] &&
pElementType->ppClassTypeArgs[0] == pObjType)))
{
// Can't be done
Sys.INTERNALCALL_RESULT_U32(pReturnValue, 0);
return(null);
}
index = (*((uint *)(pParams + Sys.S_PTR)));
#if WIN32 && _DEBUG
// Do a bounds-check
if (index >= pArray->length)
{
printf("[Array] Internal_SetValue() Bounds-check failed\n");
__debugbreak();
}
#endif
elementSize = pElementType->arrayElementSize;
pElement = tSystemArray.GetElements(pArray) + elementSize * index;
if (pElementType->isValueType != 0)
{
if (pElementType->pGenericDefinition == Type.types[Type.TYPE_SYSTEM_NULLABLE])
{
// Nullable type, so treat specially
if (obj == null)
{
Mem.memset(pElement, 0, elementSize);
}
else
{
*(uint *)pElement = 1;
Mem.memcpy(pElement + 4, obj, elementSize - 4);
}
}
else
{
// Get the value out of the box
Mem.memcpy(pElement, obj, elementSize);
}
}
else
{
// This must be a reference type, so it must be 32-bits wide
*(/*HEAP_PTR*/ byte **)pElement = obj;
}
Sys.INTERNALCALL_RESULT_U32(pReturnValue, 1);
return(null);
}
public static void GarbageCollect()
{
#if NO
tHeapRoots heapRoots;
tHeapEntry * pNode;
tHeapEntry **pUp = stackalloc tHeapEntry *[MAX_TREE_DEPTH * 2];
int top;
tHeapEntry * pToDelete = null;
SIZE_T orgHeapSize = trackHeapSize;
uint orgNumNodes = numNodes;
#if DIAG_GC
ulong startTime;
#endif
Mem.heapcheck();
numCollections++;
#if DIAG_GC
startTime = microTime();
#endif
heapRoots.capacity = 64;
heapRoots.num = 0;
heapRoots.pHeapEntries = (tHeapRootEntry *)Mem.malloc(heapRoots.capacity * (SIZE_T)sizeof(tHeapRootEntry));
Thread.GetHeapRoots(&heapRoots);
CLIFile.GetHeapRoots(&heapRoots);
// Mark phase
while (heapRoots.num > 0)
{
tHeapRootEntry *pRootsEntry;
uint i;
uint moreRootsAdded = 0;
uint rootsEntryNumPointers;
void ** pRootsEntryMem;
// Get a piece of memory off the list of heap memory roots.
pRootsEntry = &heapRoots.pHeapEntries[heapRoots.num - 1];
rootsEntryNumPointers = pRootsEntry->numPointers;
pRootsEntryMem = pRootsEntry->pMem;
// Mark this entry as done
pRootsEntry->numPointers = 0;
pRootsEntry->pMem = null;
// Iterate through all pointers in it
for (i = 0; i < rootsEntryNumPointers; i++)
{
void *pMemRef = pRootsEntryMem[i];
// Quick escape for known non-memory
if (pMemRef == null)
{
continue;
}
// Find this piece of heap memory in the tracking tree.
// Note that the 2nd memory address comparison MUST be >, not >= as might be expected,
// to allow for a zero-sized memory to be detected (and not garbage collected) properly.
// E.g. The object class has zero memory.
pNode = pHeapTreeRoot;
while (pNode != nil)
{
if (pMemRef < (void *)pNode)
{
pNode = (tHeapEntry *)pNode->pLink[0];
}
else if ((byte *)pMemRef > ((byte *)pNode) + GetSize(pNode) + sizeof(tHeapEntry))
{
pNode = (tHeapEntry *)pNode->pLink[1];
}
else
{
// Found memory. See if it's already been marked.
// If it's already marked, then don't do anything.
// It it's not marked, then add all of its memory to the roots, and mark it.
if (pNode->marked == 0)
{
tMD_TypeDef *pType = pNode->pTypeDef;
// Not yet marked, so mark it, and add it to heap roots.
pNode->marked = 1;
// Don't look at the contents of strings, arrays of primitive Type.types, or WeakReferences
if (pType->stackType == EvalStack.EVALSTACK_O ||
pType->stackType == EvalStack.EVALSTACK_VALUETYPE ||
pType->stackType == EvalStack.EVALSTACK_PTR)
{
if (pType != Type.types[Type.TYPE_SYSTEM_STRING] &&
(!MetaData.TYPE_ISARRAY(pType) ||
pType->pArrayElementType->stackType == EvalStack.EVALSTACK_O ||
pType->pArrayElementType->stackType == EvalStack.EVALSTACK_VALUETYPE ||
pType->pArrayElementType->stackType == EvalStack.EVALSTACK_PTR))
{
if (pType != Type.types[Type.TYPE_SYSTEM_WEAKREFERENCE])
{
Heap.SetRoots(&heapRoots, ((byte *)&pNode->pSync + sizeof(PTR)), GetSize(pNode));
moreRootsAdded = 1;
}
}
}
}
break;
}
}
}
if (moreRootsAdded == 0)
{
heapRoots.num--;
}
}
Mem.free(heapRoots.pHeapEntries);
// Sweep phase
// Traverse nodes
pUp[0] = pHeapTreeRoot;
top = 1;
while (top != 0)
{
// Get this node
pNode = pUp[--top];
// Act on this node
if (pNode->marked != 0)
{
if (pNode->marked != 0xff)
{
// Still in use (but not marked undeletable), so unmark
pNode->marked = 0;
}
}
else
{
// Not in use any more, so put in deletion queue if it does not need Finalizing
// If it does need Finalizing, then don't garbage collect, and put in Finalization queue.
if (pNode->needToFinalize != 0)
{
if (pNode->needToFinalize == 1)
{
Finalizer.AddFinalizer((/*HEAP_PTR*/ byte *)pNode + sizeof(tHeapEntry));
// Mark it has having been placed in the finalization queue.
// When it has been finalized, then this will be set to 0
pNode->needToFinalize = 2;
// If this object is being targetted by weak-ref(s), handle it
if (pNode->pSync != null)
{
RemoveWeakRefTarget(pNode, 0);
Mem.free(pNode->pSync);
}
}
}
else
{
// If this object is being targetted by weak-ref(s), handle it
if (pNode->pSync != null)
{
RemoveWeakRefTarget(pNode, 1);
Mem.free(pNode->pSync);
}
// Use pSync to point to next entry in this linked-list.
pNode->pSync = (tSync *)pToDelete;
pToDelete = pNode;
}
}
// Get next node(s)
if (pNode->pLink[1] != (PTR)nil)
{
pUp[top++] = (tHeapEntry *)pNode->pLink[1];
}
if (pNode->pLink[0] != (PTR)nil)
{
pUp[top++] = (tHeapEntry *)pNode->pLink[0];
}
}
// Delete all unused memory nodes.
while (pToDelete != null)
{
tHeapEntry *pThis = pToDelete;
pToDelete = (tHeapEntry *)(pToDelete->pSync);
pHeapTreeRoot = TreeRemove(pHeapTreeRoot, pThis);
if (pThis->monoGCHandle == 1)
{
void *hptr = *(void **)((byte *)pThis + sizeof(tHeapEntry));
if (hptr != null)
{
GCHandle h = System.Runtime.InteropServices.GCHandle.FromIntPtr((System.IntPtr)hptr);
h.Free();
}
}
numNodes--;
trackHeapSize -= GetSize(pThis) + (uint)sizeof(tHeapEntry);
Mem.free(pThis);
}
Mem.heapcheck();
#if DIAG_GC
gcTotalTime += microTime() - startTime;
#endif
Sys.log_f(1, "--- GARBAGE --- [Size: %d -> %d] [Nodes: %d -> %d]\n",
orgHeapSize, trackHeapSize, orgNumNodes, numNodes);
#if DIAG_GC
Sys.log_f(1, "GC time = %d ms\n", gcTotalTime / 1000);
#endif
#endif
}