Question

我希望以所有数据都是连续的方式存储三维矩阵。 这是因为我需要使用MPI将矩阵发送到主节点，然后将所有较小的矩阵连接成一个大矩阵。这对于嵌套向量来说变得很麻烦，因为你只能发送超过一个int，double等，如果它们在内存中是连续的，那么你必须分别发送每个最内层的向量，比如

for (int i = 0; i < nx; i++) {
    for (int j = 0; j < ny; j++) {
        int id_of_data = i*ny*nz + j*nz;
        MPI_Send(&local_matrix[i][j][0], nz, MPI_DOUBLE, 0, id_of_data, MPI_COMM_WORLD);
    }
}

然后使用id_of_data在主节点上接收数据现在我正在使用std向量来存储矩阵，

std::vector<std::vector<std::vector<double> > > matrix;

所以我现在想坚持使用std :: vector。我意识到使用数组/指针很容易解决这个问题，但我想在使用std :: vectors之前尝试使用它。矩阵的维数是不变的，所以我不必担心动态分配。

我可以使用像这样的指针访问向量的元素

double* a = &matrix[x][y][z];

但我不知道如何做“相反”，即。

之类的东西

double* vec_ptr = new float(nz);
&matrix[x][y][0] = vec_ptr;

我想做的是

double* linear_matrix = new double(nx*ny*nz);

然后以某种方式使嵌套向量指向此数据。

Answer 1

我最终为这种情况创建了自己的类。矩阵操作库非常典型地将矩阵作为连续的数据块，但同时我希望能够使用标准的m [i] [j]访问器来填充和读取它。那么，你走了。下面是将任意维度的容器创建为连续内存块的代码。在这里使用boost预处理器可以做任何维度。如果你只需要它达到3d，那么去除它是非常明显的：）

<强> memblock.h

#ifndef BOOST_PP_IS_ITERATING

#ifndef MEMBLOCK_INCLUDED
#define MEMBLOCK_INCLUDED
#include <algorithm>
#include <boost/preprocessor.hpp>

#    ifndef MBLOCK_MAX_DIM
#      define MBLOCK_MAX_DIM 4
#    endif

template <typename T> class MemoryBlock1d
{
protected:
    T* m_data;
public:
    MemoryBlock1d() { m_data = 0; }
    MemoryBlock1d(int size) { m_data = 0;  resize(size); }
    MemoryBlock1d(int size, T val) { m_data = 0;  resize(size, val); }
    virtual ~MemoryBlock1d();
    inline T*& data() { return m_data; }
    inline void resize(int size);
    inline void resize(int size, T val);
    inline void clear();
    inline T& operator[](int i) { return m_data[i]; }
};

// Implementation 1d:
template <typename T> inline MemoryBlock1d<T>::~MemoryBlock1d()
{
    if (m_data)
    {
        delete[] m_data;
    }
}

template <typename T> inline void MemoryBlock1d<T>::clear()
{
    if (m_data)
    {
        delete[] m_data;
    }
    m_data = 0;
}

template <typename T> inline void MemoryBlock1d<T>::resize(int size)
{
    if (m_data)
    {
        delete[] m_data;
    }
    m_data = new T[size];
}

template <typename T> void MemoryBlock1d<T>::resize(int size, T val)
{
    resize(size);
    std::fill(m_data, m_data + size, val);
}


// generate multi_dimensional blocks:
#    define BOOST_PP_ITERATION_LIMITS (2, MBLOCK_MAX_DIM)
#    define BOOST_PP_FILENAME_1       "memblock.h"   // this file
#    include BOOST_PP_ITERATE()

#endif // MEMBLOCK_INCLUDED

#else // BOOST_PP_IS_ITERATING
#   define n BOOST_PP_ITERATION()
#   define nprev BOOST_PP_SUB(n, 1)
#   define MemoryBlockNd BOOST_PP_CAT(MemoryBlock, BOOST_PP_CAT(n, d))
#   define MemoryBlockPREVd BOOST_PP_CAT(MemoryBlock, BOOST_PP_CAT(nprev, d))
#   define MB_print(z, m, data) data
#   define MB_timesDATAM(z, m, data) * BOOST_PP_CAT(data, m)

template <typename T> class MemoryBlockNd : public MemoryBlock1d<T>
{
private:
    MemoryBlockPREVd<T*> m_pointers;
public:
    MemoryBlockNd() { MemoryBlock1d<T>::data() = 0; }
    MemoryBlockNd(BOOST_PP_ENUM_PARAMS(n, int size)) { MemoryBlock1d<T>::data() = 0;  resize(BOOST_PP_ENUM_PARAMS(n, size)); }
    MemoryBlockNd(BOOST_PP_ENUM_PARAMS(n, int size), T val) { MemoryBlock1d<T>::data() = 0;  resize(BOOST_PP_ENUM_PARAMS(n, size), val); }
    inline void resize(BOOST_PP_ENUM_PARAMS(n, int size));
    inline void resize(BOOST_PP_ENUM_PARAMS(n, int size), T val);
    inline T BOOST_PP_REPEAT(nprev, MB_print,*) & operator[](int i) { return m_pointers[i]; }
};

// Implementation n-dim:

template <typename T> void MemoryBlockNd<T>::resize(BOOST_PP_ENUM_PARAMS(n, int size))
{
    m_pointers.resize(BOOST_PP_ENUM_PARAMS(nprev, size));
    int sizePointers = size0 BOOST_PP_REPEAT_FROM_TO(1, nprev, MB_timesDATAM, size);
    int sizeData = sizePointers * BOOST_PP_CAT(size, nprev);
    MemoryBlock1d<T>::resize(sizeData);

    T *p = MemoryBlock1d<T>::data();
    T **ptr = m_pointers.data();

    for (int i=0; i < sizePointers; i++, p += BOOST_PP_CAT(size, nprev)) ptr[i] = p;
}

template <typename T> void MemoryBlockNd<T>::resize(BOOST_PP_ENUM_PARAMS(n, int size), T val)
{
    resize(BOOST_PP_ENUM_PARAMS(n, size));
    int sizeData = size0 BOOST_PP_REPEAT_FROM_TO(1, n, MB_timesDATAM, size);
    std::fill(MemoryBlock1d<T>::data(), MemoryBlock1d<T>::data() + sizeData, val);
}

#  undef MB_timesDATAM
#  undef MB_print
#  undef MemoryBlockPREVd
#  undef MemoryBlockNd
#  undef nprev
#  undef n
#endif // BOOST_PP_IS_ITERATING

<强> memblock.cpp

// test the class here
#include <stdio.h>
#include <memblock.h>

int main() {
  MemoryBlock3d<double> cube(2, 2, 2);
  double *p = &cube[0][0][0];

  for (int i=0; i < 8; i++)
    p[i] = 0.5 + i;

  for (int i=0; i < 2; i++)
    for (int j=0; j < 2; j++)
      for (int k=0; k < 2; k++)
        printf("%f\n", cube[i][j][k]);

  return 0;
}

有争议地在嵌套的STL载体中分配数据

1 个答案: