如何访问和管理块存储的数据

Question

我想做什么:我需要以块状形式存储单元格数据,即

*cell_member1 [cell0] .. cell_member1 [cellN] ... cell_memberM [cell0] .. cell_memberM [cellN]*

然后我需要有效地访问这些数据,如果可能的话,使用一个很好的语法.如果我能够轻松地定义要存储的数据,那将是很好的,即通过将成员定义为我想要存储的数据并将其传递给为我做一切的"魔术".

动机:为什么我需要这样做？缓存垃圾.在一些内部循环中,仅访问对象的一些成员.使用未使用的内存浪费一半缓存行不是我的应用程序的选项.我可以在指向某个顺序内存区域的对象中存储指针.这会浪费内存并迫使我在这个区域使用不同的语法.

我目前是怎么做的:我有一个容器:

template<class T> struct Container {
  char* data;
  Container(const int n) {
    data = new char[n*T::spaceRequirements()]; //< Data stored "block-wise"
    new(data) typename T::Flags[n]; //< Flags stored "cell-wise"
  }
  /// Destructor ommited for briefness.
};

我存储了T类型的一些单元格的数据.我需要每个单元格一些标记,现在我使用std :: bitset来存储它们,这意味着我需要以单元格形式存储这些位集:

*cell_member1 [cell0] ... cell_memberM [cell0] ... cell_member1 [cellN] .. cell_memberM [cellN]*

我在描述每个单元需要在下面的类中存储多少数据,这也提供了对数据的访问:

template<int nd> struct CellAccessor {
  /// Cell flags are stored cell-wise:
  typedef std::bitset<64> Flags;
  enum { DELETE = 0, ///< Cell marked for deletion
         REFINE = 1 ///< Cell marked for refinement
         //...
  }; ///< Enum for the flags.
  static inline Flags& flags(const int cellId) {
    return *reinterpret_cast<Flags*>(data + sizeof(Flags)*cellId); }
  template<int pId> static inline Flags::reference flags(const int cellId) {
    return flags(cellId)[pId]; } //< Cell-wise access to the properties

  /// The rest of the data is stored block-wise:
  static inline int& order(const int cellId) { ///< One int field.
    return *reinterpret_cast<int*>
        (data + maxNoCells*sizeof(Flags) + sizeof(int)*cellId);}

  /// Coordinate vector with nd components:
  static inline double& coordinates(const int cellId, const int i) {
    return *reinterpret_cast<double*>
        (data + maxNoCells*(sizeof(Flags)+sizeof(int))
         + maxNoCells*i*sizeof(double) + sizeof(double)*cellId); }
  template<int i> static inline double& coordinates(const int cellId) {
    return *reinterpret_cast<double*>
        (data +maxNoCells*(sizeof(Flags)+sizeof(int)+i*sizeof(double))
         + sizeof(double)*cellId); }

  /// Total amount of memory to allocate per cell: (used by Container)
  static inline int spaceRequirements() { return
        sizeof(Flags) // Flags
        + sizeof(int) // order
        + nd*sizeof(double) // coordinates
        ;}

  /// Constructor gets pointer to the beginning of the container 
  /// and the offset for the member variables:
  CellAccessor(char* d, int n){data = d; maxNoCells = n;}
 private:
  static char* data;  ///< Pointer to the beginning of the container.
  static int maxNoCells;  ///< Cell offset for the member variables.
};
template<int nd> char* CellAccessor<nd>::data = nullptr;
template<int nd> int CellAccessor<nd>::maxNoCells = 0;

我这样使用它:

int main() {
  int maxNoCells = 10000;   ///< Maximum number of cells (=cell offset).
  typedef CellAccessor<2> A;
  Container< A > cellData(maxNoCells);  ///< Allocate cell data.
  A cells(cellData.data,maxNoCells);  ///< Provides access to cell data.

  for(int i = 0; i < maxNoCells; ++i){
    cells.flags<A::DELETE>(i) = i%2==0 ? true : false;
    cells.flags<A::REFINE>(i) = i%2==0 ? false : true;
    cells.coordinates(i,0) = i;
    cells.coordinates<1>(i) = -((double)i);
    cells.order(i) = 2;
  }
}

优点:

• 数据是以块为单位形式的,这是我所需要的.

• 语法还可以.

问题:

• 我的课程做得太多了:为用户提供数据访问权限,提供需要为容器存储多少数据,提供如何为我的数据结构(树木......)移动/复制/交换数据... )...

• 没有迭代器我不能使用STL算法.我已经通过使迭代器存储单元索引并重新实现其中的CellAccessor类来实现迭代器(糟糕!干!).

• Bitset仍然以单元格形式存储.我可以为我的块方式数据结构重新实现bitset ...

• data和maxNoCells是静态变量,但如果需要,我可以使它们成为正常的成员变量.

问题:是否有任何有效的方法以块方式存储"对象"(或我们在概念上通过对象理解的内容)并访问它们,就像它们存储在诸如vector之类的std容器中一样？

Answer 1

你想要的是一种“基于列”的内存访问风格

您可以轻松地使用它std::vector作为列类型来实现它，或者使用自己的底层内存管理创建自己的“列”类型 - 但std::vector应该可以正常工作

现在，一旦您有了列类型，就可以创建“TABLE”类型。

在某种程度上，你的表格只是向量的向量。当然，您可以将其包装起来以获得更好看的访问器（如果您想首先按行（对象）访问，然后按列（属性）访问。

我认为这是最好的通用方法。

即使在您的特定情况下 - 因为您想使用位长度标志来节省内存，正如 Bart van Ingen Schenau 提到的，您可以使用 avector<bool>所以一般方法是这样的