这里访问了多少不同的指针/间接级别？

Question

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

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指向
5. 访问 d 的 shared_ptr<D> 对象
6. 访问对象D d
7. 访问d的std::list<int> e指针
8. 访问d的*begin()数据

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

Answer 1

添加答案以补充 cmets 中的对话

这是带有一些 cmets 的循环：

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
}