performance.cpp

来自「Boost provides free peer-reviewed portab」· C++ 代码 · 共 512 行 · 第 1/2 页

    typedef RGB_PLANAR_VIEW(T1) View1;
    typedef RGB_PLANAR_VIEW(T2) View2;
    View1 _v1;
    View2 _v2;
    copy_nongil_t(const View1& v1_in,const View2& v2_in) : _v1(v1_in), _v2(v2_in) {}
    void operator()() const {
        std::size_t size=_v1.size();
        T1* first10=(T1*)at_c<0>(_v1.row_begin(0));
        T1* first11=(T1*)at_c<1>(_v1.row_begin(0));
        T1* first12=(T1*)at_c<2>(_v1.row_begin(0));
        T2* first20=(T2*)at_c<0>(_v2.row_begin(0));
        T2* first21=(T2*)at_c<1>(_v2.row_begin(0));
        T2* first22=(T2*)at_c<2>(_v2.row_begin(0));
        std::copy(first10,first10+size,first20);
        std::copy(first11,first11+size,first21);
        std::copy(first12,first12+size,first22);
    }
};
template <typename T1, typename T2>
struct copy_nongil_t<RGB_VIEW(T1),RGB_PLANAR_VIEW(T2)> {
    typedef RGB_VIEW(T1) View1;
    typedef RGB_PLANAR_VIEW(T2) View2;
    View1 _v1;
    View2 _v2;
    copy_nongil_t(const View1& v1_in,const View2& v2_in) : _v1(v1_in), _v2(v2_in) {}
    void operator()() const {
        T1* first=(T1*)_v1.row_begin(0);
        T1* last=first+_v1.size()*3;
        T2* first0=(T2*)at_c<0>(_v2.row_begin(0));
        T2* first1=(T2*)at_c<1>(_v2.row_begin(0));
        T2* first2=(T2*)at_c<2>(_v2.row_begin(0));
        while(first!=last) {
            *first0++=first[0];
            *first1++=first[1];
            *first2++=first[2];
            first+=3;
        }
    }
};
template <typename T1, typename T2>
struct copy_nongil_t<RGB_PLANAR_VIEW(T1),RGB_VIEW(T2)> {
    typedef RGB_PLANAR_VIEW(T1) View1;
    typedef RGB_VIEW(T2) View2;
    View1 _v1;
    View2 _v2;
    copy_nongil_t(const View1& v1_in,const View2& v2_in) : _v1(v1_in), _v2(v2_in) {}
    void operator()() const {
        T1* first=(T1*)_v2.row_begin(0);
        T1* last=first+_v2.size()*3;
        T2* first0=(T2*)at_c<0>(_v1.row_begin(0));
        T2* first1=(T2*)at_c<1>(_v1.row_begin(0));
        T2* first2=(T2*)at_c<2>(_v1.row_begin(0));
        while(first!=last) {
            first[0]=*first0++;
            first[1]=*first1++;
            first[2]=*first2++;
            first+=3;
        }
    }
};
template <typename View1, typename View2>
void test_copy(std::size_t trials) {
    image<typename View1::value_type, is_planar<View1>::value> im1(width,height);
    image<typename View2::value_type, is_planar<View2>::value> im2(width,height);
    std::cout << "GIL: "    <<measure_time(copy_gil_t<View1,View2>(view(im1),view(im2)),trials) << std::endl;
    std::cout << "Non-GIL: "<<measure_time(copy_nongil_t<View1,View2>(view(im1),view(im2)),trials) << std::endl;
}

// transform()
template <typename T,typename Pixel>
struct bgr_to_rgb_t {
    pixel<T,rgb_layout_t> operator()(const Pixel& p) const {
        return pixel<T,rgb_layout_t>(T(get_color(p,blue_t())*0.1f),
                                     T(get_color(p,green_t())*0.2f),
                                     T(get_color(p,red_t())*0.3f));
    }
};
template <typename View1, typename View2, typename F>
struct transform_gil_t {
    View1 _v1;
    View2 _v2;
    F _f;
    transform_gil_t(const View1& v1_in,const View2& v2_in,const F& f_in) : _v1(v1_in),_v2(v2_in),_f(f_in) {}
    void operator()() const {transform_pixels(_v1,_v2,_f);}
};
template <typename View1, typename View2, typename F> struct transform_nongil_t;
template <typename T1, typename T2, typename F>
struct transform_nongil_t<RGB_VIEW(T1),RGB_VIEW(T2),F> {
    typedef RGB_VIEW(T1) View1;
    typedef RGB_VIEW(T2) View2;
    View1 _v1;
    View2 _v2;
    F _f;
    transform_nongil_t(const View1& v1_in,const View2& v2_in,const F& f_in) : _v1(v1_in),_v2(v2_in),_f(f_in) {}
    void operator()() const {
        T1* first1=(T1*)_v1.row_begin(0);
        T2* first2=(T1*)_v2.row_begin(0);
        T1* last1=first1+_v1.size()*3;
        while(first1!=last1) {
            first2[0]=T2(first1[2]*0.1f);
            first2[1]=T2(first1[1]*0.2f);
            first2[2]=T2(first1[0]*0.3f);
            first1+=3; first2+=3;
        }
    }
};
template <typename T1, typename T2, typename F>
struct transform_nongil_t<RGB_PLANAR_VIEW(T1),RGB_PLANAR_VIEW(T2),F> {
    typedef RGB_PLANAR_VIEW(T1) View1;
    typedef RGB_PLANAR_VIEW(T2) View2;
    View1 _v1;
    View2 _v2;
    F _f;
    transform_nongil_t(const View1& v1_in,const View2& v2_in,const F& f_in) : _v1(v1_in),_v2(v2_in),_f(f_in) {}
    void operator()() const {
        T1* first10=(T1*)at_c<0>(_v1.row_begin(0));
        T1* first11=(T1*)at_c<1>(_v1.row_begin(0));
        T1* first12=(T1*)at_c<2>(_v1.row_begin(0));
        T1* first20=(T2*)at_c<0>(_v2.row_begin(0));
        T1* first21=(T2*)at_c<1>(_v2.row_begin(0));
        T1* first22=(T2*)at_c<2>(_v2.row_begin(0));
        T1* last10=first10+_v1.size();
        while(first10!=last10) {
            *first20++=T2(*first12++*0.1f);
            *first21++=T2(*first11++*0.2f);
            *first22++=T2(*first10++*0.3f);
        }
    }
};
template <typename T1, typename T2, typename F>
struct transform_nongil_t<RGB_VIEW(T1),RGB_PLANAR_VIEW(T2),F> {
    typedef RGB_VIEW(T1) View1;
    typedef RGB_PLANAR_VIEW(T2) View2;
    View1 _v1;
    View2 _v2;
    F _f;
    transform_nongil_t(const View1& v1_in,const View2& v2_in,const F& f_in) : _v1(v1_in),_v2(v2_in),_f(f_in) {}
    void operator()() const {
        T1* first1=(T1*)_v1.row_begin(0);
        T1* last1=first1+_v1.size()*3;
        T1* first20=(T2*)at_c<0>(_v2.row_begin(0));
        T1* first21=(T2*)at_c<1>(_v2.row_begin(0));
        T1* first22=(T2*)at_c<2>(_v2.row_begin(0));
        while(first1!=last1) {
            *first20++=T2(first1[2]*0.1f);
            *first21++=T2(first1[1]*0.2f);
            *first22++=T2(first1[0]*0.3f);
            first1+=3;
        }
    }
};
template <typename T1, typename T2, typename F>
struct transform_nongil_t<RGB_PLANAR_VIEW(T1),RGB_VIEW(T2),F> {
    typedef RGB_PLANAR_VIEW(T1) View1;
    typedef RGB_VIEW(T2) View2;
    View1 _v1;
    View2 _v2;
    F _f;
    transform_nongil_t(const View1& v1_in,const View2& v2_in,const F& f_in) : _v1(v1_in),_v2(v2_in),_f(f_in) {}
    void operator()() const {
        T1* first10=(T1*)at_c<0>(_v1.row_begin(0));
        T1* first11=(T1*)at_c<1>(_v1.row_begin(0));
        T1* first12=(T1*)at_c<2>(_v1.row_begin(0));
        T2* first2=(T1*)_v2.row_begin(0);
        T1* last2=first2+_v1.size()*3;
        while(first2!=last2) {
            first2[0]=T2(*first12++*0.1f);
            first2[1]=T2(*first11++*0.2f);
            first2[2]=T2(*first10++*0.3f);
            first2+=3;
        }
    }
};

