Question

我正在用C ++编写一些数值模拟代码。在这个模拟中，有些东西是“本地的”，在二维网格上的每个点都有浮点值，而其他东西是“全局的”，只有一个全局浮点值。

除了这种差异，两种类型的对象行为相似，因此我希望能够拥有一个包含两种类型对象的数组。但是，因为这是一个数值模拟，我需要这样做：（a）尽可能避免虚函数调用开销，（b）允许编译器尽可能多地使用优化 - 特别是允许编译器在可能的情况下进行SIMD自动化。

目前，我发现自己正在编写这样的代码（我现在意识到，实际上并没有按预期工作）：

class Base {};

class Local: public Base {
public:
    float data[size];
    // plus constructors etc.
};

class Global: public Base {
public:
    float data;
    // ...
};

void doStuff(Local a, Local b) {
    for (int i; i<size; ++i) {
        a.data[i] += b.data[i];
    }
}

void doStuff(Local a, Global b) {
    for (int i; i<size; ++i) {
        a.data[i] += b.data;
    }
}

void doStuff(Global a, Local b) {
    for (int i; i<size; ++i) {
        a.data += b.data[i];
    }
}

void doStuff(Global a, Global b) {
    a.data += b.data*size;
}

我的代码比这复杂一点 - 数组是二维的，并且有几个doStuff - 类型的函数有三个而不是两个参数，所以我必须为每个编写8个特化。

这不能正常工作的原因是doStuff的参数类型在编译时实际上并不知道。我想要做的是拥有一个Base *数组并在其两个成员上调用doStuff。然后，我希望为其参数的特定类型调用doStuff的正确特化。（如果在doStuff中涉及虚拟方法调用并不重要 - 我只想在内循环中避免它们。）

这样做的意义而不是（例如）重载operator[]是编译器可以（希望）对doStuff(Local, Local)和doStuff(Local, Global)进行SIMD自动矢量化，而我可以完全失去doStuff(Global, Global)中的循环。也许在这些函数中也可能发生其他编译器优化。

然而，必须编写这样的重复代码是很烦人的。因此，我想知道是否有办法使用模板实现这一点，这样我就可以编写一个函数doStuff(Base, Base)，并生成与上面相同的代码。（我希望gcc足够聪明，可以在doStuff(Global, Global)的情况下优化掉循环。）

我强调以下解决方案不我正在寻找什么，因为它涉及通过循环的每次迭代的虚函数调用，这增加了开销并且可能会阻止大量编译器优化

class Base {
    virtual float &operator[](int) = 0;
};

class Local: public Base {
    float data[size];
public:
    float &operator[](int i) {
        return data[i];
    }
    // …
};

class Global: public Base {
    float data;
public:
    float &operator[](int i) {
        return data;
    }
    // ...
};

void doStuff(Base a, Base b) {
    for (int i; i<size; ++i) {
        a[i] += b[i];
    }
}

我想实现与上面类似的效果，但是没有通过内部循环的每次迭代调用虚函数的开销。（除非我完全错了，编译器实际上可以优化所有虚函数调用并生成如上所述的代码。在这种情况下，你可以通过告诉我这个来节省我很多时间！）

我确实看了一下CRTP，但是由于doStuff的多个重载参数，至少不适合我，并不明白如何使其适应这种情况。

Answer 1

你几乎得到了答案。像这样的模板函数应该可以工作（虽然我不知道size来自哪里）：

template<typename A, typename B>
void doStuff(A & a, B & b) {
    for (int i; i<size; ++i) {
        a[i] += b[i];
    }
}

这里有一个超载的operator[]，但它不是虚拟的。

如果您在通话时不知道您有哪些类型，但是您有固定数量的派生类型，那么创建静态调度是一个选项

void doStuff( Base & a, Base & b ) {
    Local * a_local = dynamic_cast<Local*>(&a);
    Global * a_global = dynamic_cast<Global*>(&a);
    //same for b
    if( a_local && b_local ) {
        doStuffImpl(*a, *b); {
    } else if( a_local && b_global ) {
        doStuffImpl(*a, *b):
    } ...
}

假设doStuffImpl是模板函数，您会注意到if块中的代码对于每个条件都是相同的。我建议将其包装在宏中以减少代码开销。您可能还希望自己跟踪类型，不要使用dynamic_cast。在Base类中有一个明确列出类型的枚举。这是一种安全机制，基本上可以防止未知的派生类出现在doStuff。

不幸的是，这种方法是必需的。这是从动态类型转换为静态类型的唯一方法。如果你想使用模板，你需要静态模板。

Answer 2

您的代码是否可以Local了解Global和Global了解Local？

如果上述问题的答案是肯定的，那么你可以通过一个虚拟函数调用和几个动态强制转换来避免域中每个点的虚函数成本。

class Base {
    public:
       virtual void doStuff(Base& b) = 0;
};

class Local: public Base {
    public:
       virtual void doStuff(Base& b);
       float data[size];
       // plus constructors etc.
};

class Global: public Base {
    public:
       virtual void doStuff(Base& b);
       float data;
       // ...
};

void Local::doStuff(Base& b) {
    Local* lb = NULL;
    Global* gb = NULL;
    if ( NULL != (lb = dynamic_cast<Local*>(&b)) )
    {
       // Do Local+Local stuff.
    }
    else if ( NULL != (gb = dynamic_cast<Global*>(&b)))
    {
       // Do Local+Global stuff.
    }

}

void Global::doStuff(Base& b) {
    Local* lb = NULL;
    Global* gb = NULL;
    if ( NULL != (lb = dynamic_cast<Local*>(&b)) )
    {
       // Do Global+Local stuff.
    }
    else if ( NULL != (gb = dynamic_cast<Global*>(&b)))
    {
       // Do Global+Global stuff.
    }

}

void doStuff(Base a, Base b) {
    a.doStuff(b);
}

用数字C ++避免虚函数调用

2 个答案: