动态向量的特征库内存使用情况

Question

我有一个存储 float32 对象的二进制文件（其中 9748422*5 个）。从这样一个集合（大约 190MB 大小）中，我创建了一组 Eigen::VectorXd 向量（每个向量有 5 个分量），因此其中有 9748422 个。底层类型是double，因此存储它们的输入大小大约是两倍。

但是，幸运的是，该过程总共需要 2.5GB。这是PROCESS_MEMORY_COUNTERS的日志：

    PageFaultCount: 0x000A3C40
    PeakWorkingSetSize: 0xA3C42000
    WorkingSetSize: 0xA3C42000
    QuotaPeakPagedPoolUsage: 0x00004ED8
    QuotaPagedPoolUsage: 0x00004ED8
    QuotaPeakNonPagedPoolUsage: 0x000057A8
    QuotaNonPagedPoolUsage: 0x000057A8
    PagefileUsage: 0xA3A9B000
    PeakPagefileUsage: 0xA3A9B000

我跟踪了 Eigen 的内部分配器，它似乎确实“分配”了我在纸上计算的大小。然而，Eigen 的大部分动态向量都使用了aligned_alloc。这会造成如此严重的破坏吗？如果没有想到，您能否推荐其他地方来查找为什么会发生这种情况的问题？

我无法提供可编译的（在线）cpp 示例，但这是我正在做的事情的概要：

struct SSCCE_struct
{
    Eigen::VectorXd m_data;
};

typedef std::vector<SSCCE_struct*> TVector;

int main(int argc, char* argv[])
{
    TVector outputVertices;
    HANDLE bpcHandle;
    bpcHandle = CreateFileA("D:\\sample.bpc",              
        GENERIC_READ,          
        FILE_SHARE_READ,       
        NULL,                 
        OPEN_EXISTING,        
        FILE_ATTRIBUTE_NORMAL, 
        NULL);                 

    LARGE_INTEGER  len_li;
    GetFileSizeEx (bpcHandle, &len_li);
    INT64 len = len_li.QuadPart; //(len_li.u.HighPart << 32) | len_li.u.LowPart;

    unsigned long long noPoints = len / 20;
    unsigned long noPointsRead = 0;
    unsigned long long currPointIdx = 0;

    outputVertices.resize( noPoints );

    DebugTrace( "No points %lu \n", noPoints );

    float buffer[ 5 * 1024 ];
    DWORD noBytesRead = 0;
    do 
    {
        ReadFile(bpcHandle, buffer, sizeof(buffer), &noBytesRead, NULL);
        noPointsRead = noBytesRead / 20;
        for (unsigned long idx = 0; idx < noPointsRead; ++idx )
        {
            outputVertices[ currPointIdx + idx ] = new SSCCE_struct();

            outputVertices[ currPointIdx + idx ]->m_data.resize(5);

            for (unsigned kdx = 0; kdx < 5; ++kdx)
            {
                outputVertices[ currPointIdx + idx ]->m_data[ kdx ] = buffer[ 5 * idx + kdx ];
            }
        }

        currPointIdx += noPointsRead;

    } while (noBytesRead);


    CloseHandle(bpcHandle);
}
}

稍后编辑：

我执行了大卫回答中指出的测试，解决方案是完全避免动态分配。您可以尝试多种组合，以下是所有这些组合的结果：

1.

struct SSCCE_struct
{
    Eigen::Matrix<double,1,5> m_data;
};

typedef std::vector<SSCCE_struct*> TVector;

产生 1.4 GB（1.1 GB 浪费）

2.

 struct SSCCE_struct
 {
    Eigen::VectorXd m_data;
 };

 typedef std::vector< SSCCE_struct* > TVector;

产生 2.5 GB（2.2 GB 浪费）

3.

struct SSCCE_struct
{
    Eigen::Matrix<double,1,5> m_data;
};

typedef std::vector<SSCCE_struct> TVector;

产生 381 GB（有 40 MB 的浪费 - 完全合理，也许是可预测的）。

Answer 1

这里有很多指针，每个指针都有分配开销。指针指向小对象，因此开销很大。

最重要的是，动态分配的对象必然比固定大小的对象有更多的开销。这是因为固定大小的对象不需要存储矩阵维度。

以下是指针开销的来源：

1. Eigen::VectorXd 使用动态分配的存储。这意味着一个指针。
2. 您将对象存储在std::vector<SSCCE_struct*> 中。这是另一个指针，有开销。

存储这些对象最有效的方法是删除间接性。你可以通过切换到：

1. Matrix<double, 5, 1>。这是一个固定大小的对象，因此没有间接性。更重要的是，如上所述，它不需要在运行时存储矩阵维度，因为它们在编译时是已知的。对于这样一个意义重大的小物体。
2. 将对象存储在std::vector<SSCCE_struct> 中。同样，您失去了一层间接性。

通过这些更改，在我的机器上使用发布设置编译时，程序的内存使用量降至 383MB。这更符合您的期望。

最大的区别似乎在Eigen::VectorXd 和固定大小的对象之间。如果我使用Eigen::VectorXd 和std::vector<SSCCE_struct>，那么内存使用量会跳转到 918MB。然后当我转到 std::vector<SSCCE_struct*> 时，它会进一步跳转到 1185MB。

这些测量将高度依赖于编译器。我用VS2013编译32位代码。

Answer 2

我不允许发表评论，所以我会再发布一个答案，尽管我认为上述答案实际上解释了浪费内存的来源（大量分配）。

我知道你想处理很多 penta，所以你使用的是 struct SSCCE_struct 的向量，即

std::vector<SSCCE_struct*> TVector;

你考虑过使用

Eigen::Matrix< double, Dynamic, 5 > outputVertices;
outputVertices.resize( noPoints, 5 );

这样可以避免内存的浪费。我也会考虑将其用于矢量化（以帮助 eigen/compiler 更好地矢量化您对它们所做的任何事情），即使 5 对于矢量化 4 或 8 而言不是一个非常方便的数字。

编辑：当我点击帖子的那一刻，我意识到我迟到了 3 年......