template <typename View1, typename View2, typename F>
void test_transform(std::size_t trials) {
    image<typename View1::value_type, is_planar<View1>::value> im1(width,height);
    image<typename View2::value_type, is_planar<View2>::value> im2(width,height);
    std::cout << "GIL: "    <<measure_time(transform_gil_t<View1,View2,F>(view(im1),view(im2),F()),trials) << std::endl;
    std::cout << "Non-GIL: "<<measure_time(transform_nongil_t<View1,View2,F>(view(im1),view(im2),F()),trials) << std::endl;
}

int main() {
#ifdef NDEBUG
    std::size_t num_trials=1000;
#else
    std::size_t num_trials=1;
#endif

    // fill()
    std::cout<<"test fill_pixels() on rgb8_image_t with rgb8_pixel_t"<<std::endl;
    test_fill<rgb8_view_t,rgb8_pixel_t>(num_trials);
    std::cout<<std::endl;

    std::cout<<"test fill_pixels() on rgb8_planar_image_t with rgb8_pixel_t"<<std::endl;
    test_fill<rgb8_planar_view_t,rgb8_pixel_t>(num_trials);
    std::cout<<std::endl;

    std::cout<<"test fill_pixels() on rgb8_image_t with bgr8_pixel_t"<<std::endl;
    test_fill<rgb8_view_t,bgr8_pixel_t>(num_trials);
    std::cout<<std::endl;

    std::cout<<"test fill_pixels() on rgb8_planar_image_t with bgr8_pixel_t"<<std::endl;
    test_fill<rgb8_planar_view_t,bgr8_pixel_t>(num_trials);
    std::cout<<std::endl;

    // for_each()
    std::cout<<"test for_each_pixel() on rgb8_image_t"<<std::endl;
    test_for_each<rgb8_view_t,rgb_fr_t<bits8> >(num_trials);
    std::cout<<std::endl;

    std::cout<<"test for_each_pixel() on rgb8_planar_image_t"<<std::endl;
    test_for_each<rgb8_planar_view_t,rgb_fr_t<bits8> >(num_trials);
    std::cout<<std::endl;

    // copy()
    std::cout<<"test copy_pixels() between rgb8_image_t and rgb8_image_t"<<std::endl;
    test_copy<rgb8_view_t,rgb8_view_t>(num_trials);
    std::cout<<std::endl;

    std::cout<<"test copy_pixels() between rgb8_image_t and bgr8_image_t"<<std::endl;
    test_copy<rgb8_view_t,bgr8_view_t>(num_trials);
    std::cout<<std::endl;

    std::cout<<"test copy_pixels() between rgb8_planar_image_t and rgb8_planar_image_t"<<std::endl;
    test_copy<rgb8_planar_view_t,rgb8_planar_view_t>(num_trials);
    std::cout<<std::endl;

    std::cout<<"test copy_pixels() between rgb8_image_t and rgb8_planar_image_t"<<std::endl;
    test_copy<rgb8_view_t,rgb8_planar_view_t>(num_trials);
    std::cout<<std::endl;

    std::cout<<"test copy_pixels() between rgb8_planar_image_t and rgb8_image_t"<<std::endl;
    test_copy<rgb8_planar_view_t,rgb8_view_t>(num_trials);
    std::cout<<std::endl;

    // transform()
    std::cout<<"test transform_pixels() between rgb8_image_t and rgb8_image_t"<<std::endl;
    test_transform<rgb8_view_t,rgb8_view_t,bgr_to_rgb_t<bits8,pixel<bits8,rgb_layout_t> > >(num_trials);
    std::cout<<std::endl;

    std::cout<<"test transform_pixels() between rgb8_planar_image_t and rgb8_planar_image_t"<<std::endl;
    test_transform<rgb8_planar_view_t,rgb8_planar_view_t,bgr_to_rgb_t<bits8,planar_pixel_reference<bits8,rgb_t> > >(num_trials);
    std::cout<<std::endl;

    std::cout<<"test transform_pixels() between rgb8_image_t and rgb8_planar_image_t"<<std::endl;
    test_transform<rgb8_view_t,rgb8_planar_view_t,bgr_to_rgb_t<bits8,pixel<bits8,rgb_layout_t> > >(num_trials);
    std::cout<<std::endl;

    std::cout<<"test transform_pixels() between rgb8_planar_image_t and rgb8_image_t"<<std::endl;
    test_transform<rgb8_planar_view_t,rgb8_view_t,bgr_to_rgb_t<bits8,planar_pixel_reference<bits8,rgb_t> > >(num_trials);
    std::cout<<std::endl;

    return 0;
}