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>>，我会迭代并汇总来自两个*begin()对象的D std::list<int>值：

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个不同的缓存行：

访问shared_ptr<A>至vec[i]（这是0.25，因为sizeof(shared_ptr<A>)/64）
访问A对象vec[i]指向
访问shared_ptr<C> c指向
访问C对象c指向
访问d {/ 1>的shared_ptr<D>对象
访问对象D d
访问d的{{1}}指针
访问std::list<int> e的{{1}}数据

我有什么遗漏的吗？我不确定在循环内的堆栈上创建的对象（d和*begin()）是否可以存储在他们正在访问的指针的不同缓存行中（b和{{1} }）。

Answer 1

在评论

中添加补充以补充对话

这是你的循环，有一些评论：

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
}

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

1 个答案: