使用数组字段代替大量对象

Question

鉴于 这篇文章，我想知道人们在内存中使用数组存储数据字段而不是实例化数百万个对象并积累大量数据集（例如，>10,000,000 个对象）的体验如何内存开销（例如，每个对象 12-24 字节，具体取决于您阅读的文章）。每个属性的数据因项目而异，因此我不能使用严格的享元模式，但会设想类似的东西。

我对这种表示的想法是，有一个“模板对象”...

class Thing
{
  double A;
  double B;
  int    C;
  string D;
}

然后是一个容器对象，具有根据请求创建对象的方法...

class ContainerOfThings
{
  double[] ContainerA;
  double[] ContainerB;
  int[]    ContainerC;
  string[] ContainerD;

  ContainerOfThings(int total)
  {
    //create arrays
  }

  IThing GetThingAtPosition(int position)
  {
     IThing thing = new Thing(); //probably best done as a factory instead
     thing.A = ContainerA[position];
     thing.B = ContainerB[position];
     thing.C = ContainerC[position];
     thing.D = ContainerD[position];

     return thing;
  }
}

所以这是一种简单的策略，但不是很通用，例如可以如果不复制数据并违背数组字段存储的目的，就不能创建“事物”的子集（作为列表）。我一直无法找到好的例子，所以我希望有更好的方法来处理这种情况的人提供的链接或代码片段......或者更好的想法。

Answer 1

这取决于你的具体场景。根据创建对象的频率，您可以：

1. 如果对象是可序列化的，则将它们保存在 MemoryMappedFile 中（获得中/低性能和低内存消耗的某种融合）。

2. 在不同对象之间映射字段：我的意思是，如果对象最初有默认值，则将它们全部放在单独的基中，如果该值与默认值不同，则真正分配一个新空间。 （这对于引用类型自然是有意义的）。

3. 另一个解决方案再次将对象保存到 SqlLite 库。比 MemoryMappedFiles 更容易管理，因为您可以使用简单的 SQL。

选择取决于您，因为这取决于您的具体项目要求。

问候。

Answer 2

根据这篇文章，我想知道人们在内存中使用数组存储数据字段而不是实例化数百万个对象并增加内存开销来存储大量数据集（例如，>10,000,000 个对象）的体验如何。 ..

我我猜有几种方法可以解决这个问题，实际上您正在寻找一种可能的解决方案来限制内存中的数据。然而，我不确定你的结构是否减少了 24 个？ bytes 会给你带来很多好处。您的结构约为 79 个字节（对于 15 个字符的字符串）= 8 + 8 + 4 + 24？ + 4 + 1 + (2 * 字符长度) 因此您的总增益最多为 25%。这似乎不是很有用，因为您必须处于内存适合 1000 万 * 80 字节而 1000 万 * 100 字节不适合的位置。这意味着您设计的解决方案处于灾难边缘，太多大字符串，或太多记录，或某些其他程序占用内存，并且您的机器内存不足。

如果您需要支持对 n 个小记录的随机访问（其中 n = 1000 万），那么您的设计目标应该是至少 2n 或 10n。也许你已经在你的 1000 万中考虑这个了？无论哪种方式，都有很多技术可以支持此类数据的访问。

一种可能性是，如果字符串的最大长度 (ml) 受到限制，并且大小合理（例如 255），那么您可以转到简单的 ISAM 存储。每条记录的大小为 8 + 8 + 4 + 255 字节，您可以简单地偏移到平面文件中来读取它们。如果记录大小可变或可能很大，那么您将需要为此使用不同的存储格式并将偏移量存储到文件中。

另一种可能性是，如果您通过某个键查找值，那么我会推荐诸如嵌入式数据库或 BTree 之类的东西，您可以禁用某些磁盘一致性以获得性能。碰巧我写了一个 BPlusTree 用于客户端缓存大量数据。有关使用 B+Tree 的详细信息位于此处。

Answer 3

实际上，ADO.NET DataTable 使用类似的方法来存储数据。也许你应该看看它是如何实现的。
因此，您需要有一个类似 DataRow 的对象，该对象在内部保存指向表的指针和行数据的索引。这将是我认为最轻量级的解决方案。

在你的情况下：
a) 如果每次调用 GetThingAtPosition 方法时都在构造事物，则在堆中创建对象，这会使表中已有的信息加倍。加上“对象开销”数据。

b) 如果您需要访问 ContainerOfThings 中的每个项目，则所需内存将加倍 + 12 字节 * 对象开销数量。在这种情况下，最好有一个简单的数组，而不是动态创建它们。

