测量应用程序可用的 RAM 总量

Question

我有一个我一直在研究的数据解析应用程序，考虑到它正在读取的文本文件的绝对大小，控制内存使用是获得良好性能的关键。这里的两部分策略首先测量每个文件对总和的贡献有多少 RAM，但它还需要知道在给定时间点应用程序有多少 RAM 可用。如果有足够的 RAM 可用，应用程序会选择在内存中进行处理。否则，它会切换到在磁盘上执行所有或大部分操作的模式。

测量文件对内存使用的贡献既快捷又简单：

    static Int64 GetSizeInMemory(string path)
    {
        //THIS CODE IS SPEEDY
        Int64 r = ((Func<Int64>)(
                    () =>
                        {
                            try
                            {
                                using (Stream s = new MemoryStream())
                                {
                                    BinaryFormatter formatter = new BinaryFormatter();
                                    formatter.Serialize(s, File.ReadAllLines(path));
                                    return s.Length;
                                }
                            }
                            catch
                            {
                                //this file is way too big
                                return -1;
                            }
                        }
                ))();
        GC.Collect();
        GC.WaitForPendingFinalizers();
        return r;
    }

但是，测量可用内存总量既慢又困难。在这种情况下，我试图通过捕获堆栈溢出错误来做到这一点，在我看来，这应该给出最可靠的数字。

    static Int64 GetMaxAllowedMemory()
    {
        //THIS CODE IS SLOW
        Int64 r = ((Func<Int64>)(
                    () =>
                        {
                            byte[] b = new byte[]{};
                            Int64 rs = 0;
                            while (true)
                            {
                                try
                                {
                                    Array.Resize<byte>(ref b, b.Length + 1);
                                    b[b.Length - 1] = new byte();
                                    rs = b.Length;
                                } catch (Exception e) {
                                    break;
                                }
                            }
                            b = null;
                            return rs;
                        }
                ))();
        GC.Collect();
        GC.WaitForPendingFinalizers();
        return r;
    }

我应该在这里使用更好的方法吗？

请注意我在 Stack Overflow 上查看了许多与此类似的问题，但大多数问题仅涉及获取计算机上可用 RAM 总量的数字，这不是与 .NET 进程在运行时允许的最大 RAM 量相同。

更新

收到答复后，我想出了以下方法，可让我获得应用程序可用的 RAM 总量。

    static Int64 GetMemoryFailPoint()
    {
        Int64 r = ((Func<Int64>)(
                    () =>
                    {
                        int rs = 1;
                        while (true)
                        {
                            try
                            {
                                using (new System.Runtime.MemoryFailPoint(rs))
                                {
                                }
                            }
                            catch {
                                break;
                            }
                            rs++;
                        }
                        return Convert.ToInt64(rs) * 1000000;
                    }
                ))();
        return r;
    }

Answer 1

您可以尝试使用MemoryFailPoint 类：

try
{
    using (new System.Runtime.MemoryFailPoint(1024)) // 1024 megabytes
    {
        // Do processing in memory
    }
}
catch (InsufficientMemoryException)
{
    // Do processing on disk
}

---

基于此original post。

Answer 2

而不是将整个文件读入内存并查看它是否失败，您可以使用MemoryFailPoint 通过使用文件的大小来检查是否有足够的内存可用于进行内存处理在磁盘上。

void ProcessFile(string path)
{
    try
    {
        var fileInfo = new FileInfo(path);
        var fileSizeInMb = (int)(fileInfo.Length >> 20);
        using (new System.Runtime.MemoryFailPoint(fileSizeInMb))
        {
            // Do processing in memory
        }
    }
    catch (InsufficientMemoryException)
    {
        // Do processing on disk
    }
}