dan/Cosmos
1
0
Fork 0
mirror of https://github.com/danbulant/Cosmos synced 2026-06-03 14:50:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

modified Ptr

Browse source
This commit is contained in:
ralfkronemeyer_cp 2008-08-14 16:22:28 +00:00
parent 710cf1c333
commit def59164b3
1 changed files with 67 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

134
source/Playgrounds/Ralf/EsxTest/Heap.cs
View file

@ -226,23 +226,23 @@ namespace EsxTest
internal unsafe void AllocateInParent() internal unsafe void AllocateInParent()
{ {
var parentHeader = (FragmentHeader*) ParentAddress; var parentHeaderPtr = (FragmentHeader*) ParentAddress;
#region validation #region validation
//general heap logic problem, if one these exceptions occurs //general heap logic problem, if one these exceptions occurs
if ((*parentHeader).HasData) if (parentHeaderPtr->HasData)
{ {
Heap.CallException("AllocateInParent failed: Data already exits", FragmentAddress); Heap.CallException("AllocateInParent failed: Data already exits", FragmentAddress);
} }
if (IsChild2OfParent) if (IsChild2OfParent)
{ {
if ((*parentHeader).HasChild2) if (parentHeaderPtr->HasChild2)
{ {
Heap.CallException("AllocateInParent failed: Child2 already exits", FragmentAddress); Heap.CallException("AllocateInParent failed: Child2 already exits", FragmentAddress);
} }
} }
else else
{ {
if ((*parentHeader).HasChild1) if (parentHeaderPtr->HasChild1)
{ {
Heap.CallException("AllocateInParent failed: Child1 already exits", FragmentAddress); Heap.CallException("AllocateInParent failed: Child1 already exits", FragmentAddress);
} }
@ -250,34 +250,34 @@ namespace EsxTest
#endregion #endregion
if (IsChild2OfParent) if (IsChild2OfParent)
{ {
(*parentHeader).HasChild2 = true; parentHeaderPtr->HasChild2 = true;
} }
else else
{ {
(*parentHeader).HasChild1 = true; parentHeaderPtr->HasChild1 = true;
} }
} }
internal unsafe void FreeInParent() internal unsafe void FreeInParent()
{ {
var parentHeader = (FragmentHeader*) ParentAddress; var parentHeaderPtr = (FragmentHeader*) ParentAddress;
#region validation #region validation
//general heap logic problem, if one these exceptions occurs //general heap logic problem, if one these exceptions occurs
if ((*parentHeader).HasData) if (parentHeaderPtr->HasData)
{ {
Heap.CallException("FreeInParent failed: Parent HasData ", FragmentAddress); Heap.CallException("FreeInParent failed: Parent HasData ", FragmentAddress);
} }
if (IsChild2OfParent) if (IsChild2OfParent)
{ {
if (!(*parentHeader).HasChild2) if (!parentHeaderPtr->HasChild2)
{ {
Heap.CallException("FreeInParent failed: Child2 doesnt exits", FragmentAddress); Heap.CallException("FreeInParent failed: Child2 doesnt exits", FragmentAddress);
} }
} }
else else
{ {
if (!(*parentHeader).HasChild1) if (!parentHeaderPtr->HasChild1)
{ {
Heap.CallException("FreeInParent failed: Child1 doesnt exits", FragmentAddress); Heap.CallException("FreeInParent failed: Child1 doesnt exits", FragmentAddress);
} }
@ -285,11 +285,11 @@ namespace EsxTest
#endregion #endregion
if (IsChild2OfParent) if (IsChild2OfParent)
{ {
(*parentHeader).HasChild2 = false; parentHeaderPtr->HasChild2 = false;
} }
else else
{ {
(*parentHeader).HasChild1 = false; parentHeaderPtr->HasChild1 = false;
} }
} }
@ -454,8 +454,8 @@ namespace EsxTest
Size = EndAddress - StartAddress; Size = EndAddress - StartAddress;
MaxFragmentDataSize = Size - FragmentHeader.HeaderSize; MaxFragmentDataSize = Size - FragmentHeader.HeaderSize;
CalculateFragmentSizes(Size); CalculateFragmentSizes(Size);
var RootHeader = (FragmentHeader*)StartAddress; var rootHeaderPtr = (FragmentHeader*)StartAddress;
(*RootHeader).Initialize(MaxFragmentSizeIndex); rootHeaderPtr->Initialize(MaxFragmentSizeIndex);
//ClearFragment(StartAddress, GetFragmentDataSize((*RootHeader).SizeIndex)); //this is bad for ESX Server //ClearFragment(StartAddress, GetFragmentDataSize((*RootHeader).SizeIndex)); //this is bad for ESX Server
#if NOCOSMOS #if NOCOSMOS
Debug("CacheStackPointerAddress=" + CacheStackPointerAddress); Debug("CacheStackPointerAddress=" + CacheStackPointerAddress);
@ -504,15 +504,15 @@ namespace EsxTest
{ {
CallException("MemAlloc: Out of memory"); CallException("MemAlloc: Out of memory");
} }
var fragmentHeader = (FragmentHeader*)fragmentAddress; var fragmentHeaderPtr = (FragmentHeader*)fragmentAddress;
(*fragmentHeader).HasData = true; fragmentHeaderPtr->HasData = true;
#region validation #region validation
//general heap logic problem, if one these exceptions occurs //general heap logic problem, if one these exceptions occurs
if ((*fragmentHeader).SizeIndex != sizeIndex) if (fragmentHeaderPtr->SizeIndex != sizeIndex)
{ {
CallException("MemAlloc: SizeIndex wrong", fragmentAddress); CallException("MemAlloc: SizeIndex wrong", fragmentAddress);
} }
if (GetFragmentDataSize((*fragmentHeader).SizeIndex) < size) if (GetFragmentDataSize(fragmentHeaderPtr->SizeIndex) < size)
{ {
CallException("MemAlloc: HeaderSize mismatch", fragmentAddress); CallException("MemAlloc: HeaderSize mismatch", fragmentAddress);
} }
@ -520,7 +520,7 @@ namespace EsxTest
ClearFragment(fragmentAddress,size); ClearFragment(fragmentAddress,size);
++HeapCounter.MemAlloc; ++HeapCounter.MemAlloc;
++HeapCounter.Count; ++HeapCounter.Count;
HeapCounter.DataSize += GetFragmentSize((*fragmentHeader).SizeIndex); HeapCounter.DataSize += GetFragmentSize(fragmentHeaderPtr->SizeIndex);
Debug(fragmentAddress); Debug(fragmentAddress);
#if NOCOSMOS #if NOCOSMOS
Debug("End Malloc HeaderSize=" + size); Debug("End Malloc HeaderSize=" + size);
@ -541,14 +541,14 @@ namespace EsxTest
CallException("MemFree: pointer==0"); CallException("MemFree: pointer==0");
} }
var fragmentAddress = pointer - FragmentHeader.HeaderSize; var fragmentAddress = pointer - FragmentHeader.HeaderSize;
var fragmentHeader = (FragmentHeader*)fragmentAddress; var fragmentHeaderPtr = (FragmentHeader*)fragmentAddress;
Debug(fragmentAddress); Debug(fragmentAddress);
(*fragmentHeader).HasData = false; fragmentHeaderPtr->HasData = false;
(*fragmentHeader).FreeInParent(); fragmentHeaderPtr->FreeInParent();
PushFreeFragmentAddress((*fragmentHeader).SizeIndex, fragmentAddress); PushFreeFragmentAddress(fragmentHeaderPtr->SizeIndex, fragmentAddress);
++HeapCounter.MemFree; ++HeapCounter.MemFree;
--HeapCounter.Count; --HeapCounter.Count;
HeapCounter.DataSize -= GetFragmentSize((*fragmentHeader).SizeIndex); HeapCounter.DataSize -= GetFragmentSize(fragmentHeaderPtr->SizeIndex);
Debug("End MemFree"); Debug("End MemFree");
} }
@ -563,8 +563,8 @@ namespace EsxTest
Debug(fragmentAddress); Debug(fragmentAddress);
#region validation #region validation
//general heap logic problem, if one these exceptions occurs //general heap logic problem, if one these exceptions occurs
var header = (FragmentHeader*) fragmentAddress; var headerPtr = (FragmentHeader*) fragmentAddress;
if (size>GetFragmentDataSize((*header).SizeIndex)) if (size>GetFragmentDataSize(headerPtr->SizeIndex))
{ {
CallException("ClearFragment: size mismatch", fragmentAddress); CallException("ClearFragment: size mismatch", fragmentAddress);
} }
@ -621,8 +621,8 @@ namespace EsxTest
{ {
if (address != StartAddress) if (address != StartAddress)
{ {
var header = (FragmentHeader*) address; var headerPtr = (FragmentHeader*) address;
(*header).AllocateInParent(); headerPtr->AllocateInParent();
} }
} }
else else
@ -657,43 +657,43 @@ namespace EsxTest
++DebugTab; ++DebugTab;
++HeapCounter.SearchTotal; ++HeapCounter.SearchTotal;
UInt32 freeAddress = 0; UInt32 freeAddress = 0;
var header = (FragmentHeader*)address; var headerPtr = (FragmentHeader*)address;
if (sizeIndex+1 <= (*header).SizeIndex) if (sizeIndex+1 <= headerPtr->SizeIndex)
{ {
if (sizeIndex+1 == (*header).SizeIndex) if (sizeIndex+1 == headerPtr->SizeIndex)
{ {
if ((*header).IsEmpty) if (headerPtr->IsEmpty)
{ {
freeAddress = (*header).Child1Address; freeAddress = headerPtr->Child1Address;
var child1Header = (FragmentHeader*) freeAddress; var child1HeaderPtr = (FragmentHeader*) freeAddress;
(*child1Header).Initialize(sizeIndex); child1HeaderPtr->Initialize(sizeIndex);
(*header).HasChild1 = true; headerPtr->HasChild1 = true;
var child2Header = (FragmentHeader*)(*header).Child2Address; var child2HeaderPtr = (FragmentHeader*)headerPtr->Child2Address;
(*child2Header).Initialize(sizeIndex); child2HeaderPtr->Initialize(sizeIndex);
(*child2Header).IsChild2OfParent = true; child2HeaderPtr->IsChild2OfParent = true;
PushFreeFragmentAddress(sizeIndex, (*header).Child2Address); PushFreeFragmentAddress(sizeIndex, headerPtr->Child2Address);
++HeapCounter.SearchSuccess; ++HeapCounter.SearchSuccess;
} }
} }
if (freeAddress == 0) if (freeAddress == 0)
{ {
if ((*header).HasChild1) if (headerPtr->HasChild1)
{ {
freeAddress = SearchFreeFragmentAddress(sizeIndex, (*header).Child1Address); freeAddress = SearchFreeFragmentAddress(sizeIndex, headerPtr->Child1Address);
} }
if (freeAddress == 0) if (freeAddress == 0)
{ {
if ((*header).HasChild2) if (headerPtr->HasChild2)
{ {
freeAddress = SearchFreeFragmentAddress(sizeIndex , (*header).Child2Address); freeAddress = SearchFreeFragmentAddress(sizeIndex , headerPtr->Child2Address);
} }
} }
} }
} }
if (freeAddress != 0) if (freeAddress != 0)
{ {
var freeHeader = (FragmentHeader*) freeAddress; var freeHeaderPtr = (FragmentHeader*) freeAddress;
if ((*freeHeader).SizeIndex!=sizeIndex) if (freeHeaderPtr->SizeIndex!=sizeIndex)
{ {
CallException("SearchFreeFragmentAddress: SizeIndex mismatch", freeAddress); CallException("SearchFreeFragmentAddress: SizeIndex mismatch", freeAddress);
} }
@ -742,28 +742,28 @@ namespace EsxTest
} }
else else
{ {
var parentHeader = (FragmentHeader*) parentFragmentAddress; var parentHeaderPtr = (FragmentHeader*) parentFragmentAddress;
if ((*parentHeader).HasChild1 && (*parentHeader).HasChild2) if (parentHeaderPtr->HasChild1 && parentHeaderPtr->HasChild2)
{ {
//Out of memory //Out of memory
return 0; return 0;
} }
(*parentHeader).HasChild1 = true; parentHeaderPtr->HasChild1 = true;
fragmentAddress = (*parentHeader).Child1Address; fragmentAddress = parentHeaderPtr->Child1Address;
var child2Address = (*parentHeader).Child2Address; var child2Address = parentHeaderPtr->Child2Address;
var child2Header = (FragmentHeader*) child2Address; var child2HeaderPtr = (FragmentHeader*) child2Address;
(*child2Header).Initialize(sizeIndex); child2HeaderPtr->Initialize(sizeIndex);
(*child2Header).IsChild2OfParent = true; child2HeaderPtr->IsChild2OfParent = true;
PushFreeFragmentAddress(sizeIndex, child2Address); PushFreeFragmentAddress(sizeIndex, child2Address);
if (fragmentAddress == 0) if (fragmentAddress == 0)
{ {
CallException("CreateFragment failed"); CallException("CreateFragment failed");
} }
++HeapCounter.Create; ++HeapCounter.Create;
var fragmentHeader = (FragmentHeader*) fragmentAddress; var fragmentHeaderPtr = (FragmentHeader*) fragmentAddress;
(*fragmentHeader).Initialize(sizeIndex); fragmentHeaderPtr->Initialize(sizeIndex);
--DebugTab; --DebugTab;
Debug("Created:"); Debug("Created:");
Debug(fragmentAddress); Debug(fragmentAddress);
@ -1073,32 +1073,32 @@ namespace EsxTest
//general heap logic problem, if one these exceptions occurs //general heap logic problem, if one these exceptions occurs
var header = (FragmentHeader*)address; var headerPtr = (FragmentHeader*)address;
if ((*header).SizeIndex != sizeIndex) if (headerPtr->SizeIndex != sizeIndex)
{ {
CallException("PushFreeFragmentAddress: sizeIndex mismatch", address); CallException("PushFreeFragmentAddress: sizeIndex mismatch", address);
} }
if (!(*header).IsEmpty) if (!headerPtr->IsEmpty)
{ {
CallException("PushFreeFragmentAddress: not empty", address); CallException("PushFreeFragmentAddress: not empty", address);
} }
if ((*header).HasParent) if (headerPtr->HasParent)
{ {
var parentHeader = (FragmentHeader*) (*header).ParentAddress; var parentHeaderPtr = (FragmentHeader*) headerPtr->ParentAddress;
if ((*parentHeader).HasData) if (parentHeaderPtr->HasData)
{ {
CallException("PushFreeFragmentAddress: Parent HasData"); CallException("PushFreeFragmentAddress: Parent HasData");
} }
if ((*header).IsChild2OfParent) if (headerPtr->IsChild2OfParent)
{ {
if ((*parentHeader).HasChild2) if (parentHeaderPtr->HasChild2)
{ {
CallException("PushFreeFragmentAddress: ChildBit2 in Parent"); CallException("PushFreeFragmentAddress: ChildBit2 in Parent");
} }
} }
else else
{ {
if ((*parentHeader).HasChild1) if (parentHeaderPtr->HasChild1)
{ {
CallException("PushFreeFragmentAddress: ChildBit1 in Parent"); CallException("PushFreeFragmentAddress: ChildBit1 in Parent");
} }
@ -1185,8 +1185,8 @@ namespace EsxTest
#endif #endif
if (address != 0) if (address != 0)
{ {
var header = (FragmentHeader*) address; var headerPtr = (FragmentHeader*) address;
if ((*header).IsEmpty) if (headerPtr->IsEmpty)
{ {
++HeapCounter.CachePop; ++HeapCounter.CachePop;
#if NOCOSMOS #if NOCOSMOS