Answer 4

你的问题说明有问题。内存使用是否被证明是一个问题？

如果每个项目 100 字节，那么听起来就像 1GB。所以我想知道该应用程序以及这是否有问题。该应用程序是否要在具有 8GB 或 RAM 的专用 64 位机器上运行？

如果存在恐惧，您可以通过集成测试来测试恐惧。实例化其中 2000 万个项目并运行一些性能测试。

但当然，这一切都来自于应用程序领域。我有专门的应用程序，使用比这更多的内存，并且运行良好。硬件成本通常远低于软件成本（是的，这又归结为应用程序领域）。

再见

Answer 5

不幸的是，面向对象无法消除性能问题（带宽饱和就是其中之一）。这是一个方便的范例，但它也有局限性。

我喜欢你的想法，我也使用这个......你猜怎么着，我们不是第一个想到这个的;-)。我发现这确实需要一些思维转变。

我可以推荐您到 J 社区吗？请参阅：

http://www.JSoftware.com。

那不是 C#（或 Java）组。他们是一群好人。通常，数组需要被视为第一类对象。在 C# 中，它就没有那么灵活了。使用 C# 的结构可能会令人沮丧。

对于大型数据集问题，有各种面向对象的模式……但如果您问这样的问题，可能是时候采用更实用的方法了。或者至少可以用于解决问题/原型设计。

Answer 6

我为rapidSTORM项目做了这样的事情，其中​​需要缓存数百万个稀疏对象（定位显微镜）。虽然我无法真正为您提供好的代码片段（太多依赖项），但我发现使用 Boost Fusion 实现非常快速且简单。融合结构，为每个元素类型构建一个向量，然后为该向量编写一个非常简单的访问器来重建每个元素。

（哦，我刚刚注意到你标记了这个问题，但也许我的 C++ 答案也有帮助）

Answer 7

[更新 2011-07-19]

现在有一个新版本：http://www.mediafire.com/file/74fxj7u1n0ppcq9/MemStorageDemo-6639584-2011_07_19-12_47_00.zip

我仍在尝试调试一些令人讨厌的引用计数，但来自新鲜的 xUnit 会话，我能够运行一个创建 1000 万个对象的测试（它发生在我身上）我现在已经缩小了字符串大小以进行测试，但我让它运行了 1000 万个长度为 3 到 15 字节的可变长度的字符串，我还没有机会在我的系统上尝试比这更大的字符串。大约 1.95G 负载到 2.35G 的 1000 万个对象，除了使用实际托管字符串的非常简单的支持类之外，我仍然没有对字符串做任何事情

，所以，我认为它工作得相当好，尽管如此。后备存储肯定还需要优化，而且我还认为，如果有必要，可以在迭代器上做一些工作，具体取决于您一次处理的数据量。不幸的是，直到明天晚些时候或第二天才能再次查看它。

无论如何，基本思想如下：

1. MemoryArray 类：使用由 Marhsal.AllocHGlobal() 分配的非托管内存来存储结构。我正在使用一个大的 MemoryArray 进行测试，但成员方面只有几个字段，我认为只要您保持数组大小相当大，内存消耗就不会有太大差异把它分开。 MemoryArray 实现了 IEnumerable，这是我在测试中用来填充数组的方法。

MemoryArray 旨在保存来自任何受支持对象的常规大小的数据块。您可以使用我尚未实现的指针数学对枚举器执行一些操作。我目前每次都会返回新对象，所以这是我认为大小的很大一部分。在我基于此原型的原型类中，我能够使用非常常规的指针数学来进行遍历，但是我认为我这样做的方式主要对非常快速的遍历有用，并且可能不适用于互操作性。

MemoryArray 只有一个标准索引器，它使用 IntPtr 上的指针数学来获取请求的元素，该指针表示在构造时分配的非托管数据的头部。我还实现了一个名义上的 2D 索引器，您可以在其中将表示维度的整数数组传递给数组，然后可以对其执行 A[x,y]。这只是一个简单的小例子来说明它是如何工作的。

我还没有实现的一件事是任何形式的分段，但我确实认为分段适合该项目，所以当我有机会时我可能会实现它。

1. MemoryArrayEnumerator 类：我选择实现实际的枚举器而不是枚举器函数。枚举器类基本上只接受一个MemoryArray，然后为枚举器提供库存函数以返回实际的MemoryArrayItem对象。

