`

基于perf的C++中的inline与函数对象性能差异分析

阅读更多

 

 

相关命令和工具

(1)nm a.out|grep compare

(2)g++ -O2 -Winline main.cpp

Winline对含有inline关键字的而没有进行inline进行警告

(3)perf

 

  • 统计基准程序:

(1)通过随机生成16M个整数,进行排序,统计排序所需要要的时间,

(2)基于Linux平台,GCC,参数选项O2级优化

g++ -O2 main.cpp

程序如下:

#include <stdlib.h>
#include <vector>
#include <sys/stat.h>
#include <sys/timeb.h>
inline bool compare(int a, int b)
{
    return a < b;
}

struct Functor {
    bool operator()(int a, int b) const {
        return a < b;
    }
};
int main(int argc,char*argv[])
{
    std::vector<int> vec1;
    std::vector<int> vec2;
    size_t count = 16*1024*1024;
    vec1.reserve(count);
    vec2.reserve(count);
    srand(0XDeadBeaf);


    long long t1=0;
    long long t2=0;
    //for(int j=0;j<16;j++)
    {
        vec1.clear();
        vec2.clear();
        for(size_t i=0;i<count;i++)
        {
            int rd = rand();
            vec1.push_back(rd);
            vec2.push_back(rd);
        }
        clock_t t2_start=clock();
        std::sort(vec2.begin(), vec2.end(), Functor());
        clock_t t2_end = clock();

        clock_t t1_start=clock();
        std::sort(vec1.begin(), vec1.end(), compare);
        clock_t t1_end=clock();
        t1 += t1_end-t1_start;
        t2 += t2_end-t2_start;
    }
    printf("1 cost:%d\n2 cost:%d\n",(t1)/(CLOCKS_PER_SEC/1000),(t2)/(CLOCKS_PER_SEC/1000));
    getchar();
    return 0;
}

 

 

  • 统计结果

1 cost:4090

2 cost:3030

 

1为使用内联函数方式,2为Functor方式

 

  • 基于perf程序性能分析

统计使用方式如下:

(1)统计性能到文件中(其余参数,man perf,这里都忽略)

$>perf record ./a.out

(2)显示分析报告

$>perf report

 

基于该统计结果进行分析如下:

 

  • 使用函数compare方式
   0.65 :          401209:       callq  *%rbx                                                                                                                             a
    4.03 :          40120b:       test   %al,%al                                                                                                                           a
    0.00 :          40120d:       lea    0x4(%r12),%rdx                                                                                                                    a
    0.00 :          401212:       jne    401200 <void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, bool (*)(int`
    7.04 :          401214:       mov    0x8(%rsp),%r15                                                                                                                    a
    7.36 :          401219:       sub    $0x4,%r15                                                                                                                         a
    0.71 :          40121d:       nopl   (%rax)                                                                                                                            a
    9.30 :          401220:       mov    %r15,0x8(%rsp)                                                                                                                    a
   14.59 :          401225:       mov    (%r15),%esi                                                                                                                       a
    3.03 :          401228:       sub    $0x4,%r15                                                                                                                         a
    0.00 :          40122c:       mov    0x4(%rsp),%edi                                                                                                                    a
    1.97 :          401230:       callq  *%rbx                                                                                                                             a
    5.10 :          401232:       test   %al,%al                                                                                                                           a
    0.00 :          401234:       jne    401220 <void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, bool (*)(inta
    7.88 :          401236:       cmp    0x8(%rsp),%r12                                                                                                                    a
    0.00 :          40123b:       jae    401255 <void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, bool (*)(inta
    9.52 :          40123d:       mov    0x8(%rsp),%rcx   

 

  • Functor方式
   11.71 :          400e50:       add    $0x4,%r13                                                                                                                         a
    4.69 :          400e54:       mov    0x0(%r13),%edx                                                                                                                    a
    8.13 :          400e58:       cmp    %edx,%edi                                                                                                                         a
    0.00 :          400e5a:       jg     400e50 <void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, Functor>(__ga
    9.77 :          400e5c:       cmp    %ecx,%edi                                                                                                                         a
    5.07 :          400e5e:       lea    -0x4(%rax),%r8                                                                                                                    `
    0.92 :          400e62:       jge    400e7d <void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, Functor>(__ga
    4.31 :          400e64:       sub    $0x8,%rax                                                                                                                         a
    1.95 :          400e68:       nopl   0x0(%rax,%rax,1)                                                                                                                  a
    9.50 :          400e70:       mov    (%rax),%ecx                                                                                                                       a
   10.15 :          400e72:       mov    %rax,%r8                                                                                                                          a
    0.04 :          400e75:       sub    $0x4,%rax                                                                                                                         a
    0.08 :          400e79:       cmp    %ecx,%edi                                                                                                                         a
    0.00 :          400e7b:       jl     400e70 <void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, Functor>(__ga
   11.06 :          400e7d:       cmp    %r13,%r8                                                                                                                          a
    5.04 :          400e80:       jbe    400e9e <void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, Functor>(__ga
    4.01 :          400e82:       mov    %ecx,0x0(%r13)                                                                                                                    a
    6.98 :          400e86:       add    $0x4,%r13                                                                                                                         a
    0.04 :          400e8a:       mov    %edx,(%r8)                                                                                                                        a
    3.01 :          400e8d:       mov    -0x4(%r8),%ecx                                                                                                                    a
    0.57 :          400e91:       mov    0x0(%r13),%edx 

 

 

  • 总耗时概览
 41.09%  a.out  a.out              [.] void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, bool (*)(int, int)>(__`
 34.57%  a.out  a.out              [.] void std::__introsort_loop<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, long, Functor>(__gnu_cxx::__a
 12.15%  a.out  a.out              [.] main                                                                                                                                a
  7.64%  a.out  a.out              [.] compare(int, int)  

 

对比1,2,红色部分;可以看出,在std:sort中,compare并不能被内联,虽然已经声明为内联。

callq %rbx即为调用compare函数,因此,造成了性能影响。

 

  • 结论:

(1)Functor函数对象比内联函数,在std::sort这种复杂的函数中(存在递归,循环),效率更高。

(2)内联,由编译器决定,通常不影响性能

 

 

 

 

 

分享到:
评论

相关推荐

    性能验证工具,可以查看到每个子函数的时间消耗情况

    标题中的“性能验证工具”指的是一个能够帮助开发者分析和优化程序性能的软件工具。这种工具通常可以提供详细的报告,展示程序中各个子函数的运行时间,以便于定位性能瓶颈。在给定的描述中,我们可以推测这个工具是...

    Linux高级系统级性能分析工具perf

    Linux系统中的perf是一款强大的性能分析工具,专为深入了解操作系统及应用程序的性能瓶颈而设计。它提供了丰富的命令行接口,能够帮助开发者和系统管理员对CPU周期消耗、指令执行、内存访问等进行深入剖析,从而优化...

    google perftools性能分析工具说明

    Google Perftools 的主要功能是通过采样方式对程序中的 CPU 使用情况进行“画像”,从而对程序中各个函数的调用关系和耗时情况进行分析。这种方式可以帮助开发者快速地找到程序中最耗时的部分,从而对其进行优化,以...

    性能调优工具-perf介绍

    - `perf annotate`:进一步分析函数级别的性能,找出代码中的瓶颈。 通过perf,开发者可以有效地监控和优化应用程序及内核,提升整体系统性能。在进行性能调优时,结合硬件特性、软件设计以及perf提供的工具,可以...

    基于Linux Perf和ECharts的可视化系统噪声分析工具.pdf

    本工具基于Linux Perf和ECharts技术,旨在解决系统性能问题的排查和分析,提供了简单易用的使用方式和直观的数据展示方式,能够帮助用户快速了解系统性能情况,找出系统性能瓶颈,从而提高系统性能和可靠性。

    perf 性能测试工具

    Linux中的`perf`是一款强大的性能分析工具,专用于系统级的性能分析,它能够帮助开发者深入理解程序在操作系统层面上的执行情况。`perf`利用硬件事件(如CPU周期、缓存命中等)来收集数据,进而分析程序的性能瓶颈,...

    google-perftools 源码 (一款针对 C/C++ 程序的性能分析工具)

    google-perftools 是一款针对 C/C++ 程序的性能分析工具,它是一个遵守 BSD 协议的开源项目。使用该工具可以对 CPU 时间片、内存等系统资源的分配和使用进行分析,本文将重点介绍如何进行 CPU 时间片的剖析。 google...

    C++性能优化技术导论.pdf

    基于事件的分析方法可以在运行时检测特定的CPU事件,如缓存失效,以此来判断程序性能的瓶颈。另外,为了避免外界环境影响性能测试,测试环境应该保持一致性和稳定性,避免例如内存不足导致的页交换。 1.3 性能分析...

    perf火焰图生成与分析.pdf

    【perf火焰图生成与分析】 火焰图是一种可视化工具,用于分析程序性能瓶颈,尤其是在CPU和I/O方面。本文主要探讨如何使用perf工具生成和分析火焰图,以及不同类型的火焰图适用于哪种场景。 1. **火焰图简介** ...

    Linux perf user guide

    perf 的核心机理是基于硬件性能计数器(Hardware Performance Counters,HPC),它可以对 CPU 的性能进行监控和分析。perf 还可以从其他来源收集信息,如高精度定时器(hrtimers)、静态跟踪点(static tracepoints...

    Perf在Linux性能评估中的应用

    Perf是一个内置于Linux内核中的性能分析工具,它自Linux内核2.6.31版本起被集成到内核源码中。Perf可以用来评估Linux系统和程序的性能,它是对Linux系统进行性能调优的有力工具之一。Perf工具能够处理与性能相关的...

    如何在C++中实现代码性能报告生

    在C/C++开发中,性能分析是一个关键环节,它可以帮助开发者识别代码中的性能瓶颈,从而进行优化。生成代码性能报告是性能分析的重要步骤,以下是如何在C/C++中实现代码性能报告生成的详细指南。 通过使用gperftools...

    基于OpenWrt的性能检测工具unit_perf.zip

    目前工作是基于 OpenWrt 开发,经常要改善代码性能,但是OpenWrt又不支持perf。所以查找性能瓶颈时,就比较麻烦。于是利用业余时间写了个小工具,用于定位性能瓶颈的。编码,测试,加文档(README)大概花了3个小时...

    C++ json库性能对比

    总结来说,C++中的JSON库选择应该基于项目的具体需求,如性能、内存效率、易用性、兼容性和社区支持等因素。对于性能敏感的应用,如网络服务或大数据处理,像rapidjson这样的高性能库可能是首选;而对于那些对代码...

    使用Linux perf分析应用程序性能 - Jinyao 1

    perf 是 Linux 中的一个性能分析工具,能够对应用程序的性能进行详细的分析。perf 由 Linux 社区维护,Intel 也为其贡献了代码。perf 的主要特点是抽象硬件,支持软件事件,可以在多种架构上运行。 perf 的架构...

    linux/unix C++ 性能统计代码

    在C++中,性能统计可以利用各种系统调用和库,如`&lt;chrono&gt;`库进行时间测量,`&lt;unistd.h&gt;`头文件中的`getrusage`函数获取资源使用情况,或者更复杂的性能分析工具如gprof、perf等。此代码库可能是对这些底层机制的...

    cpp-nperf是一个类似于perf的Linux采样CPU分析器

    与gprof、valgrind等其他性能分析工具相比,cpp-nperf可能具有更低的开销和更高的精度,因为它基于硬件性能事件采样。这使得它在分析高并发或实时性要求高的应用时更具优势。 ### 五、cpp-nperf在开发过程中的应用 ...

    Linux perf 工具使用

    Linux perf工具是一款强大的性能分析工具,它主要用于诊断和分析Linux系统的性能问题,特别是在CPU、内存、I/O等关键领域。perf工具提供了丰富的事件类型,包括硬件事件和软件事件,允许用户深入到内核级别的性能...

    perf-tools.zip

    在Linux操作系统中,perf是强大的性能分析工具,它能够帮助我们深入理解系统的运行状况,定位性能瓶颈,从而优化程序的执行效率。perf-tools.zip压缩包包含了perf工具的源代码和相关资源,为开发者提供了详尽的性能...

    perf4j perf4j perf4j

    Perf4J是一款轻量级的Java性能度量和监控工具,主要设计用于提供应用程序的性能剖析和计时。这个工具允许开发者轻松地在代码中插入性能计时器,然后收集和报告这些计时器的数据,帮助优化和理解程序运行时的性能瓶颈...

Global site tag (gtag.js) - Google Analytics