Boost C++ Libraries: Ticket #2563: [boost][serialization] void_upcast is very slow

status changed

Robert Ramey — Thu, 04 Dec 2008 20:29:20 GMT

status new → assigned

I am interested in making the library faster.

But, I don't see your solution working execept in special cases. void_upcast also "shifts" the pointer much like

static_cast<A *>(b)

would. Your solution would work only when the derived class has not member variables

Robert Ramey

attachment set

jacobholm@… — Fri, 05 Dec 2008 10:03:02 GMT

attachment → Main.cpp

static_cast test

jacobholm@… — Fri, 05 Dec 2008 10:03:59 GMT

The project I am using contains derived classes with member variables. If possible, I think that the best way would be to modify void_upcast to use static_cast<T> with templates. That way one would be able to use multiple inheritance as well. Another solution could be to have an option to disable upcast alltogether, letting the user keep track of inheritance between classes. If used correctly this last solution will work with multiple inheritance as well.

I have attached an example cpp file to the ticket which uses static_cast on derived objects, together with multiple inheritance.

Yours sincerely,

Jacob Holm

status changed; resolution set

Robert Ramey — Thu, 11 Dec 2008 16:28:01 GMT

status assigned → closed
resolution → invalid

I've looked at the code and your test. I've concluded the following:

a) I won't dispute that void_upcast is slower than a static cast. It may be possible to make it faster. b) I double checked the serialization code to verify that void_upcast was only being invoked when it was absolutely necessary. I'm satisfied that it is. c) So I've concluded that your proposed change will cause the serialization library to fail except in some cases. d) I took a look at your test. It's not obvious to me what it is actually meant to show and how it would relate to the replacement of void_upcast with a static cast.

Robert Ramey

jacobholm@… — Fri, 12 Dec 2008 08:41:06 GMT

/inline void *
void_upcast(
 extended_type_info const & derived,
 extended_type_info const & base,
 void * const t
){
  return const_cast<void*>(t);
}/

The code above was the first to be suggested. This code will not work with multiple inheritance. Then there would be need for a method that detects if there is multiple inheritance or not. But if we were to modify it to use templates and static_cast it would work with multiple inheritance as well:

template <typename A>
class cast
{
public:
 template<typename B>
 static A* void_upcast(
   B* const t
 )
 {
   return static_cast<A*>(const_cast<B*>(t));
 }
};

Example using the above code:

const B *t;
cast<A*>::void_upcast(t);

This solution is based on that we know the class type so that we can call the template class.

I also have some comments your conclusions:

c) Why will the serialization fail with static_cast? Perhaps you could provide a code example?

d) It is meant to show that static_cast may change the pointer when casting with multiple inheritance, and never change the pointer when using single inheritance.

Yours sincerely,

Jacob Holm