2. MemoryArrayItem 类：该类除了根据数组中的开始和位置保存适当的指针信息之外，没有做太多事情。它是在该对象之上（到侧面？）实现的特定类，它们实际上执行指针操作以获取数据。

然后还有一些支持类，MemoryStringArray是可变大小的内存后备块，暂时只处理字符串，然后是自动处置类(AutoDisposer ）和一个处理附加和分离的通用类。 （自动引用）。

现在，在此基础之上是特定的类。这三种类型（数组/枚举器/项目）中的每一种都是专门针对您正在查看的对象实现的。在我放弃的这个项目的更大规模的版本中，这是一个峰值，我对偏移量等有更通用的处理，这样你就不会那么依赖于具体的类，但即使它们是这样的非常有用；我最初的实现都是具体的类，没有真正的基础。

目前，我将它们全部实现为单独的类，您可以将引用传递给它们；因此，TestArray 类在其构造函数中传递了一个 MemoryArray 类。与枚举器和项目相同。我知道那里会节省一些处理能力，而且我认为如果我能找到一种好方法将它们实现为后代而不是仅仅拥有底层类的副本，那么也很有可能节省空间。不过，我想先获得基本的感觉，这似乎是最直接的方法。问题在于它是另一层间接。

TestArray 和 TestArrayEnumerator 事实证明，除了传递 MemoryArray 和 MemoryArrayEnumerator 的功能之外，并没有做太多事情。这些类中的主要问题只是将指针分割并传递到正在使用它的项目中。

但是，TestArrayItem 是指针实际切换为真实数据的地方；这是文件。我剪下了一大段评论，其中包含一些选项，以便更好地处理可变长度后备存储（仍在上面给出的链接中的实际文件中），请原谅我在其中留下注释的大量评论当我处理它时我在想什么:)

TestArrayItem.cs

// ----------------------------------------------
//      rights lavished upon all with love
//         see 'license/unlicense.txt'
//   ♥ 2011, shelley butterfly - public domain
// ----------------------------------------------

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MemStorageDemo
{
    public unsafe class TestArrayItem
    {
        public static MemoryStringArray s_MemoryArrayStore = new MemoryStringArray();

        public static int TestArrayItemSize_bytes =
            sizeof(double) * 2
            + sizeof(int)
            + sizeof(int);

        // hard-coding here; this is another place that things could be a little more generic if you wanted and if 
        // performance permitted; for instance, creating a dictionary of offsets based on index.  also, perhaps
        // a dictionary with key strings to allow indexing using field names of the object.
        private enum EFieldOffset
        {
            DoubleTheFirstOffset       =  0,
            DoubleTheSecondOffset      =  8,
            IntTheFirstOffset          = 16,
            StringTheFirstHandleOffset = 20
        }

        private MemoryArrayItem myMemoryArrayItem;
        private MemoryStringArray myStringStore;

        // constructor that uses the static string array store
        public TestArrayItem(MemoryArrayItem parMemoryArrayItem) :
            this(parMemoryArrayItem, s_MemoryArrayStore)
        {
        }

        // constructor for getting the item at its memory block without any initialization (e.g. existing item)
        public TestArrayItem(MemoryArrayItem parMemoryArrayItem, MemoryStringArray parStringStore)
        {
            myMemoryArrayItem = parMemoryArrayItem;
            myStringStore = parStringStore;
        }

        // constructor for geting the item at its memory block and initializing it (e.g. adding new items)
        public TestArrayItem(MemoryArrayItem parMemoryArrayItem, double parDoubleTheFirst, double parDoubleTheSecond, int parIntTheFirst, string parStringTheFirst)
        {
            myMemoryArrayItem = parMemoryArrayItem;

            DoubleTheFirst = parDoubleTheFirst;
            DoubleTheSecond = parDoubleTheSecond;
            IntTheFirst = parIntTheFirst;
            StringTheFirst = parStringTheFirst;
        }

        // if you end up in a situation where the compiler isn't giving you equivalent performance to just doing
        // the array math directly in the properties, you could always just do the math directly in the properties.
        //
        // it reads much cleaner the way i have it set up, and there's a lot less code duplication, so without 
        // actually determining empirically that i needed to do so, i would stick with the function calls.
        private IntPtr GetPointerAtOffset(EFieldOffset parFieldOffset)
            { return myMemoryArrayItem.ObjectPointer + (int)parFieldOffset; }

        private double* DoubleTheFirstPtr 
            { get { return (double*)GetPointerAtOffset(EFieldOffset.DoubleTheFirstOffset); } }
        public double DoubleTheFirst
        {
            get
            {
                return *DoubleTheFirstPtr;
            }

            set
            {
                *DoubleTheFirstPtr = value;
            }
        }

        private double* DoubleTheSecondPtr
            { get { return (double*)GetPointerAtOffset(EFieldOffset.DoubleTheSecondOffset); } }
        public double DoubleTheSecond
        {
            get
            {
                return *DoubleTheSecondPtr;
            }
            set
            {
                *DoubleTheSecondPtr = value;
            }
        }

        // ahh wishing for a preprocessor about now
        private int* IntTheFirstPtr
            { get { return (int*)GetPointerAtOffset(EFieldOffset.IntTheFirstOffset); } }
        public int IntTheFirst
        {
            get
            {
                return *IntTheFirstPtr;
            }
            set
            {
                *IntTheFirstPtr = value;
            }
        }

        // okay since we're using the StringArray backing store in the example, we just need to get the
        // pointer stored in our blocks, and then copy the data from that address 
        private int* StringTheFirstHandlePtr 
            { get { return (int*)GetPointerAtOffset(EFieldOffset.StringTheFirstHandleOffset); } }
        public string StringTheFirst
        {
            get
            {
                return myStringStore.GetString(*StringTheFirstHandlePtr);
            }
            set
            {
                myStringStore.ModifyString(*StringTheFirstHandlePtr, value);
            }
        }

        public void CreateStringTheFirst(string WithValue)
        {
            *StringTheFirstHandlePtr = myStringStore.AddString(WithValue);
        }

        public override string ToString()
        {
            return string.Format("{0:X8}: {{ {1:0.000}, {2:0.000}, {3}, {4} }} {5:X8}", (int)DoubleTheFirstPtr, DoubleTheFirst, DoubleTheSecond, IntTheFirst, StringTheFirst, (int)myMemoryArrayItem.ObjectPointer);
        }
    }
}

