llvm g ++ и функция повышения - PullRequest
Новая
       16

llvm g ++ и функция повышения

3 голосов
/ 15 марта 2012

Я пытаюсь определить, являются ли временные издержки, введенные boost :: function для оценки математических функций, пренебрежимо малыми по сравнению с использованием function templates.

кода для эталонного теста, который я используюниже.

С традиционным g++ накладные расходы с boost::function пренебрежимо малы: 

$ g++ -O3 main.cxx 
$ ./a.out
METHOD              INTEGRAL  TIME TO COMPUTE (SEC)         
Direct              0.379885  3.360000                      
Function template   0.379885  3.380000                      
Boost function      0.379885  3.400000

С llvm-g++ увеличение скорости в 1,5 раза для templates function, нонет усиления для boost::function. 

$ llvm-g++ -O3 main.cxx
METHOD              INTEGRAL  TIME TO COMPUTE (SEC)         
Direct              0.379885  2.170000                      
Function template   0.379885  2.160000                      
Boost function      0.379885  3.360000

Возможно ли получить усиление 1,5 для boost::function и llvm-g++? 

#include <boost/function.hpp>
#include <math.h>
#include <stdio.h>

typedef unsigned int UInt;

using namespace std;

//=============================================================================
// chrono
//=============================================================================
class Chrono
{
    clock_t t1_,t2_,dt_;
    public:
        Chrono(){}
        void   start() { t1_=clock(); };
        void   stop()  { t2_=clock(); };
        double diff()  { return ( (double)( t2_ - t1_) ) / CLOCKS_PER_SEC; };
};

//=============================================================================
// function to integrate
//=============================================================================
inline double fct(double x)
{
    return 1. / (1.+exp(x));
}

//=============================================================================
// using direct method
//=============================================================================
double direct(double a, double b, UInt numSamplePoints)
{
    double delta = (b-a) / (numSamplePoints-1);
    double sum = 0.;
    for (UInt i=0; i < numSamplePoints-1; ++i)
        sum += 1. / (1. + exp(a + i*delta));
    return sum * delta;
}

//=============================================================================
// using function template
//=============================================================================
template<double functionToIntegrate(double)>
double integrate(double a, double b, UInt numSamplePoints)
{
    double delta = (b-a) / (numSamplePoints-1);
    double sum = 0.;
    for (UInt i=0; i < numSamplePoints-1; ++i)
        sum += functionToIntegrate(a + i*delta);
    return sum * delta;
}

//=============================================================================
// using Boost function
//=============================================================================
typedef boost::function<double ( double )> fct_type;

class IntegratorBoost {
    public:
    fct_type functionToIntegrate;
    IntegratorBoost(fct_type fct): functionToIntegrate(fct){}
    double integrate(double a, double b, UInt numSamplePoints)
    {
        double delta = (b-a) / (numSamplePoints-1);
        double sum = 0.;
        for (UInt i=0; i < numSamplePoints-1; ++i)
        sum += functionToIntegrate(a + i*delta);
        return sum * (b-a) / numSamplePoints;
    }
};

//=============================================================================
// main
//=============================================================================
int main()
{
    double integral;
    UInt numSamplePoints = 5E07;
    Chrono chrono;

    printf("%-20s%-10s%-30s\n","METHOD","INTEGRAL","TIME TO COMPUTE (SEC)");

    // Direct
    chrono.start();
    integral = direct(0., 1., numSamplePoints);
    chrono.stop();
    printf("%-20s%-10f%-30f\n","Direct",integral,chrono.diff());

    // Function template
    chrono.start();
    integral = integrate<fct>(0., 1.,numSamplePoints);
    chrono.stop();
    printf("%-20s%-10f%-30f\n","Function template",integral,chrono.diff());

    // Boost function
    chrono.start();
    IntegratorBoost intboost(fct);
    integral = intboost.integrate(0.,1.,numSamplePoints);
    chrono.stop();
    printf("%-20s%-10f%-30f\n","Boost function",integral,chrono.diff());
}

1 Ответ

0 голосов
/ 15 марта 2012

Без реальных мер я рискну и утверждаю, что использование boost::function (или std::function из C ++ 11) не может быть столь же эффективным, как другие два варианта.

Причина в том, чтоfunction использует стирание типа, чтобы удалить тип фактического используемого функтора , и это означает, что function должен хранить фактический объект, который выполняет вызов через указатель, и использовать вызовы функций.С другой стороны, в двух других методах компилятор может встроить логику и убрать стоимость отправки.

Это на самом деле очень похоже на много раз упомянутое различие впроизводительность библиотеки C qsort по сравнению с C ++ sort, где при использовании функтора у компилятора больше шансов для встраивания и оптимизации.

Другой вопрос, будет ли этооказать влияние на ваше приложение, и для этого вам нужно измерить.Может случиться так, что общая стоимость IO или любой другой операции будет доминировать в вашем приложении, и это не будет иметь никакого значения.

...