public virtual bool IsSpaceAvailable(int sizeInMb)
{
if (sizeInMb < 1)
return true;
bool isAvailable = true;
MemoryFailPoint _memoryFailPoint = null;
try
{
_memoryFailPoint = new MemoryFailPoint(sizeInMb);
}
catch (InsufficientMemoryException)
{
isAvailable = false;
}
catch (NotImplementedException e)
{
_logger.Warn("MemoryFailPoint is not implemented on this platform. The MemoryManager.IsSpaceAvailable() will just return true.");
}
finally
{
if (_memoryFailPoint != null)
_memoryFailPoint.Dispose();
}
return isAvailable;
}
public static bool EnsureMemoryAvailability(int expectedSizeMegaBytes)
{
if (expectedSizeMegaBytes < 0)
{
throw new ArgumentException("Param expectedSizeBytes should be positive", "expectedSizeMegaBytes");
}
bool available = true;
MemoryFailPoint p = null;
try
{
p = new MemoryFailPoint(expectedSizeMegaBytes);
}
catch(InsufficientMemoryException)
{
available = false;
}
finally
{
if(p != null)
{
try { p.Dispose(); }
catch(Exception)
{
// ignored
}
}
}
return available;
}
public static void MemoryFailPointTestNoThrow()
{
MemoryFailPoint memFailPoint = null;
memFailPoint = new MemoryFailPoint(1);
memFailPoint.Dispose();
memFailPoint = new MemoryFailPoint(2);
memFailPoint.Dispose();
}
private static bool CheckForFreeAddressSpace(ulong size, bool shouldThrow)
{
ulong num = MemoryFailPoint.MemFreeAfterAddress(null, size);
MemoryFailPoint.LastKnownFreeAddressSpace = (long)num;
MemoryFailPoint.LastTimeCheckingAddressSpace = (long)Environment.TickCount;
if (num < size && shouldThrow)
{
throw new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint_VAFrag"));
}
return(num >= size);
}
static void Main(String[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Environment.SetEnvironmentVariable("PATH", Environment.CurrentDirectory +@"\SciDLL;" + Environment.GetEnvironmentVariable("PATH"));
try
{
MemoryFailPoint mem = new MemoryFailPoint(100);
Application.Run(new MainWindow());
}
catch (InsufficientMemoryException e)
{
MessageBox.Show(e.ToString());
Environment.Exit(1);
}
}
private static unsafe bool CheckForFreeAddressSpace(ulong size, bool shouldThrow)
{
long num1;
MemoryFailPoint.LastKnownFreeAddressSpace = num1 = (long)MemoryFailPoint.MemFreeAfterAddress((void *)null, size);
MemoryFailPoint.LastTimeCheckingAddressSpace = (long)Environment.TickCount;
long num2 = (long)size;
if ((ulong)num1 < (ulong)num2 & shouldThrow)
{
throw new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint_VAFrag"));
}
long num3 = (long)size;
return((ulong)num1 >= (ulong)num3);
}
public unsafe MemoryFailPoint(int sizeInMegabytes)
{
if (sizeInMegabytes <= 0)
{
throw new ArgumentOutOfRangeException("sizeInMegabytes", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
ulong num = (ulong)((ulong)((long)sizeInMegabytes) << 20);
this._reservedMemory = num;
ulong num2 = (ulong)(Math.Ceiling(num / MemoryFailPoint.GCSegmentSize) * MemoryFailPoint.GCSegmentSize);
if (num2 >= MemoryFailPoint.TopOfMemory)
{
throw new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint_TooBig"));
}
ulong num3 = (ulong)(Math.Ceiling((double)sizeInMegabytes / 16.0) * 16.0);
num3 <<= 20;
ulong num4 = 0UL;
ulong num5 = 0UL;
int i = 0;
while (i < 3)
{
MemoryFailPoint.CheckForAvailableMemory(out num4, out num5);
ulong memoryFailPointReservedMemory = SharedStatics.MemoryFailPointReservedMemory;
ulong num6 = num2 + memoryFailPointReservedMemory;
bool flag = num6 < num2 || num6 < memoryFailPointReservedMemory;
bool flag2 = num4 < num3 + memoryFailPointReservedMemory + 16777216UL || flag;
bool flag3 = num5 < num6 || flag;
long num7 = (long)Environment.TickCount;
if (num7 > MemoryFailPoint.LastTimeCheckingAddressSpace + 10000L || num7 < MemoryFailPoint.LastTimeCheckingAddressSpace || MemoryFailPoint.LastKnownFreeAddressSpace < (long)num2)
{
MemoryFailPoint.CheckForFreeAddressSpace(num2, false);
}
bool flag4 = MemoryFailPoint.LastKnownFreeAddressSpace < (long)num2;
if (!flag2 && !flag3 && !flag4)
{
break;
}
switch (i)
{
case 0:
GC.Collect();
break;
case 1:
if (flag2)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
break;
}
finally
{
UIntPtr numBytes = new UIntPtr(num2);
void * ptr = Win32Native.VirtualAlloc(null, numBytes, 4096, 4);
if (ptr != null && !Win32Native.VirtualFree(ptr, UIntPtr.Zero, 32768))
{
__Error.WinIOError();
}
}
goto IL_183;
}
break;
case 2:
goto IL_183;
}
IL_1B6:
i++;
continue;
IL_183:
if (flag2 || flag3)
{
InsufficientMemoryException ex = new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint"));
throw ex;
}
if (flag4)
{
InsufficientMemoryException ex2 = new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint_VAFrag"));
throw ex2;
}
goto IL_1B6;
}
MemoryFailPoint.AddToLastKnownFreeAddressSpace((long)(-(long)num));
if (MemoryFailPoint.LastKnownFreeAddressSpace < 0L)
{
MemoryFailPoint.CheckForFreeAddressSpace(num2, true);
}
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
SharedStatics.AddMemoryFailPointReservation((long)num);
this._mustSubtractReservation = true;
}
}
static MemoryFailPoint()
{
MemoryFailPoint.GetMemorySettings(out MemoryFailPoint.GCSegmentSize, out MemoryFailPoint.TopOfMemory);
}
public unsafe MemoryFailPoint(int sizeInMegabytes)
{
if (sizeInMegabytes <= 0)
{
throw new ArgumentOutOfRangeException("sizeInMegabytes", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
ulong num1 = (ulong)sizeInMegabytes << 20;
this._reservedMemory = num1;
ulong size = (ulong)(Math.Ceiling((double)num1 / (double)MemoryFailPoint.GCSegmentSize) * (double)MemoryFailPoint.GCSegmentSize);
if (size >= MemoryFailPoint.TopOfMemory)
{
throw new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint_TooBig"));
}
ulong num2 = (ulong)(Math.Ceiling((double)sizeInMegabytes / 16.0) * 16.0) << 20;
ulong availPageFile = 0;
ulong totalAddressSpaceFree = 0;
for (int index = 0; index < 3; ++index)
{
MemoryFailPoint.CheckForAvailableMemory(out availPageFile, out totalAddressSpaceFree);
ulong pointReservedMemory = SharedStatics.MemoryFailPointReservedMemory;
ulong num3 = size + pointReservedMemory;
bool flag1 = num3 < size || num3 < pointReservedMemory;
bool flag2 = availPageFile < num2 + pointReservedMemory + 16777216UL | flag1;
bool flag3 = totalAddressSpaceFree < num3 | flag1;
long num4 = (long)Environment.TickCount;
if (num4 > MemoryFailPoint.LastTimeCheckingAddressSpace + 10000L || num4 < MemoryFailPoint.LastTimeCheckingAddressSpace || MemoryFailPoint.LastKnownFreeAddressSpace < (long)size)
{
MemoryFailPoint.CheckForFreeAddressSpace(size, false);
}
bool flag4 = (ulong)MemoryFailPoint.LastKnownFreeAddressSpace < size;
if (flag2 || flag3 || flag4)
{
switch (index)
{
case 0:
GC.Collect();
break;
case 1:
if (flag2)
{
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
void *address = Win32Native.VirtualAlloc((void *)null, new UIntPtr(size), 4096, 4);
if ((IntPtr)address != IntPtr.Zero && !Win32Native.VirtualFree(address, UIntPtr.Zero, 32768))
{
__Error.WinIOError();
}
}
break;
}
break;
case 2:
if (flag2 | flag3)
{
throw new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint"));
}
if (flag4)
{
throw new InsufficientMemoryException(Environment.GetResourceString("InsufficientMemory_MemFailPoint_VAFrag"));
}
break;
}
}
else
{
break;
}
}
MemoryFailPoint.AddToLastKnownFreeAddressSpace(-(long)num1);
if (MemoryFailPoint.LastKnownFreeAddressSpace < 0L)
{
MemoryFailPoint.CheckForFreeAddressSpace(size, true);
}
RuntimeHelpers.PrepareConstrainedRegions();
try
{
}
finally
{
SharedStatics.AddMemoryFailPointReservation((long)num1);
this._mustSubtractReservation = true;
}
}
