Is there a way to acces RTTI directly in c++ to improve branch prediction in virtual calls?

Question

So I'm creating a library that will have a class someBase {}; which will be derived by downstream users in a number of classes.

class someBase {
  public:
    virtual void foo()=0;
};

What I also have, is a vector of pointers to someBase and I'm doing this :-

vector <someBase*> children;

// downstream user code populates children with some objects over here

for (i=0; i<children.size(); i++)
  children[i]->foo();

Now profiling suggests that the branch mispredictions on the virtual calls is one (of the several) bottlenecks in my code. What I'm looking to do is somehow access the RTTI of the objects and use that to sort the vector of children according to class type to improve both instruction cache locality and branch prediction.

Any suggestions/solutions on how this can be done?

The main challenges to keep in mind are :-

1.) I don't really know which or how many classes are going to be derived from someBase. Hypothetically, I could have a global enum in some common file somewhere that downstream users can edit to add their own class-type and then sort on that (basically implementing my own RTTI). But that's an ugly solution.

2.) PiotrNycz suggests in his answer below to use type_info. However, only != and == are defined for that. Any ideas on how to derive a strict weak ordering on type_info?

3.) I'm really looking to improve branch prediction and instruction cache locality so if there is an alternative solution, that would also be welcome.

@EdS. my bad. fixed that in the question. – owagh Sep 19 '12 at 20:08 — owagh, Sep 19 '12 at 20:08

PiotrNycz · Accepted Answer · 2012-09-19T20:58:57.290

4

There is typeid operator.

You can use it to define comparator for sorting your objects in vector.

Like this:

inline bool compareTypes(BaseClass* obj1, BaseClass* obj2)
{
   int compareRes = strcmp(typeid(*obj1).name(), typeid(*obj2).name());
   if (compareRes < 0) return true;
   if (compareRes > 0) return false;
   std::less<BaseClass*> ptrComp;
   return ptrComp(obj1, obj2); 
}

And:

  sort(v.begin(), v.end(), compareTypes);

[UPDATE]

Thanks for poiting me out that there is a function designed for this goal. It is std::type_info::before(const type_info&) const So the comparator will be as easy as this:

inline bool compareTypes(A* obj1, A* obj2)
{
   return typeid(*obj1).before(typeid(*obj2));
}

My earlier version is not so bad ;) It can be used for cases where one need to sort also objects of a given class.

edited Sep 19 '12 at 20:58

answered Sep 19 '12 at 20:12

PiotrNycz

23,099
7
66
112

well yes, but you only have != and == defined for type_info. Any ideas on how to derive a strict weak ordering from it? – owagh Sep 19 '12 at 20:16
You have name returning string from typeinfo returned from typeid. – PiotrNycz Sep 19 '12 at 20:18
1

I just make some update. I did not sure the `type_info` interface. `type_info::name()` return `const char*` so simple `strcmp` can be used. Not sure about `before()` - probably should be called twice to be sure if less, equal or greater... – PiotrNycz Sep 19 '12 at 20:22
Check out this question :- http://stackoverflow.com/questions/8682582/what-is-type-infobefore-useful-for . Your earlier solution was actually correct and this one isn't! – owagh Sep 19 '12 at 20:40
@owagh I checked this version on ideone: http://ideone.com/03NJW. It looks like working - but I have an error - `.` instead of `,`. But your are right with `before()` it will be faster. I'll add this version. Thanks. – PiotrNycz Sep 19 '12 at 20:54
@MooingDuck I'm not eliminating the vtable call. I'm just sorting it as per the class-type. And yes, it does have a small (~2-4%) improvement in run-time. – owagh Sep 19 '12 at 21:20
1

@MooingDuck See question. Per OP analysis - branch prediction is a problem. So OP wants to sort objects in vector to have branch prediction improved. I believe the sorting will be done once and execution will be done many times. – PiotrNycz Sep 19 '12 at 21:22
I _totally_ misunderstood. My bad. – Mooing Duck Sep 19 '12 at 21:23

score 0 · Answer 2 · edited Sep 18 '17 at 10:43

You can classify the pointers by type once in the initialization, by using for example:

std::vector<derivedA*> derivedA_list;
std::vector<derivedB*> derivedB_list;
//...

for (i=0; i<children.size(); i++)
    if (derivedA *d = dynamic_cast<derivedA*>(children[i]))
        derivedA_list.push_back(d);
    else if (derivedB *d = dynamic_cast<derivedB*>(children[i]))
        derivedB_list.push_back(d);
    //...

And then to call the function you can do a non-virtual call:

for (i=0; i<derivedA.size(); ++i)
    derivedA_list[i]->derivedA::foo();
for (i=0; i<derivedB.size(); ++i)
    derivedB_list[i]->derivedB::foo();

Also note that loops using iterators are likely to be better optimized.

Wrong cast, that should have been `dynamic_cast`. – MSalters Sep 20 '12 at 09:20 — MSalters, Sep 20 '12 at 09:20

Is there a way to acces RTTI directly in c++ to improve branch prediction in virtual calls?

2 Answers2