know how many free memory on System? Windows Standalone

Unity Engine
,
1

I need to know how many free memory are on System on real time.

I’m on Windows Standalone Application.

I use

 cpuCounter = new PerformanceCounter();
     cpuCounter.CategoryName = "Processor";
     cpuCounter.CounterName = "% Processor Time";
     cpuCounter.InstanceName = "_Total";
     ramCounter = new PerformanceCounter("Memory", "Available MBytes");

        public float getAvailableRAM(){
        return ramCounter.NextValue();
     }

but always return 0!!

Any solution?

2

You can PInvoke into this API:

3

Please can you explain a little how to do this?
thanks you

4

Something like this:

struct MEMORYSTATUSEX
{
    public int dwLength;
    public uint dwMemoryLoad;
    public ulong ullTotalPhys;
    public ulong ullAvailPhys;
    public ulong ullTotalPageFile;
    public ulong ullAvailPageFile;
    public ulong ullTotalVirtual;
    public ulong ullAvailVirtual;
    public ulong ullAvailExtendedVirtual;
}

[DllImport("kernel32.dll", SetLastError = true)]
static extern bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX memoryStatus);

static ulong GetAvailableMemory()
{
    var structureSize = Marshal.SizeOf(typeof(MEMORYSTATUSEX));

    var memoryStatus = default(MEMORYSTATUSEX);
    memoryStatus.dwLength = structureSize;

    if (!GlobalMemoryStatusEx(ref memoryStatus))
        throw new Win32Exception(Marshal.GetLastWin32Error());

    return memoryStatus.ullAvailPageFile;
}
1 Like
5

Perfect!! It Works!!

I found also this code and Works ok

public class PerformanceDataInfo : MonoBehaviour {
   
    public class PerfomanceInfoData
    {
        public Int64 CommitTotalPages;
        public Int64 CommitLimitPages;
        public Int64 CommitPeakPages;
        public Int64 PhysicalTotalBytes;
        public Int64 PhysicalAvailableBytes;
        public Int64 SystemCacheBytes;
        public Int64 KernelTotalBytes;
        public Int64 KernelPagedBytes;
        public Int64 KernelNonPagedBytes;
        public Int64 PageSizeBytes;
        public int HandlesCount;
        public int ProcessCount;
        public int ThreadCount;
    }
   
    [StructLayout(LayoutKind.Sequential)]
    public struct PsApiPerformanceInformation
    {
        public int Size;
        public IntPtr CommitTotal;
        public IntPtr CommitLimit;
        public IntPtr CommitPeak;
        public IntPtr PhysicalTotal;
        public IntPtr PhysicalAvailable;
        public IntPtr SystemCache;
        public IntPtr KernelTotal;
        public IntPtr KernelPaged;
        public IntPtr KernelNonPaged;
        public IntPtr PageSize;
        public int HandlesCount;
        public int ProcessCount;
        public int ThreadCount;
    }
   
   
    [DllImport("psapi.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool GetPerformanceInfo([Out] out PsApiPerformanceInformation PerformanceInformation, [In] int Size);
       
    // Use this for initialization
    void Start () {

    }

    static double ConvertBytesToMegabytes(long bytes)
    {
        return (bytes / 1024f) / 1024f;
    }
   
   
    public static PerfomanceInfoData GetPerformanceInfo()
    {
        PerfomanceInfoData data = new PerfomanceInfoData();
        PsApiPerformanceInformation perfInfo = new PsApiPerformanceInformation();
        if (GetPerformanceInfo(out perfInfo, Marshal.SizeOf(perfInfo)))
        {
            /// data in pages
            data.CommitTotalPages = perfInfo.CommitTotal.ToInt64();
            data.CommitLimitPages = perfInfo.CommitLimit.ToInt64();
            data.CommitPeakPages = perfInfo.CommitPeak.ToInt64();
           
            /// data in bytes
            Int64 pageSize = perfInfo.PageSize.ToInt64();
            data.PhysicalTotalBytes = perfInfo.PhysicalTotal.ToInt64() * pageSize;
            data.PhysicalAvailableBytes = perfInfo.PhysicalAvailable.ToInt64() * pageSize;
            data.SystemCacheBytes = perfInfo.SystemCache.ToInt64() * pageSize;
            data.KernelTotalBytes = perfInfo.KernelTotal.ToInt64() * pageSize;
            data.KernelPagedBytes = perfInfo.KernelPaged.ToInt64() * pageSize;
            data.KernelNonPagedBytes = perfInfo.KernelNonPaged.ToInt64() * pageSize;
            data.PageSizeBytes = pageSize;
           
            /// counters
            data.HandlesCount = perfInfo.HandlesCount;
            data.ProcessCount = perfInfo.ProcessCount;
            data.ThreadCount = perfInfo.ThreadCount;
        }
        return data;
    }