private static void CheckNumRectArray(IHeapConnector arrayRef, int count)
{
for (int i = 0; i < count; i++)
{
if (((IValueRead <RCNumRectangle>)arrayRef.AccessArrayItem(i)).Read() != new RCNumRectangle(i, i + 1, i + 2, i + 3))
{
throw new Exception("Mismatch!");
}
}
}
private static void CheckNumArray(IHeapConnector arrayRef, int count)
{
for (int i = 0; i < count; i++)
{
if (((IValueRead <RCNumber>)arrayRef.AccessArrayItem(i)).Read() != i)
{
throw new Exception("Mismatch!");
}
}
}
private static IHeapConnector CreateNumRectArray(IHeapManagerInternals heapMgr, int count)
{
IHeapConnector retObj = heapMgr.NewArray(heapMgr.GetHeapType("numrect").ID, count);
for (int i = 0; i < count; i++)
{
((IValueWrite <RCNumRectangle>)retObj.AccessArrayItem(i)).Write(new RCNumRectangle(i, i + 1, i + 2, i + 3));
}
return(retObj);
}
private static IHeapConnector CreateNumArray(IHeapManagerInternals heapMgr, int count)
{
IHeapConnector retObj = heapMgr.NewArray(heapMgr.GetHeapType("num").ID, count);
for (int i = 0; i < count; i++)
{
((IValueWrite <RCNumber>)retObj.AccessArrayItem(i)).Write((RCNumber)i);
}
return(retObj);
}
private static void CheckTestObj(IHeapConnector obj)
{
CheckByteArray(obj.AccessField(TESTTYPE_BYTEARRAY_IDX).Dereference(), 1);
CheckShortArray(obj.AccessField(TESTTYPE_SHORTARRAY_IDX).Dereference(), 2);
CheckIntArray(obj.AccessField(TESTTYPE_INTARRAY_IDX).Dereference(), 3);
CheckLongArray(obj.AccessField(TESTTYPE_LONGARRAY_IDX).Dereference(), 4);
CheckNumArray(obj.AccessField(TESTTYPE_NUMARRAY_IDX).Dereference(), 5);
CheckIntVectArray(obj.AccessField(TESTTYPE_INTVECTARRAY_IDX).Dereference(), 6);
CheckNumVectArray(obj.AccessField(TESTTYPE_NUMVECTARRAY_IDX).Dereference(), 7);
CheckIntRectArray(obj.AccessField(TESTTYPE_INTRECTARRAY_IDX).Dereference(), 8);
CheckNumRectArray(obj.AccessField(TESTTYPE_NUMRECTARRAY_IDX).Dereference(), 9);
}
private static void DeleteTestObj(IHeapConnector obj)
{
obj.AccessField(TESTTYPE_BYTEARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_SHORTARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_INTARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_LONGARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_NUMARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_INTVECTARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_NUMVECTARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_INTRECTARRAY_IDX).Dereference().DeleteArray();
obj.AccessField(TESTTYPE_NUMRECTARRAY_IDX).Dereference().DeleteArray();
obj.Delete();
}
/// <see cref="IHeapedFieldAccessor.AttachToHeap"/>
public void AttachToHeap(IHeapConnector connector)
{
if (!this.isReadyToUse)
{
throw new InvalidOperationException("Heap accessor is not ready to use!");
}
if (this.connector != null)
{
throw new InvalidOperationException("Heap accessor already attached to the heap!");
}
this.connector = connector;
this.SynchToHeap();
}
private static IHeapConnector CreateTestObj(IHeapManagerInternals heapMgr)
{
IHeapConnector retObj = heapMgr.New(testType.ID);
retObj.AccessField(TESTTYPE_BYTEARRAY_IDX).PointTo(CreateByteArray(heapMgr, 1));
retObj.AccessField(TESTTYPE_SHORTARRAY_IDX).PointTo(CreateShortArray(heapMgr, 2));
retObj.AccessField(TESTTYPE_INTARRAY_IDX).PointTo(CreateIntArray(heapMgr, 3));
retObj.AccessField(TESTTYPE_LONGARRAY_IDX).PointTo(CreateLongArray(heapMgr, 4));
retObj.AccessField(TESTTYPE_NUMARRAY_IDX).PointTo(CreateNumArray(heapMgr, 5));
retObj.AccessField(TESTTYPE_INTVECTARRAY_IDX).PointTo(CreateIntVectArray(heapMgr, 6));
retObj.AccessField(TESTTYPE_NUMVECTARRAY_IDX).PointTo(CreateNumVectArray(heapMgr, 7));
retObj.AccessField(TESTTYPE_INTRECTARRAY_IDX).PointTo(CreateIntRectArray(heapMgr, 8));
retObj.AccessField(TESTTYPE_NUMRECTARRAY_IDX).PointTo(CreateNumRectArray(heapMgr, 9));
return(retObj);
}
/// <see cref="IHeapConnector.PointTo"/>
public void PointTo(IHeapConnector target)
{
if (target != null)
{
HeapConnector targetInstance = (HeapConnector)target;
if (this.dataType.PointedTypeID != targetInstance.dataType.ID)
{
throw new HeapException("Type mismatch!");
}
this.heap.WriteInt(this.dataAddress, targetInstance.dataAddress);
}
else
{
this.heap.WriteInt(this.dataAddress, 0);
}
}
static void TestSimulationHeap()
{
List <HeapType> testMetadata = new List <HeapType>()
{
new HeapType("Unit", new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("HitPoints", "short"),
new KeyValuePair <string, string>("TestArray", "int*"),
new KeyValuePair <string, string>("TestPtrArray", "Building**"),
new KeyValuePair <string, string>("TestPtr", "Building*"),
}),
new HeapType("Building", new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("HitPoints", "short"),
new KeyValuePair <string, string>("BuildStatus", "short"),
}),
};
IHeapManagerInternals heapMgr = new HeapManager(testMetadata);
IHeapType unitType = heapMgr.GetHeapType("Unit");
int UNIT_HP_IDX = unitType.GetFieldIdx("HitPoints");
short UNIT_HP_TID = unitType.GetFieldTypeID("HitPoints");
int UNIT_TESTARRAY_IDX = unitType.GetFieldIdx("TestArray");
short UNIT_TESTARRAY_TID = unitType.GetFieldTypeID("TestArray");
int UNIT_TESTPTRARRAY_IDX = unitType.GetFieldIdx("TestPtrArray");
short UNIT_TESTPTRARRAY_TID = unitType.GetFieldTypeID("TestPtrArray");
int UNIT_TESTPTR_IDX = unitType.GetFieldIdx("TestPtr");
short UNIT_TESTPTR_TID = unitType.GetFieldTypeID("TestPtr");
IHeapType buildingType = heapMgr.GetHeapType("Building");
int BUILDING_HP_IDX = buildingType.GetFieldIdx("HitPoints");
short BUILDING_HP_TID = buildingType.GetFieldTypeID("HitPoints");
int BUILDING_BUILDSTATUS_IDX = buildingType.GetFieldIdx("BuildStatus");
short BUILDING_BUILDSTATUS_TID = buildingType.GetFieldTypeID("BuildStatus");
Stopwatch watch = new Stopwatch();
watch.Start();
for (int j = 0; j < 100000; j++)
{
IHeapConnector unit = heapMgr.New(unitType.ID);
IHeapConnector building0 = heapMgr.New(buildingType.ID);
IHeapConnector building1 = heapMgr.New(buildingType.ID);
((IValueWrite <short>)building0.AccessField(BUILDING_HP_IDX)).Write(100);
((IValueWrite <short>)building0.AccessField(BUILDING_BUILDSTATUS_IDX)).Write(50);
((IValueWrite <short>)building1.AccessField(BUILDING_HP_IDX)).Write(50);
((IValueWrite <short>)building1.AccessField(BUILDING_BUILDSTATUS_IDX)).Write(100);
((IValueWrite <short>)unit.AccessField(UNIT_HP_IDX)).Write(88);
unit.AccessField(UNIT_TESTPTR_IDX).PointTo(building0);
unit.AccessField(UNIT_TESTARRAY_IDX).PointTo(heapMgr.NewArray(heapMgr.GetHeapType("int").ID, 5));
for (int i = 0; i < 5; ++i)
{
((IValueWrite <int>)unit.AccessField(UNIT_TESTARRAY_IDX).Dereference().AccessArrayItem(i)).Write(i);
}
unit.AccessField(UNIT_TESTPTRARRAY_IDX).PointTo(heapMgr.NewArray(heapMgr.GetHeapType("Building*").ID, 5));
unit.AccessField(UNIT_TESTPTRARRAY_IDX).Dereference().AccessArrayItem(0).PointTo(building0);
unit.AccessField(UNIT_TESTPTRARRAY_IDX).Dereference().AccessArrayItem(1).PointTo(building1);
unit.AccessField(UNIT_TESTARRAY_IDX).Dereference().DeleteArray();
unit.AccessField(UNIT_TESTPTRARRAY_IDX).Dereference().DeleteArray();
unit.Delete();
building0.Delete();
building1.Delete();
}
watch.Stop();
// TODO: test heap saving/loading
}
public static bool StressTest()
{
HeapManager heapMgr = new HeapManager(testMetadata);
heapMgr.CreateHeap();
GetIDs(heapMgr);
Stopwatch watch = new Stopwatch();
watch.Start();
IHeapConnector prevObj = null;
IHeapConnector[] allObjects = new IHeapConnector[100];
for (int i = 0; i < 100; i++)
{
IHeapConnector currObj = CreateTestObj(heapMgr);
allObjects[i] = currObj;
if (prevObj != null)
{
prevObj.AccessField(TESTTYPE_NEXT_IDX).PointTo(currObj);
}
prevObj = currObj;
}
//byte[] savedHeap = heapMgr.UnloadHeap(new List<IHeapConnector>() { allObjects[0] });
//List<IHeapConnector> savedRefs = heapMgr.LoadHeap(savedHeap);
//if (savedRefs.Count != 1) { throw new Exception("Load error!"); }
//IHeapConnector curr = savedRefs[0];
//int objIdx = 0;
//do
//{
// allObjects[objIdx] = curr;
// objIdx++;
// CheckTestObj(curr);
// curr = curr.AccessField(TESTTYPE_NEXT_IDX).Dereference();
//} while (curr != null);
for (int i = 0; i < 50; i++)
{
DeleteTestObj(allObjects[2 * i + 1]);
allObjects[2 * i].AccessField(TESTTYPE_NEXT_IDX).PointTo(i < 49 ? allObjects[2 * i + 2] : null);
}
for (int i = 0; i < 50; i++)
{
DeleteTestObj(allObjects[2 * i]);
}
watch.Stop();
FieldInfo freeSectionsHeadFI = typeof(HeapManager).GetField("freeSectionsHead", BindingFlags.NonPublic | BindingFlags.Instance);
HeapSection freeSectionsHead = (HeapSection)freeSectionsHeadFI.GetValue(heapMgr);
return(freeSectionsHead.Address == 4 &&
freeSectionsHead.Length == -1 &&
freeSectionsHead.Next == null &&
freeSectionsHead.Prev == null);
}
