PA4 – Implicit Conversions, RVOs and Proxy Objects!

Hello once again! I am trying to keep the pace here with the posts and hopefully you are enjoying them. Today I will talk about Assignment #4 (PA4) – C++ Efficiency. This assignment was a combination of three important topics about Efficiency in C++ programming: Implicit Conversions, Return Value Optimizations and Proxy Objects. I will give you a summary of each one in the following paragraphs:

• Implicit Conversions: the whole idea behind this trick/optimization is to prevent coders from passing wrong-typed parameters to functions. For example, imagine that you have a set function for a particular member of a class and you do not want the user to pass a value that has a different type, how can you achieve this? Aside from turning up the compiler settings (warnings), there is one trick you could use:

Class Diego {

public:

          void setX( const  float  inX );

private:

          template <typename T> void setX( const T inX );

}

When this trick is applied, anything but a float variable will give a compilation error, therefore successfully preventing wrong-typed values to be passed as parameters. Sexy or what?

• Return Value Optimizations: I will start by saying this: temporaries kill performance big time! (quoting famous philosopher Ed Keenan). The idea behind RVO is to remove as much temporary variables as possible in order to improve performance. By removing these temporaries we are also removing unnecessary calls to constructors, destructors, copy constructors, etc. Let’s look at the following example to better understand the idea:

With temporaries (No RVO):

Vect2D Vect2D::operator + ( const Vect2D &tmp ) const {

    Vect2D sum;

    sum.x = this->x + tmp.x;

    sum.y = this->y + tmp.y;

    return ( sum );

};

Without temporaries (RVO):

Vect2D Vect2D::operator + ( const Vect2D &tmp ) const {

    return Vect2D( this->x + tmp.x, this->y + tmp.y );

};

You might think this change does not improve performance a lot, but in my assignment I had a stress test in which a bunch of math operations were performed and repeated 5 million times, and just by using RVO I improved the time to 301ms down from 939ms originally. That’s a hell of an improvement in my opinion!

• Proxy objects: this one is another trick to remove/reduce temporaries and copies from function calls. This method involves (ab)using operator overloading to: replace operations that involve more than two operands, to compare vector length using squared distance instead of square root, etc. I will show you guys an example for your entertainment and pleasure, try running/debugging it so you really understand  what is going on (it took me a while to get it):

struct VaddV {

    const Vect2D &v1;

    const Vect2D &v2;

    VaddV( const Vect2D &t1, const Vect2D &t2 )

        : v1(t1), v2(t2) {};

    operator Vect2D() {

        return Vect2D( v1.x + v2.x, v1.y + v2.y );

    }

};

inline Vect2D::VaddV operator + ( const Vect2D &a1, const Vect2D &a2 ) {

    return Vect2D::VaddV(a1, a2);

};

Try performing an addition operation between three (3) vectors and you will see this baby up and running.

Well my fellow readers, I hope these tricks are useful for you, and if not try using them as opening lines in your next date (not recommended). See you later! Adios!