使用具有以下选项的Valgrind：

valgrind --tool=callgrind ./(Your binary)

这将生成一个名为callgrind.out.x的文件。使用kcachegrind工具读取该文件。它会给你一个图形化的分析结果，比如哪一行花费多少。

我会使用Valgrind和Callgrind作为我的仿形工具套件的基础。重要的是，Valgrind基本上是一台虚拟机：

（维基百科）Valgrind本质上是虚拟的机器使用准时制（JIT）编译技术，包括动态重新编译。没有来自的内容原始程序始终运行直接在主机处理器上。相反，Valgrind首先翻译将程序转换为临时的、更简单的形式称为中间表示（IR）是处理器中性的，转换后，工具（见下文）可以自由使用无论它想要什么样的转变在Valgrind翻译之前IR返回到机器代码中主机处理器运行它。

Callgrind是一个基于此的剖析器。主要的好处是，您不必运行应用程序数小时就能获得可靠的结果。因为Callgrind是一个非探测型剖面仪，所以即使一秒钟的运行也足以获得可靠的结果。

另一个基于Valgrind的工具是Massif。我使用它来分析堆内存使用情况。它工作得很好。它的作用是为您提供内存使用情况的快照--详细信息What hold What percentage of memory，and WHO has put it there。这些信息在应用程序运行的不同时间点可用。

您可以使用loguru这样的日志框架，因为它包括时间戳和总运行时间，可以很好地用于分析：

编译和链接代码并运行可执行文件时，请使用-pg标志。执行此程序时，分析数据收集在文件a.out中。有两种不同类型的分析

1-平面轮廓：通过运行命令gprog--flat profile a.out，可以获得以下数据-该功能所花费的总时间的百分比，-在包括和排除对子函数的调用的函数中花费了多少秒，-呼叫的数量，-每次通话的平均时间。

2-图形分析使用命令gprof--graph a.out获取每个函数的以下数据，其中包括-在每个部分中，一个函数都标有索引编号。-在函数上方，有一个调用该函数的函数列表。-在函数下面，有一个函数调用的函数列表。

要获取更多信息，请查看https://sourceware.org/binutils/docs-2.32/gprof/

这是对Nazgob Gprof回答的回应。

过去几天我一直在使用Gprof，已经发现了三个重要的限制，其中一个是我在其他地方还没有看到过的：

它不能在多线程代码上正常工作，除非您使用变通方法调用图被函数指针弄糊涂了。示例：我有一个名为multithread（）的函数，它使我能够在指定的数组上对指定的函数进行多线程处理（两者都作为参数传递）。然而，Gprof将所有对多线程（）的调用视为等效的，以计算在孩子身上花费的时间。由于我传递给多线程（）的一些函数花费的时间比其他函数长得多，所以我的调用图基本上是无用的。（对于那些想知道线程是否是这里的问题的人来说：不，多线程（）可以选择，在这种情况下，只在调用线程上按顺序运行所有内容）。这里说“……调用数数字是通过计数而不是采样得出的。它们是完全准确的……”。然而，我发现我的调用图给了我5345859132+784984078作为对我调用最多的函数的调用统计数据，其中第一个数字应该是直接调用，第二个递归调用（都来自它本身）。因为这意味着我有一个bug，所以我在代码中加入了长（64位）计数器，并再次运行相同的程序。我的计数：5345859132个直接调用和78094395406个自递归调用。这里有很多数字，所以我要指出，我测量的递归调用是780亿，而Gprof是7.84亿：相差100倍。两次运行都是单线程和未优化的代码，一次是编译的-g，另一次是-pg。

这是在64位Debian Lenny下运行的GNUGprof（Debian的GNUBinutils）2.18.0.20080103，如果这对任何人都有帮助的话。

如果您的目标是使用探查器，请使用建议的探查器之一。

然而，如果您很匆忙，并且可以在调试器下手动中断程序，而程序主观上很慢，那么有一种简单的方法可以找到性能问题。

只需暂停几次，每次都查看调用堆栈。如果有一些代码浪费了一定百分比的时间，20%或50%或更多，这就是您在每个示例的操作中捕获它的概率。所以，这大概是你将看到的样本的百分比。不需要经过教育的猜测。如果你确实猜到了问题所在，这将证明或反驳它。

您可能有多个不同大小的性能问题。如果你清除了其中的任何一个，剩下的将占更大的百分比，并且在随后的传球中更容易被发现。这种放大效应，当在多个问题上叠加时，会导致真正的大规模加速因素。

注意：除非程序员自己使用过，否则他们倾向于怀疑这种技术。他们会说，分析程序提供了这些信息，但只有当他们对整个调用堆栈进行采样，然后让您检查一组随机样本时，这才是正确的。（总结是失去洞察力的地方。）调用图不能提供相同的信息，因为

他们不在教学层面进行总结，而且在递归的情况下，它们给出了令人困惑的摘要。

他们也会说它只适用于玩具程序，而实际上它适用于任何程序，而且它似乎更适用于大型程序，因为他们往往会发现更多问题。他们会说，它有时会发现不存在问题的东西，但只有当你看到一次时，这才是真的。如果您在多个样本上看到问题，则这是真实的。

P.S.如果有一种方法可以在某个时间点收集线程池的调用堆栈样本，这也可以在多线程程序上完成，就像在Java中一样。

