shadowrect code

I just posted the shadowrect code that I mention in my old 2001 article. I've emailed it to a couple dozen people in the last 5 years, and it seemed like time to just put it up.

New Thunderbird

Just wanted to say that the new Thunderbird beta has great notifications (it has excerpts, kinda like Outlook). This wastes so much less time for me, because I don't go reading emails that I'm not interested in.

Now I just need a delete button in the notification window...

mike

How slow is dynamic_cast?

C++ users are advised frequently not to use dynamic_cast, because it's slow.

I thought it would be nice to measure this, so I made up a test on Visual C++. All you need is a simple hierarchy of types with a baseclass, a derived class, and another class derived from that.

The test is this: if you only know that an object is derived from the baseclass, prove whether or not it's of a certain type and (if so) call an appropriate method on it. And you typically want to be able to measure how fast you can determine that a base class is not of a certain type too.

The typical workaround to dynamic_cast is to make a base virtual method like this:

virtual int32 Name() = 0;

I measured that too.

Here's how things wind up in my test:

Base case

• Use reinterpret_cast on a known type, call a simple 2-cycle method.
• Result: 1.1B operations/sec (half my CPU speed, good)
  

Virtual case

• Implement a virtual method per derived class, call it, check the result. If it matches what we want, follow the base case.
• Result: 270M operations/sec for positive and negative tests
  

dynamic_cast case

• Calls dynamic_cast, and if non-NULL result, calls a method.
• Proof positive (is the type you want): 21M operations/sec
• Proof negative (NULL result, single derivation): 15M operations/sec
• Proof negative (NULL result, two-level derivation): 11M operations/sec
  

Conclusions

dynamic_cast costs a lot. A simple call can use 100-200 cycles under Visual C++. Calling a virtual function (or checking a base-class member) and testing the result can run up to 20x faster.

However, it is more general than the other listed methods (because you can cast to intermediate types), and it doesn't use extra space in your binary like a bunch of virtual functions do.

But it's not so advisable in performance-critical code.