/// <summary> /// 添加谱面到缓存区 /// </summary> /// <param name="md5">谱面md5</param> /// <param name="beatmap">谱面</param> public unsafe void Add(string md5, CacheBeatmap beatmap) { MemoryStatusEx status = new MemoryStatusEx(); status.Length = (uint)sizeof(MemoryStatusEx); Win32.Api.Win32Api.GlobalMemoryStatusEx(out status); if (Marshal.GetLastWin32Error() != 0) { OutputHelper.Output("[osuTools::BeatmapCache] Failed to query memory usage. Operation aborted."); return; } else { double memPercent = (double)status.AvailablePhysicalMemory / status.TotalPhysicalMemory; /*OutputHelper.Output($"[osuTools::BeatmapCache] Current available memory: {status.AvailablePhysicalMemory / Math.Pow(1024, 2):f2}MB " + * $"({memPercent:p2}) Program used {(double)_currentProcess.WorkingSet64 / status.TotalPhysicalMemory:p2}");*/ if (memPercent > 0.95) { Enabled = false; Clear(); GC.Collect(); } else { Enabled = true; } } if (Enabled) { _beatmaps.Add(md5, beatmap); } }
void UpdateGPU(out float load, out float mem) { HWmon.Update(); float vramTotalGB = HWmon.GPUTotalMemory / 1024f, gpuMemLoad = HWmon.GPUMemoryLoad, vramUsed = vramTotalGB * (gpuMemLoad / 100f), vramFree = vramTotalGB - vramUsed, gpuMemCtrl = HWmon.GPUMemCtrlLoad, gpuLoad = HWmon.GPULoad, gpuTemp = HWmon.GPUTemperature, gpuFanRPM = HWmon.GPUFanSpeed, gpuFanLoad = HWmon.GPUFanLoad, gpuClock = HWmon.GPUClock; Sensor_GPU_MEM.Chart.Add(gpuMemLoad); Sensor_GPU_MEM.Value.Text = $"{vramFree:N2} GiB free\n{gpuMemLoad:N1} % usage\n{gpuMemCtrl:N1} % Ctrl"; Sensor_GPU_Load.Chart.Add(gpuLoad); Sensor_GPU_Load.Value.Text = $"{gpuLoad:N1} %\n{gpuTemp:N1} C\n{gpuClock:N0} MHz\n{gpuFanRPM:N0} RPM [{gpuFanLoad:N0}%]"; load = gpuLoad / 10f; mem = ((gpuMemLoad / 10f) - 7f).Min(0f) + (gpuMemCtrl / 10f); }
public static uint GetMemoryLoad() { if (_noGlobalMemoryStatusEx) { // In the absence of a measure of memory usage, act conservatively // and return a high value. Tweaking batch size configuration parameters // should help mitigate performance issues return(100); } try { var ms = new MemoryStatusEx(); if (GlobalMemoryStatusEx(ms)) { return(ms.dwMemoryLoad); } } catch (System.EntryPointNotFoundException) { // Indicates we are on a Mono platform that does not currently support this native method _noGlobalMemoryStatusEx = true; } return(100); }
public static uint GetMemoryLoad() { if (_noGlobalMemoryStatusEx) { // In the absence of a measure of memory usage, act conservatively // and return a high value. Tweaking batch size configuration parameters // should help mitigate performance issues return 100; } try { var ms = new MemoryStatusEx(); if (GlobalMemoryStatusEx(ms)) { return ms.dwMemoryLoad; } } catch (System.EntryPointNotFoundException) { // Indicates we are on a Mono platform that does not currently support this native method _noGlobalMemoryStatusEx = true; } return 100; }
private void Timer_Tick(object sender, EventArgs eventArgs) { MemoryStatusEx memoryInfo = new MemoryStatusEx(); memoryInfo.dwLength = (uint)Marshal.SizeOf(memoryInfo); GlobalMemoryStatusEx(ref memoryInfo); UsedMem = $"{Math.Round((memoryInfo.ullTotalPhys - memoryInfo.ullAvailPhys) / (double)memoryInfo.ullTotalPhys * 100, 0)}%"; }
public static long GetCommitted() { MemoryStatusEx mex = new MemoryStatusEx(); mex.length = Marshal.SizeOf(mex); GlobalMemoryStatusEx(mex); return(mex.totalPageFile - mex.availPageFile); }
public static MemoryStatusEx GetMemoryStatus() { var res = new MemoryStatusEx(); if (!GlobalMemoryStatusEx(res)) { throw new Win32Exception(); } return res; }
public static uint GetMemoryLoad() { var ms = new MemoryStatusEx(); if (GlobalMemoryStatusEx(ms)) { return ms.dwMemoryLoad; } return 100; }
public static uint GetAvailablePhysicalMemory() { var status = new MemoryStatusEx { Length = (uint)Marshal.SizeOf(typeof(MemoryStatusEx)) }; GlobalMemoryStatusEx(ref status); return((uint)(status.AvailablePhysicalMemory / (1024 * 1024))); }
public override void Append(ErrorInfo errorInfo) { var memorystatusex = new MemoryStatusEx(); if (NativeMethods.GlobalMemoryStatusEx(memorystatusex)) { errorInfo.AddDetail(this.Name, "Total Memory", string.Format(CultureInfo.InvariantCulture, "{0} MB", memorystatusex.ullTotalPhys / (1024 * 1024))); errorInfo.AddDetail(this.Name, "Available Memory", string.Format(CultureInfo.InvariantCulture, "{0} MB", memorystatusex.ullAvailPhys / (1024 * 1024))); } }
private static ulong WindowsGetFreePhysicalMemory() { MemoryStatusEx memoryStatus = new MemoryStatusEx(); memoryStatus.Length = 64; bool ok = NativeMethods.Kernel32.GlobalMemoryStatusEx(ref memoryStatus); return(memoryStatus.AvailPhys); }
public static long GetTotalPhysicalMemory() { if (_memoryStatusEx == null) { _memoryStatusEx = new MemoryStatusEx(); GlobalMemoryStatusEx(_memoryStatusEx); } return(_memoryStatusEx.ullTotalPhys); }
public static uint GetMemoryLoad() { var ms = new MemoryStatusEx(); if (GlobalMemoryStatusEx(ms)) { return(ms.dwMemoryLoad); } return(100); }
private static unsafe MemoryInfoResult GetMemoryInfoWindows() { // windows var memoryStatus = new MemoryStatusEx { dwLength = (uint)sizeof(MemoryStatusEx) }; if (GlobalMemoryStatusEx(&memoryStatus) == false) { if (Logger.IsInfoEnabled) { Logger.Info("Failure when trying to read memory info from Windows, error code is: " + Marshal.GetLastWin32Error()); } return(FailedResult); } // The amount of physical memory retrieved by the GetPhysicallyInstalledSystemMemory function // must be equal to or greater than the amount reported by the GlobalMemoryStatusEx function // if it is less, the SMBIOS data is malformed and the function fails with ERROR_INVALID_DATA. // Malformed SMBIOS data may indicate a problem with the user's computer. var fetchedInstalledMemory = GetPhysicallyInstalledSystemMemory(out var installedMemoryInKb); SetMemoryRecords((long)memoryStatus.ullAvailPhys); return(new MemoryInfoResult { TotalCommittableMemory = new Size((long)memoryStatus.ullTotalPageFile, SizeUnit.Bytes), CurrentCommitCharge = new Size((long)(memoryStatus.ullTotalPageFile - memoryStatus.ullAvailPageFile), SizeUnit.Bytes), AvailableMemory = new Size((long)memoryStatus.ullAvailPhys, SizeUnit.Bytes), AvailableWithoutTotalCleanMemory = new Size((long)memoryStatus.ullAvailPhys, SizeUnit.Bytes), SharedCleanMemory = Size.Zero, TotalPhysicalMemory = new Size((long)memoryStatus.ullTotalPhys, SizeUnit.Bytes), InstalledMemory = fetchedInstalledMemory ? new Size(installedMemoryInKb, SizeUnit.Kilobytes) : new Size((long)memoryStatus.ullTotalPhys, SizeUnit.Bytes), MemoryUsageRecords = new MemoryInfoResult.MemoryUsageLowHigh { High = new MemoryInfoResult.MemoryUsageIntervals { LastOneMinute = new Size(HighLastOneMinute, SizeUnit.Bytes), LastFiveMinutes = new Size(HighLastFiveMinutes, SizeUnit.Bytes), SinceStartup = new Size(HighSinceStartup, SizeUnit.Bytes) }, Low = new MemoryInfoResult.MemoryUsageIntervals { LastOneMinute = new Size(LowLastOneMinute, SizeUnit.Bytes), LastFiveMinutes = new Size(LowLastFiveMinutes, SizeUnit.Bytes), SinceStartup = new Size(LowSinceStartup, SizeUnit.Bytes) } } }); }
static SystemController() { Cpu = new PerformanceCounter("Processor", "% Processor Time", "_Total"); Memory = new PerformanceCounter("Memory", "Available MBytes", string.Empty); var memStatus = new MemoryStatusEx(); if (NativeMethods.GlobalMemoryStatusEx(memStatus)) { TotalPhysicalMemory = memStatus.ullTotalPhys; } }
public MemoryStatusEx?GetMemoryStatusInfo() { var status = new MemoryStatusEx { Length = checked ((uint)Marshal.SizeOf(typeof(MemoryStatusEx))) }; if (!Native.GlobalMemoryStatusEx(ref status)) { return(null); } return(status); }
public int GetDiskFreeSpace(ref ulong freeBytesAvailable, ref ulong totalBytes, ref ulong totalFreeBytes, DokanFileInfo info) { MemoryStatusEx ms = new MemoryStatusEx(); ms.dwLength = (uint)Marshal.SizeOf(ms); GlobalMemoryStatusEx(ref ms); totalBytes = ms.ullTotalPageFile; freeBytesAvailable = ms.ullAvailPageFile; totalFreeBytes = ms.ullAvailPageFile; return(0); }
public RamSensor(Process process) { Name = "RAM Load"; counter = new PerformanceCounter("Process", "Working Set - Private", process.ProcessName); MemoryStatusEx status = new MemoryStatusEx { Length = checked ((uint)Marshal.SizeOf(typeof(MemoryStatusEx))) }; TotalRam = GlobalMemoryStatusEx(status) ? (status.TotalPhys / (1024 * 1024)) : 1f; }
public static MemoryInfo Observe() { var memoryStatus = new MemoryStatusEx(); if (GlobalMemoryStatusEx(memoryStatus)) { return(new MemoryInfo( total: (long)memoryStatus.ullTotalPhys, available: (long)memoryStatus.ullAvailPhys )); } throw new Exception("Error observing local memory"); }
private static (ulong Total, ulong Available) GetMemoryStats() { MemoryStatusEx memStatus = new MemoryStatusEx(); if (GlobalMemoryStatusEx(memStatus)) { return(memStatus.TotalPhys, memStatus.AvailPhys); // Bytes } else { Logger.Error?.Print(LogClass.Application, $"GlobalMemoryStatusEx failed. Error {Marshal.GetLastWin32Error():X}"); } return(0, 0); }
public static MemoryInfo Observe() { var memoryStatus = new MemoryStatusEx(); if (GlobalMemoryStatusEx(memoryStatus)) { return new MemoryInfo { Total = (long)memoryStatus.ullTotalPhys, Available = (long)memoryStatus.ullAvailPhys }; } throw new Exception("Could not observe local memory"); }
public static MemoryInformation GetMemoryInformation() { var returnVal = new MemoryInformation(); if (Environment.OSVersion.Platform == PlatformID.Win32NT) { // from http://stackoverflow.com/a/105109 var memStatus = new MemoryStatusEx(); if (GlobalMemoryStatusEx(memStatus)) { returnVal.TotalPhysicalMemory = memStatus.ullTotalPhys; returnVal.TotalVirtualMemory = memStatus.ullTotalVirtual; } } else { var meminfo = File.ReadAllText("/proc/meminfo"); var match = new Regex(@"MemTotal:\s+(\d+) kB").Match(meminfo); if (match.Success) { returnVal.TotalPhysicalMemory = ulong.Parse(match.Groups[1].Value) * 1024; } ulong totalSwapMemory = 0; var match2 = new Regex(@"SwapTotal:\s+(\d+) kB").Match(meminfo); if (match2.Success) { totalSwapMemory = ulong.Parse(match2.Groups[1].Value) * 1024; } var availableMemory = returnVal.TotalPhysicalMemory + totalSwapMemory; if (Environment.Is64BitProcess) { returnVal.TotalVirtualMemory = availableMemory; } else { // Googling indicates that 32-bit Mono programs attempting to allocate more than // about 1.4 GB start running into OutOfMemory errors. So 2GB is probably the // right virtual memory limit for 32-bit processes. const ulong twoGB = 2147483648L; returnVal.TotalVirtualMemory = availableMemory > twoGB ? twoGB : availableMemory; } } return(returnVal); }
public static int GetMemoryLoad(this IMemoryInfo i) { MemoryStatusEx mse = new MemoryStatusEx(); mse.dwLength = (uint)Marshal.SizeOf(mse); if (GlobalMemoryStatusEx(ref mse)) { return((int)mse.dwMemoryLoad); } MemoryStatus ms = new MemoryStatus(); if (GlobalMemoryStatus(ref ms)) { return((int)ms.dwMemoryLoad); } return(-1); }
private static unsafe MemoryInfoResult GetMemoryInfoWindows(Process process, bool extended) { // windows var memoryStatus = new MemoryStatusEx { dwLength = (uint)sizeof(MemoryStatusEx) }; if (GlobalMemoryStatusEx(&memoryStatus) == false) { if (Logger.IsInfoEnabled) { Logger.Info("Failure when trying to read memory info from Windows, error code is: " + Marshal.GetLastWin32Error()); } return(FailedResult); } // The amount of physical memory retrieved by the GetPhysicallyInstalledSystemMemory function // must be equal to or greater than the amount reported by the GlobalMemoryStatusEx function // if it is less, the SMBIOS data is malformed and the function fails with ERROR_INVALID_DATA. // Malformed SMBIOS data may indicate a problem with the user's computer. var fetchedInstalledMemory = GetPhysicallyInstalledSystemMemory(out var installedMemoryInKb); var sharedCleanInBytes = GetSharedCleanInBytes(process); var availableMemoryForProcessingInBytes = (long)memoryStatus.ullAvailPhys + sharedCleanInBytes; SetMemoryRecords(availableMemoryForProcessingInBytes); return(new MemoryInfoResult { TotalCommittableMemory = new Size((long)memoryStatus.ullTotalPageFile, SizeUnit.Bytes), CurrentCommitCharge = new Size((long)(memoryStatus.ullTotalPageFile - memoryStatus.ullAvailPageFile), SizeUnit.Bytes), AvailableMemory = new Size((long)memoryStatus.ullAvailPhys, SizeUnit.Bytes), AvailableMemoryForProcessing = new Size(availableMemoryForProcessingInBytes, SizeUnit.Bytes), SharedCleanMemory = new Size(sharedCleanInBytes, SizeUnit.Bytes), TotalPhysicalMemory = new Size((long)memoryStatus.ullTotalPhys, SizeUnit.Bytes), InstalledMemory = fetchedInstalledMemory ? new Size(installedMemoryInKb, SizeUnit.Kilobytes) : new Size((long)memoryStatus.ullTotalPhys, SizeUnit.Bytes), WorkingSet = new Size(process?.WorkingSet64 ?? 0, SizeUnit.Bytes), IsExtended = extended, TotalSwapUsage = new Size(process?.PagedMemorySize64 ?? 0, SizeUnit.Bytes) }); }
/// <summary> /// Determines the amount of RAM available to the operating system in total. /// </summary> /// <returns>Total RAM in MegaBytes</returns> private int GetRamInMegaBytes() { int result = 0; var mem = new MemoryStatusEx(); try { if (GlobalMemoryStatusEx(mem)) { result = Convert.ToInt32(mem.ullTotalPhys / 1048576); } else { ServiceRegistration.Get <ILogger>().Warn("SQLiteDatabase: Error when trying to detect the total available RAM. Using minimum cache size for SQLiteDatabase."); } } catch (Exception) { ServiceRegistration.Get <ILogger>().Warn("SQLiteDatabase: Exception when trying to detect the total available RAM. Using minimum cache size for SQLiteDatabase."); } return(result); }
static extern bool GlobalMemoryStatusEx(ref MemoryStatusEx lpBuffer);
static extern bool GlobalMemoryStatusEx([In, Out] MemoryStatusEx buffer);
public static unsafe MemoryInfoResult GetMemoryInfo() { if (failedToGetAvailablePhysicalMemory) { if (_logger.IsInfoEnabled) { _logger.Info("Because of a previous error in getting available memory, we are now lying and saying we have 256MB free"); } return(failedResult); } try { if (StorageEnvironmentOptions.RunningOnPosix) { sysinfo_t info = new sysinfo_t(); if (Syscall.sysinfo(ref info) != 0) { if (_logger.IsInfoEnabled) { _logger.Info("Failure when trying to read memory info from posix, error code was: " + Marshal.GetLastWin32Error()); } return(failedResult); } return(new MemoryInfoResult { AvailableMemory = new Size((long)info.AvailableRam, SizeUnit.Bytes), TotalPhysicalMemory = new Size((long)info.TotalRam, SizeUnit.Bytes), }); } var memoryStatus = new MemoryStatusEx { dwLength = (uint)sizeof(MemoryStatusEx) }; var result = GlobalMemoryStatusEx(&memoryStatus); if (result == false) { if (_logger.IsInfoEnabled) { _logger.Info("Failure when trying to read memory info from Windows, error code is: " + Marshal.GetLastWin32Error()); } return(failedResult); } return(new MemoryInfoResult { AvailableMemory = new Size((long)memoryStatus.ullAvailPhys, SizeUnit.Bytes), TotalPhysicalMemory = new Size((long)memoryStatus.ullTotalPhys, SizeUnit.Bytes), }); } catch (Exception e) { if (_logger.IsInfoEnabled) { _logger.Info("Error while trying to get available memory, will stop trying and report that there is 256MB free only from now on", e); } failedToGetAvailablePhysicalMemory = true; return(failedResult); } }
public int GetDiskFreeSpace(ref ulong freeBytesAvailable, ref ulong totalBytes, ref ulong totalFreeBytes, DokanFileInfo info) { MemoryStatusEx ms = new MemoryStatusEx(); ms.dwLength = (uint)Marshal.SizeOf(ms); GlobalMemoryStatusEx(ref ms); totalBytes = ms.ullTotalPageFile; freeBytesAvailable = ms.ullAvailPageFile; totalFreeBytes = ms.ullAvailPageFile; return 0; }
private static extern void GlobalMemoryStatusEx(out MemoryStatusEx stat);
/// <summary> /// Determines the amount of RAM available to the operating system in total. /// </summary> /// <returns>Total RAM in MegaBytes</returns> private int GetRamInMegaBytes() { int result = 0; var mem = new MemoryStatusEx(); try { if (GlobalMemoryStatusEx(mem)) result = Convert.ToInt32(mem.ullTotalPhys / 1048576); else ServiceRegistration.Get<ILogger>().Warn("SQLiteDatabase: Error when trying to detect the total available RAM. Using minimum cache size for SQLiteDatabase."); } catch (Exception) { ServiceRegistration.Get<ILogger>().Warn("SQLiteDatabase: Exception when trying to detect the total available RAM. Using minimum cache size for SQLiteDatabase."); } return result; }
public static bool GetMemoryStatusEx(this IMemoryInfo m, ref MemoryStatusEx mse) { mse.dwLength = (uint)Marshal.SizeOf(mse); return(GlobalMemoryStatusEx(ref mse)); }
/// <summary> /// returns the number of GB installed on the machine /// </summary> public static double TotalPhysicalMemoryGB() { if (Utilities.IsThisMono()) { PerformanceCounter counter = new PerformanceCounter("Mono Memory", "Total Physical Memory"); double physicalGB = (counter.RawValue / NumBytesInGB); return physicalGB; } MemoryStatusEx stat = new MemoryStatusEx(); GlobalMemoryStatusEx(stat); double result = stat.TotalPhysical / NumBytesInGB; return result; }
internal static extern bool GlobalMemoryStatusEx( ref MemoryStatusEx buffer);
#pragma warning disable AV1706 // Identifier contains an abbreviation or is too short #pragma warning disable AV1562 // Do not declare a parameter as ref or out public static extern bool GlobalMemoryStatusEx(ref MemoryStatusEx meminfo);
private static extern bool GlobalMemoryStatusEx([In, Out] MemoryStatusEx lpBuffer);
public static extern bool GlobalMemoryStatusEx( MemoryStatusEx memStatus);
/// <summary> /// returns the number of GB available on the machine /// </summary> public static double TotalPhysicalAvailableMemoryGB() { if (Utilities.IsThisMono()) { UInt64 freeMemoryKB = 0; UInt64 cachedMemoryKB = 0; UInt64 bufferedMemoryKB = 0; try { // If we're on linux, go looking for memory info // in the meminfo file. // Hoping to see an entry that looks like // MemFree: 1976408 kB // Buffers: 348648 kB // Cached: 4665328 kB // that specifies the available memory. There is certain // memory taken by the operating system (buffers, cache) that // can be made available if requested. StreamReader reader = new StreamReader("/proc/meminfo"); string input = null; while ((input = reader.ReadLine()) != null) { string[] splat = input.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); if (splat.Length >= 2) { if (splat[0] == "MemFree:") { UInt64.TryParse(splat[1], out freeMemoryKB); } if (splat[0] == "Buffers:") { UInt64.TryParse(splat[1], out bufferedMemoryKB); } if (splat[0] == "Cached:") { UInt64.TryParse(splat[1], out cachedMemoryKB); } } } reader.Close(); } catch (Exception e) { Console.WriteLine(e); } return (freeMemoryKB + cachedMemoryKB + bufferedMemoryKB) / NumKBInGB; } MemoryStatusEx stat = new MemoryStatusEx(); GlobalMemoryStatusEx(stat); return stat.AvailablePhysical / NumBytesInGB; }
public static long GetCommitted() { MemoryStatusEx mex = new MemoryStatusEx(); mex.length = Marshal.SizeOf(mex); GlobalMemoryStatusEx(mex); return mex.totalPageFile - mex.availPageFile; }
private static extern bool GlobalMemoryStatusEx(ref MemoryStatusEx lpBuffer);
public static unsafe MemoryInfoResult GetMemoryInfo() { if (_failedToGetAvailablePhysicalMemory) { if (Logger.IsInfoEnabled) { Logger.Info("Because of a previous error in getting available memory, we are now lying and saying we have 256MB free"); } return(FailedResult); } try { if (PlatformDetails.RunningOnPosix == false) { // Windows var memoryStatus = new MemoryStatusEx { dwLength = (uint)sizeof(MemoryStatusEx) }; var result = GlobalMemoryStatusEx(&memoryStatus); if (result == false) { if (Logger.IsInfoEnabled) { Logger.Info("Failure when trying to read memory info from Windows, error code is: " + Marshal.GetLastWin32Error()); } return(FailedResult); } return(new MemoryInfoResult { AvailableMemory = new Size((long)memoryStatus.ullAvailPhys, SizeUnit.Bytes), TotalPhysicalMemory = new Size((long)memoryStatus.ullTotalPhys, SizeUnit.Bytes), }); } // read both cgroup and sysinfo memory stats, and use the lowest if applicable var cgroupMemoryLimit = KernelVirtualFileSystemUtils.ReadNumberFromCgroupFile("/sys/fs/cgroup/memory/memory.limit_in_bytes"); var cgroupMemoryUsage = KernelVirtualFileSystemUtils.ReadNumberFromCgroupFile("/sys/fs/cgroup/memory/memory.usage_in_bytes"); ulong availableRamInBytes; ulong totalPhysicalMemoryInBytes; if (PlatformDetails.RunningOnMacOsx == false) { // Linux var info = new sysinfo_t(); if (Syscall.sysinfo(ref info) != 0) { if (Logger.IsInfoEnabled) { Logger.Info("Failure when trying to read memory info from posix, error code was: " + Marshal.GetLastWin32Error()); } return(FailedResult); } availableRamInBytes = info.AvailableRam; totalPhysicalMemoryInBytes = info.TotalRam; } else { // MacOS var mib = new[] { (int)TopLevelIdentifiersMacOs.CTL_HW, (int)CtkHwIdentifiersMacOs.HW_MEMSIZE }; ulong physicalMemory = 0; var len = sizeof(ulong); if (Syscall.sysctl(mib, 2, &physicalMemory, &len, null, UIntPtr.Zero) != 0) { if (Logger.IsInfoEnabled) { Logger.Info("Failure when trying to read physical memory info from MacOS, error code was: " + Marshal.GetLastWin32Error()); } return(FailedResult); } totalPhysicalMemoryInBytes = physicalMemory; uint pageSize; var vmStats = new vm_statistics64(); var machPort = Syscall.mach_host_self(); var count = sizeof(vm_statistics64) / sizeof(uint); if (Syscall.host_page_size(machPort, &pageSize) != 0 || Syscall.host_statistics64(machPort, (int)FlavorMacOs.HOST_VM_INFO64, &vmStats, &count) != 0) { if (Logger.IsInfoEnabled) { Logger.Info("Failure when trying to get vm_stats from MacOS, error code was: " + Marshal.GetLastWin32Error()); } return(FailedResult); } availableRamInBytes = vmStats.FreePagesCount * (ulong)pageSize; } Size availableRam, totalPhysicalMemory; if (cgroupMemoryLimit < (long)totalPhysicalMemoryInBytes) { availableRam = new Size(cgroupMemoryLimit - cgroupMemoryUsage, SizeUnit.Bytes); totalPhysicalMemory = new Size(cgroupMemoryLimit, SizeUnit.Bytes); } else { availableRam = new Size((long)availableRamInBytes, SizeUnit.Bytes); totalPhysicalMemory = new Size((long)totalPhysicalMemoryInBytes, SizeUnit.Bytes); } return(new MemoryInfoResult { AvailableMemory = availableRam, TotalPhysicalMemory = totalPhysicalMemory }); } catch (Exception e) { if (Logger.IsInfoEnabled) { Logger.Info("Error while trying to get available memory, will stop trying and report that there is 256MB free only from now on", e); } _failedToGetAvailablePhysicalMemory = true; return(FailedResult); } }
internal static extern bool GlobalMemoryStatusEx(out MemoryStatusEx status);