所以，这才是真正的魔力；只是基本上实现根据字段信息找出正确指针的函数。就目前情况而言，我认为它是代码生成的一个非常好的候选者，假设我让附加/分离的东西正常工作。我隐藏了很多必须使用自动类型指针进行手动内存管理的内容，我认为从长远来看，这是值得进行调试的......

无论如何，仅此而已，我希望今晚或明天能回到互联网，我会尽力办理入住手续。不幸的是，我要把电缆调制解调器还给电缆公司，所以除非我们去麦当劳或其他什么地方，否则不会营业:)希望这对您有所帮助;我将用它来调试问题，以便至少有一个可以工作的功能基础；我知道这不是我第一次考虑编写这样的库，我想其他人也有过这种想法。

---

在之前的内容中，

我使用了类似的内容来使用我创建的 COM 库来与预编译的 win32/64 FFTW dll 进行互操作。对于这个问题，我们确实需要一些比我拥有的更通用的东西，所以我上周开始研究一些东西，它足以作为这些类型的用途的一个像样的通用库，具有可扩展的内存管理，多维度，切片，好吧

，昨天我终于向自己承认（a）还需要几天时间才能准备好，（b）我需要一个尖峰解决方案来弄清楚最后的一些内容。因此，我决定在较低的抽象级别上进行第一次切割，试图满足您问题中提到的需求。不幸的是，我们即将搬家，我必须收拾行李，但我认为这可能不足以解决您的问题。

我将在本周继续研究这个示例，我将在此处更新新代码，我将尝试从中提取足够的信息来发表一篇文章来解释它，但如果您仍然感兴趣，这是最后一个我'可能会在本周晚些时候发布：

http://www.mediafire.com/file/a7yq53ls18q7bvf/EfficientStorage-6639584.zip

它只是一个 VS2010 解决方案，具有做我认为满足您的需求的基本必需品。有很多评论，但请随意提出问题，我会在有互联网后立即回来查看......无论哪种方式，这都是一个有趣的项目。

完成示例后，我打算完成第一个迭代完整库并将其发布到某个地方；当我有链接时，我会在这里更新。

强制性警告：它可以编译但尚未经过测试；我确信存在问题，这是一个相当大的话题。

Answer 8

您可以为类型中的每个属性创建一个 System.Array 数组，其中包含一个元素。这些子数组的大小等于您拥有的对象的数量。属性访问将为：

masterArray[propertyIndex][objectIndex]

这将允许您使用值类型数组而不是对象数组。