P.P.S一般来说，软件中的抽象层越多，就越有可能发现这是导致性能问题的原因（以及加速的机会）。

补充：这可能并不明显，但堆栈采样技术在递归的情况下也同样适用。原因是，删除指令所节省的时间与包含指令的样本分数近似，而与样本中可能出现的次数无关。

我经常听到的另一个反对意见是：“它会随机停在某个地方，它会错过真正的问题”。这源于对真正的问题是什么有一个预先的概念。性能问题的一个关键特性是它们不符合预期。抽样告诉你有问题，你的第一反应是怀疑。这很自然，但你可以确定，如果它发现了问题，它是真实的，反之亦然。

补充：让我对它的工作原理做一个贝叶斯解释。假设有一些指令I（调用或其他）在调用堆栈上占用了时间的一小部分f（因此花费了那么多）。为了简单起见，假设我们不知道f是什么，但假设它是0.1、0.2、0.3、…0.9、1.0，并且这些可能性的先验概率都是0.1，所以所有这些成本都是先验的。

然后假设我们只取2个堆栈样本，我们在两个样本上都看到指令I，指定为观察值o=2/2。这为我们提供了I的频率f的新估计，如下所示：

Prior                                    
P(f=x) x  P(o=2/2|f=x) P(o=2/2&&f=x)  P(o=2/2&&f >= x)  P(f >= x | o=2/2)

0.1    1     1             0.1          0.1            0.25974026
0.1    0.9   0.81          0.081        0.181          0.47012987
0.1    0.8   0.64          0.064        0.245          0.636363636
0.1    0.7   0.49          0.049        0.294          0.763636364
0.1    0.6   0.36          0.036        0.33           0.857142857
0.1    0.5   0.25          0.025        0.355          0.922077922
0.1    0.4   0.16          0.016        0.371          0.963636364
0.1    0.3   0.09          0.009        0.38           0.987012987
0.1    0.2   0.04          0.004        0.384          0.997402597
0.1    0.1   0.01          0.001        0.385          1

                  P(o=2/2) 0.385                

最后一列表示，例如，f>=0.5的概率为92%，高于先前假设的60%。

假设先前的假设不同。假设我们假设P（f=0.1）是.991（几乎确定），而所有其他可能性几乎都是不可能的（0.001）。换句话说，我们先前的确定是我很便宜。然后我们得到：

Prior                                    
P(f=x) x  P(o=2/2|f=x) P(o=2/2&& f=x)  P(o=2/2&&f >= x)  P(f >= x | o=2/2)

0.001  1    1              0.001        0.001          0.072727273
0.001  0.9  0.81           0.00081      0.00181        0.131636364
0.001  0.8  0.64           0.00064      0.00245        0.178181818
0.001  0.7  0.49           0.00049      0.00294        0.213818182
0.001  0.6  0.36           0.00036      0.0033         0.24
0.001  0.5  0.25           0.00025      0.00355        0.258181818
0.001  0.4  0.16           0.00016      0.00371        0.269818182
0.001  0.3  0.09           0.00009      0.0038         0.276363636
0.001  0.2  0.04           0.00004      0.00384        0.279272727
0.991  0.1  0.01           0.00991      0.01375        1

                  P(o=2/2) 0.01375                

现在它说P（f>=0.5）是26%，高于之前的假设0.6%。因此贝叶斯允许我们更新对I的可能成本的估计。如果数据量很小，它不能准确地告诉我们成本是多少，只是它足够大，值得修复。

另一种看待它的方式被称为继承规则。如果你把一枚硬币翻了两次，两次都是正面朝上，那么这能告诉你硬币的可能重量吗？令人尊敬的答案是，这是一个Beta分布，平均值（点击次数+1）/（尝试次数+2）=（2+1）/（2+2）=75%。

（关键是我们不止一次看到I。如果我们只看到一次，除了f>0之外，这并不能告诉我们什么。）

因此，即使是非常少量的样本也可以告诉我们它所看到的指令的成本。（它会看到它们的频率，平均来说，与它们的成本成正比。如果取n个样本，f是成本，那么我会出现在nf+/-sqrt（nf（1-f））样本上。例如，n=10，f=0.3，即3+/-1.4个样本。）

添加：为了直观地感受测量和随机堆栈采样之间的差异：现在有分析器可以对堆栈进行采样，即使是在墙上的时钟时间，但结果是测量结果（或热路径或热点，“瓶颈”很容易隐藏）。他们没有向你展示（而且很容易展示）的是实际样品本身。如果你的目标是找到瓶颈，那么你需要看到的瓶颈数量平均是2除以所需的时间。因此，如果花费30%的时间，平均来说，2/.3=6.7个样本将显示它，20个样本显示它的概率为99.2%。

以下是检查测量值和检查堆栈样本之间的差异的即兴说明。瓶颈可能是一个像这样的大斑点，也可能是无数个小斑点，这没有什么区别。

测量是水平的；它告诉你特定时间的例行程序需要多少时间。采样是垂直的。如果有任何方法可以避免整个程序在那一刻所做的事情，并且如果您在第二个示例中看到了这一点，那么您就发现了瓶颈。这就是造成差异的原因——看到花费时间的全部原因，而不仅仅是花费多少。