这里访问了多少个不同的指针/间接层

How many different pointers/levels of indirection are accessed here?

本文关键字：指针 访问 多少 这里      更新时间：2023-10-16

我有四个代表继承和组合层次结构的类:

class A{
//Structure here not important
}
class B : public A{
    int a;
    shared_ptr<C> c;
}
class C{
   shared_ptr<D> d;
}
class D{
    std::list<int> e;
}

然后我有一个vector<shared_ptr<A>>，我迭代并求和两个D std::list<int>对象的*begin()值:

for(int i = 0; i< vec.size(); i++){
    shared_ptr<B> b = vec[i];
    shared_ptr<C> c = b->c;
    sum += *(c->d->e.begin());
}

我试图找出每次循环迭代可以进行多少单独的缓存行访问(如果我们假设最坏的情况下，每个间接/指针级别存储在不同的缓存行中)。

到目前为止，每次迭代我计算了7.25个不同的缓存行:

  1. 将shared_ptr<A>访问vec[i](这是0.25，因为sizeof(shared_ptr<A>)/64)
  2. 访问A对象vec[i]指向
  3. 访问 shared_ptr<C>c指向
    4. 访问C对象c指向
  4. 访问d
    5. 的shared_ptr<D>对象
  5. 访问对象D d
    6. 访问d的std::list<int> e指针
  6. 访问d的*begin()数据

我错过了什么吗?我不确定在循环(b和c)内的堆栈上创建的对象是否可以存储在不同的缓存行中，以访问它们正在访问的指针(vec[i]和b->c)。

在评论中添加答案以补充对话

这是你的循环和一些注释:

for(int i = 0; i< vec.size(); i++){
    shared_ptr<B> b = vec[i];  // create 1 copy of vec[i] - increments share cout
    shared_ptr<C> c = b->c;    // create 1 copy of b->c - increments share cout
    sum1 += *(c->d1->e.begin());  // merely dereference pointer
    sum2 += *(c->d2->e.begin());  // merely dereference pointer
}

你可以保存一些副本，因此一些缓存行丢失，如果你这样写:

for(int i = 0; i< vec.size(); i++){
    // take reference only - no copy. 
    //const means I promise not to modify the pointer object.
    const shared_ptr<B>& b = vec[i];  
    // take reference only - no copy. 
    //const means I promise not to modify the pointer object.
    const shared_ptr<C>& c = b->c;  // dereference b (which is really vec[i])
    sum1 += *(c->d1->e.begin());  // merely dereference pointer
    sum2 += *(c->d2->e.begin());  // merely dereference pointer
}
相关文章：