我需要处理大量的 float 列表，但我在 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，加上名称的大小，再加上开销)。我可以使用什么来增加此限制？

编辑:我尝试使用 List<List<float>>最大内部列表大小为 1 < 17="">

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

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

Edit4:我查看了 DotMemory，发现我的数据结构确实占用了大约 1GB 的空间和我测试的设置(50ch * 3 params * 2m events = 300,000,000 float elements) .我想我需要在 x86 上限制它，或者弄清楚如何在获取数据时以这种格式写入磁盘

最佳答案

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

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 时，每个 block 将只占用 32,000 字节，因此它不会进入 LOH。 _chunks 只有在集合中有大约 16,000 个 block 时才会进入 LOH，这超过了集合中的 1.28 亿个元素(约 500 MB)。

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

首先:

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

在大约 324,000,000 个元素处引发 OutOfMemoryException

第二个:

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);
}

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

关于c# - 在 x86 上处理非常大的列表，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31486475/