C++ - Static polymorphism vs Runtime polymorphism vs Lambda - c++

Question

I learned the difference between static and run-time polymorphism and since then I've been reading a lot of stuff on it.
Plus, since I found out that implementing a static polymorphic interface (in a manner that a class can use an object with the base class definition without knowing what "derived" class the object was instantiated with).
So I ran a little test to compare these different implementations.
Here is the code:
#include <functional>
#include <iostream>
#include <ctime>
#include <chrono>
#include <memory>
class BaseLambda
{
public:
double run(double param){return m_func(param);};
protected:
BaseLambda(std::function<double(double)> func) : m_func(func) { };
std::function<double(double)> m_func;
};
class DerivedLambda : public BaseLambda
{
public:
DerivedLambda() : BaseLambda([](double param){return DerivedLambda::runImpl(param);}) { };
private:
static double runImpl(double param) {return (param * param) / 2.5;};
};
class BaseVirtual
{
public:
double run(double param){return runImpl(param);};
protected:
virtual double runImpl(double param) = 0;
};
class DerivedVirtual : public BaseVirtual
{
protected:
double runImpl(double param) {return (param * param) / 2.5;};
};
template<class C> class BaseTemplate
{
public:
double run(double param){return static_cast<C*>(this)->runImpl(param);};
};
class DerivedTemplate : public BaseTemplate<DerivedTemplate>
{
public:
double runImpl(double param) {return (param * param) / 2.5;};
};
int main()
{
std::clock_t c_start = std::clock();
std::unique_ptr<BaseVirtual> baseVirtual = std::make_unique<DerivedVirtual>();
for(unsigned int i = 0 ; i < 1000000 ; ++i) {
auto var = baseVirtual->run(10.6);
}
baseVirtual.reset(nullptr);
std::clock_t c_end = std::clock();
std::cout << "Execution time with virtual : "
<< 1000.0 * (c_end-c_start) / CLOCKS_PER_SEC << " ms" << std::endl;
c_start = std::clock();
std::unique_ptr<BaseLambda> baseLambda = std::make_unique<DerivedLambda>();
for(unsigned int i = 0 ; i < 1000000 ; ++i) {
auto var = baseLambda->run(10.6);
}
baseLambda.reset(nullptr);
c_end = std::clock();
std::cout << "Execution time with lambda : "
<< 1000.0 * (c_end-c_start) / CLOCKS_PER_SEC << " ms" << std::endl;
std::unique_ptr<BaseTemplate<DerivedTemplate>> baseTemplate = std::make_unique<DerivedTemplate>();
for(unsigned int i = 0 ; i < 1000000 ; ++i) {
auto var = baseTemplate->run(10.6);
}
baseTemplate.reset(nullptr);
c_end = std::clock();
std::cout << "Execution time with template : "
<< 1000.0 * (c_end-c_start) / CLOCKS_PER_SEC << " ms" << std::endl;
}
The thing is, when I ran this, the virtual implementation is the fastest while static polymorphism is supposed to be faster.
Here is an execution result example:
Execution time with virtual: 53 ms
Execution time with lambda: 94 ms
Execution time with template: 162 ms
I'm guessing that it is because of some compiler optimization. I compile with gcc 6.3.0.
The my question is: why the template implementation the slowest? Is it really because of compiler's optimization, and if it is, what are they and how can I change my test to have the "real" running time? And if not, what have I done wrong?