Difference between member functions and global function in release version

Do explicit template function instances make a performance difference?

Some experiments I have done to find the difference in performance:

1.
First, I suspected that the performance difference might be caused by the implementation itself. In fact, we have two sets of implementation, one is implemented by us (this one is very similar to the codes on @black) and the other is implemented to be used as a wrapper Eigen::Matrix

that is controlled by the on-off macro, but the transition between the two does not make any changes. global is still slower than member one.

2.
Since these codes (class Vector<Scalar, Dim>

and SquareMatrix<Scalar, Dim>

) are implemented in a large project, I believe that the difference in performance may be affected by other codes (although I think this is not possible, but still worth a try). This way I extract all the required codes (implementation as per our use) and put them in my handcrafted VS2010 project. Surprisingly, I generally find that the global is slightly faster than the member element, which is the same result as @black @Myles Hathcock, although I leave the implementation of the codes unchanged.

3.
Because in our project they outerProduct

are placed in the release lib files, while in my manual project it directly creates .obj files and is a link to .exe files. To rule out this issue, I use the extracted codes and create a lib file through VS2010 and apply that lib file to another VS project to test the performance difference, but still global - slightly faster than member. So both codes have the same implementation and both are put in lib files, although they are created by Scons and others are created by VS project, but they have different performance. Is Scons causing this problem?

4.
For the codes shown in my question, a global function is outerProduct

declared and defined in a file .h

and then a #include

file .cpp

. Therefore, compiling this file .cpp

will create an instance outerProduct

. But if I change this to another way:
(I have to remind you that these codes are now compiled by Scons to a file lib

, not a manually generated VS2010 project)
First, I declare a global function outerProduct

in the file .h

:

\\outProduct.h
template<typename Scalar, int Dim>
void outerProduct(const Vector<Scalar, Dim> & v1 , const Vector<Scalar, Dim> & v2, SquareMatrix<Scalar, Dim> & m);

      

        
        
        
      

    

then in the file .cpp

,

\\outerProduct.cpp
template<typename Scalar, int Dim>
void outerProduct(const Vector<Scalar, Dim> & v1 , const Vector<Scalar, Dim> & v2, SquareMatrix<Scalar, Dim> & m)
{
    for (unsigned int i=0; i<Dim; i++)
        for (unsigned int j=0; j<Dim; j++)
        {
            m(i,j) = v1[i]*v2[j];
        }
}

      

        
        
        
      

    

Since this is a template function, it requires some explicit instances:

\\outerProduct.cpp
template void outerProduct<double, 3>(const Vector<double, 3> &, const Vector<double, 3> &, SquareMatrix<double, 3> &);
template void outerProduct<float, 3>(const Vector<float, 3> &, const Vector<float, 3> &, SquareMatrix<float, 3> &);

      

        
        
        
      

    

Finally, in the file .cpp

that calls this function:

\\use_outerProduct.cpp
#include "outerProduct.h" //note: outerProduct.cpp is not needful.
...
outerProduct(v1, v2, m)
...

      

        
        
        
      

    

The weird thing now is that the global is finally slightly faster than the element shown in the following figure:

But this only happens in the Scons environment. In a human VS2010 project, the global will always be slightly faster than the member. So this performance difference only comes from the Scons environment? and if the template function is explicitly instantiated, will it become normal?

Still weird! It seems like Scons would do something I didn't expect.

// --------------------------------------------- --- ------------------------
In addition, test codes have now been changed to the following rules to avoid cycle echelon:

    Vector<double, 3> vec1(0.0);
    Vector<double, 3> vec2(1.0);
    Timer timer;
    while(true)
    {
        timer.startTimer();
        for (unsigned int i=0; i<100000; i++)
        {
            vec1 = Vector<double, 3>(i);
            SquareMatrix<double,3> m = vec1.outerProduct(vec2);
        }
        timer.stopTimer();
        cout<<"time cost for member function: "<< timer.getElapsedTime()<<endl;

        timer.startTimer();
        SquareMatrix<double,3> m;
        for (unsigned int i=0; i<100000; i++)
        {
            vec1 = Vector<double, 3>(i);
            outerProduct(vec1, vec2, m);
        }
        timer.stopTimer();
        cout<<"time cost for global function: "<< timer.getElapsedTime()<<endl;
        system("pause");
    }

      

        
        
        
      

    

@black @Myles Hathcock, Many thanks to the heartfelt people!
@Myles Hathcock, your explanation is really subtle and abstruse, but I think I would benefit a lot from this. Finally, the entire implementation is at
https://github.com/FeiZhu/Physika
This is the physics engine that we are developing and from which you can find more information, including all source codes. Vector

and SquareMatrix

defined in the folder Physika_Src/Physika_Core

! But the global function is outerProduct

not loaded, you can add it appropriately somewhere.