在 x86 上处理非常大的列表

Question

我需要处理大量浮点数，但我在 x86 系统上遇到了内存限制。我不知道最终长度，所以我需要使用可扩展类型。在 x64 系统上，我可以使用 <gcAllowVeryLargeObjects>。

我当前的数据类型：

List<RawData> param1 = new List<RawData>();
List<RawData> param2 = new List<RawData>();
List<RawData> param3 = new List<RawData>();

public class RawData
{
    public string name;
    public List<float> data;
}

paramN 列表的长度很短（当前为 50 或更低），但数据可以是 10m+。当长度为 50 时，我在 1m 数据点以上达到内存限制 (OutOfMemoryException)，当长度为 25 时，我在 2m 数据点以上达到限制。 （如果我的计算是正确的，那就是 200MB，加上名称的大小，加上开销）。我可以使用什么来提高此限制？

编辑：我尝试使用最大内部列表大小为 1 List<List<float>>，这在一定程度上增加了限制，但仍然没有达到我想要的程度。 p>

Edit2：我尝试将 List> 中的块大小减小到 8192，我得到了大约 2.3m 元素的 OOM，任务管理器读取了大约 1.4GB 的进程。看起来我需要减少数据源和存储之间的内存使用量，或者更频繁地触发 GC - 我能够在具有 4GB RAM 的 PC 上的 x64 进程中收集 10m 数据点，IIRC 该进程从未超过 3GB

Edit3：我将我的代码压缩为仅处理数据的部分。 http://pastebin.com/maYckk84

Edit4：我查看了 DotMemory，发现我的数据结构确实占用了我正在测试的设置大约 1GB（50ch * 3 参数 * 2m 事件 = 300,000,000 个浮点元素） .我想我需要在 x86 上限制它，或者在我获取数据时弄清楚如何以这种格式写入磁盘

Answer 1

首先，在 x86 系统上，内存限制是 2GB，而不是 200MB。我相信 你的问题比这更棘手。您有激进的 LOH（大对象堆）碎片。
CLR 对小型和大型对象使用不同的堆。如果对象的大小大于 85,000 字节，则该对象很大。 LOH 是一个非常棘手的东西，它不急于将未使用的内存返回给操作系统，并且在碎片整理方面很差。
.Net List 是 ArrayList 数据结构的实现，它将元素存储在数组中，数组的大小是固定的；当数组被填充时，将创建两倍大小的新数组。阵列随着数据量的持续增长是 LOH 的“饥饿”场景。
因此，您必须使用量身定制的数据结构来满足您的需求。例如。块列表，每个块都足够小，不会进入 LOH。这是小原型：

public class ChunkedList
{
    private readonly List<float[]> _chunks = new List<float[]>();
    private const int ChunkSize = 8000;
    private int _count = 0;       

    public void Add(float item)
    {            
        int chunk = _count / ChunkSize;
        int ind = _count % ChunkSize;
        if (ind == 0)
        {
            _chunks.Add(new float[ChunkSize]);
        }
        _chunks[chunk][ind] = item;
        _count ++;
    }

    public float this[int index]
    {
        get
        {
            if(index <0 || index >= _count) throw new IndexOutOfRangeException();
            int chunk = index / ChunkSize;
            int ind = index % ChunkSize;
            return _chunks[chunk][ind];
        }
        set
        {
            if(index <0 || index >= _count) throw new IndexOutOfRangeException();
            int chunk = index / ChunkSize;
            int ind = index % ChunkSize;
            _chunks[chunk][ind] = value;
        }
    }
    //other code you require
}

ChunkSize = 8000 每个块只需要 32,000 字节，所以它不会进入 LOH。 _chunks 只有在收集大约 16,000 个块时才会进入 LOH，即收集中的元素超过 1.28 亿个（约 500 MB）。

UPD 我对上面的示例进行了一些压力测试。操作系统为 x64，解决方案平台为 x86。 ChunkSize 为 20000。

第一：

var list = new ChunkedList();
for (int i = 0; ; i++)
{
    list.Add(0.1f);
}

OutOfMemoryException 在 ~324,000,000 个元素处引发

第二：

public class RawData
{
    public string Name;
    public ChunkedList Data = new ChunkedList();
}

var list = new List<RawData>();
for (int i = 0;; i++)
{
    var raw = new RawData { Name = "Test" + i };
    for (int j = 0; j < 20 * 1000 * 1000; j++)
    {
        raw.Data.Add(0.1f);
    }
    list.Add(raw);
}

OutOfMemoryException 在 i=17, j~12,000,000 时引发。成功创建 17 个 RawData 实例，每个实例 2000 万个数据点，总计约 3.52 亿个数据点。