c++ 如何用valgrind做好代码分析？

beq87vna  于 2024-01-09  发布在  其他
关注(0)|答案(2)|浏览(170)

我已经开始使用valgrind，特别是用于代码分析的工具“callgrind”。
为了开始，我创建了一个用于数值积分的共享库（我实现了一个抽象类接口和一些专门用于求积公式的派生类，例如Simpson，Trapezoidal，Midpoint）。在这一点上，我在应用程序中使用test库，我想使用callgrind来检测主要瓶颈并优化代码。
因此，我在调试模式下编译了可执行文件，并使用Kcachegrind分析了程序的行为。
我在主程序下面附上了：实质上，我创建了一个基类“NUMERICAL_INTEGRATION”，它是每个求积公式的模板，然后我测试了一些函数。

  1. #include <stdio.h>
  2. #include <iostream>
  3. #include <functional>
  5. #include "Quadrature.hpp"
  6. //#include <matplot/matplot.h>
  10. int main()
  11. {
  14.    /*--- MODULE FOR NUMERICAL INTEGRATION --TESTING------- */
  15.    using namespace Integrate_1D;
  16.    NUMERICAL_INTEGRATION<MidPointQuadrature> nIntegrationMID;
  17.    NUMERICAL_INTEGRATION<GaussLegeandreQuadrature> nIntegrationGL;
  18.    NUMERICAL_INTEGRATION<SimpsonQuadrature> nIntegrationSIMPS;
  19.    NUMERICAL_INTEGRATION<TrapzQuadrature> nIntegrationTRAPZ;
  21.    // Example : Integration of f(x) = x:
  23.    // All the formulas has to be exact for this function:
  24.    auto ToIntegrate0 = [](double x)
  25.    {
  26.      return x;
  27.    };
  29.    double xSTART = 0.0;
  30.    double xEND   = 2.0;
  31.    double EXACT_RES0 = 2.0;
  32.    unsigned int N0;
  33.    std::vector<double> degrees0;
  34.    std::vector<std::vector<double>> errors0_(3,std::vector<double>(4));
  36.    std::cout <<"********************************************\n";
  37.    std::cout<< "  TESTING FOR f(x) =x                       \n";
  38.    std::cout<< "********************************************\n";
  40.    N0=2;
  41.    double MID_RES0 = nIntegrationMID(ToIntegrate0,xSTART,xEND,N0);
  42.    double TRPZ_RES0 = nIntegrationTRAPZ(ToIntegrate0,xSTART,xEND,N0);
  43.    double SIMPS_RES0 = nIntegrationSIMPS(ToIntegrate0,xSTART,xEND,N0);
  44.    double GL_RES0 = nIntegrationGL(ToIntegrate0,xSTART,xEND,N0);
  45.    
  46.    std::cout << "********** TEST WITH N="<<N0<<"**************\n";
  47.    std::cout << "EXACT-RESULT of the integration: "<<EXACT_RES0 <<"\n";
  48.    std::cout << "Mid-point-result : "   <<   MID_RES0 << "\n";
  49.    std::cout << "Trapezoidal-result : " << TRPZ_RES0 << "\n";
  50.    std::cout << "Simpson-result : " <<     SIMPS_RES0 << "\n";
  51.    std::cout << "Gauss-Legendre-result : "<< GL_RES0 << "\n";
  53.    errors0_[0][0] = abs(MID_RES0-EXACT_RES0);
  54.    errors0_[0][1]= abs(TRPZ_RES0-EXACT_RES0);
  55.    errors0_[0][2] = abs(SIMPS_RES0-EXACT_RES0);
  56.    errors0_[0][3] = abs(GL_RES0-EXACT_RES0);
  58.    std::cout << "***************************************\n";
  60.    N0=4;
  61.    MID_RES0 = nIntegrationMID(ToIntegrate0,xSTART,xEND,N0);
  62.    TRPZ_RES0 = nIntegrationTRAPZ(ToIntegrate0,xSTART,xEND,N0);
  63.    SIMPS_RES0 = nIntegrationSIMPS(ToIntegrate0,xSTART,xEND,N0);
  64.    GL_RES0 = nIntegrationGL(ToIntegrate0,xSTART,xEND,N0);
  65.    
  66.    std::cout << "********** TEST WITH N="<<N0<<"**************\n";
  67.    std::cout << "EXACT-RESULT of the integration: "<<EXACT_RES0 <<"\n";
  68.    std::cout << "Mid-point-result : "   <<   MID_RES0 << "\n";
  69.    std::cout << "Trapezoidal-result : " << TRPZ_RES0 << "\n";
  70.    std::cout << "Simpson-result : " <<     SIMPS_RES0 << "\n";
  71.    std::cout << "Gauss-Legendre-result : "<< GL_RES0 << "\n";
  73.    // Fill the error vector:
  74.    errors0_[1][0] = abs(MID_RES0-EXACT_RES0);
  75.    errors0_[1][1] = abs(TRPZ_RES0-EXACT_RES0);
  76.    errors0_[1][2] = abs(SIMPS_RES0-EXACT_RES0);
  77.    errors0_[1][3] = abs(GL_RES0-EXACT_RES0);
  78.    std::cout << "***************************************\n";
  80.    N0=8;
  81.    MID_RES0 = nIntegrationMID(ToIntegrate0,xSTART,xEND,N0);
  82.    TRPZ_RES0 = nIntegrationTRAPZ(ToIntegrate0,xSTART,xEND,N0);
  83.    SIMPS_RES0 = nIntegrationSIMPS(ToIntegrate0,xSTART,xEND,N0);
  84.    GL_RES0 = nIntegrationGL(ToIntegrate0,xSTART,xEND,N0);
  85.    
  86.    std::cout << "********** TEST WITH N="<<N0<<"**************\n";
  87.    std::cout << "EXACT-RESULT of the integration: "<<EXACT_RES0 <<"\n";
  88.    std::cout << "Mid-point-result : "   <<   MID_RES0 << "\n";
  89.    std::cout << "Trapezoidal-result : " << TRPZ_RES0 << "\n";
  90.    std::cout << "Simpson-result : " <<     SIMPS_RES0 << "\n";
  91.    std::cout << "Gauss-Legendre-result : "<< GL_RES0 << "\n";
  93.    std::cout << "ERROR FOR N=8 : f(x)=x" <<std::endl;
  94.    std::cout << "trapz: " << TRPZ_RES0-EXACT_RES0<<std::endl;
  95.    std::cout << "midpoint: " << MID_RES0-EXACT_RES0<<std::endl;
  96.    std::cout << "simpson: " << SIMPS_RES0-EXACT_RES0<<std::endl;
  97.    std::cout << "GaussLegendre: " << GL_RES0-EXACT_RES0<<std::endl;
  98.    std::cout << "******************************************\n";
  99.    std::cout << "******************************************\n";
  100.    std::cout << "*******END TEST FOR f(x) = x *********\n\n\n\n";
  101.    
  102.    // Example : Integration of f(x) = sin(x):
  103.    auto ToIntegrate = [](double x)
  104.    {
  105.      return sin(x);
  106.    };
  107.   
  108.    xSTART = 0.0;
  109.    xEND   = M_PI;
  110.    unsigned int N;
  111.    std::vector<double> degrees;
  112.    std::vector<std::vector<double>> errors_(4,std::vector<double>(4));
  113.    std::vector<double> currErrors(4);
  114.    
  115.    double EXACT_RES = 2.0;
  116.    std::cout <<"********************************************\n";
  117.    std::cout<< "  TESTING FOR f(x) = sin(x)                 \n";
  118.    std::cout<< "********************************************\n";
  120.    N=2;
  121.    degrees.push_back(double(N));
  122.    double MID_RES = nIntegrationMID(ToIntegrate,xSTART,xEND,N);
  123.    double TRPZ_RES = nIntegrationTRAPZ(ToIntegrate,xSTART,xEND,N);
  124.    double SIMPS_RES = nIntegrationSIMPS(ToIntegrate,xSTART,xEND,N);
  125.    double GL_RES = nIntegrationGL(ToIntegrate,xSTART,xEND,N);
  126.    std::cout << "********** TEST WITH N="<<N<<"**************\n";
  127.    std::cout << "EXACT-RESULT of the integration: "<<EXACT_RES <<"\n";
  128.    std::cout << "Mid-point-result : "   <<   MID_RES << "\n";
  129.    std::cout << "Trapezoidal-result : " << TRPZ_RES << "\n";
  130.    std::cout << "Simpson-result : " <<     SIMPS_RES << "\n";
  131.    std::cout << "Gauss-Legendre-result : "<< GL_RES << "\n";
  133.    errors_[0][0] = abs(MID_RES-EXACT_RES);
  134.    errors_[0][1]= abs(TRPZ_RES-EXACT_RES);
  135.    errors_[0][2] = abs(SIMPS_RES-EXACT_RES);
  136.    errors_[0][3] = abs(GL_RES-EXACT_RES);
  137.    std::cout << "***************************************\n";
  138.    
  139.    N=4;
  140.    degrees.push_back(double(N));
  141.    MID_RES = nIntegrationMID(ToIntegrate,xSTART,xEND,N);
  142.    TRPZ_RES = nIntegrationTRAPZ(ToIntegrate,xSTART,xEND,N);
  143.    SIMPS_RES = nIntegrationSIMPS(ToIntegrate,xSTART,xEND,N);
  144.    GL_RES = nIntegrationGL(ToIntegrate,xSTART,xEND,N); 
  145.    std::cout << "********** TEST WITH N="<<N<<"**************\n";
  146.    std::cout << "EXACT-RESULT of the integration: "<<EXACT_RES <<"\n";
  147.    std::cout << "Mid-point-result : "   <<   MID_RES << "\n";
  148.    std::cout << "Trapezoidal-result : " << TRPZ_RES << "\n";
  149.    std::cout << "Simpson-result : " <<     SIMPS_RES << "\n";
  150.    std::cout << "Gauss-Legendre-result : "<< GL_RES << "\n";
  152.    // Fill the error vector:
  153.    errors_[1][0] = abs(MID_RES-EXACT_RES);
  154.    errors_[1][1] = abs(TRPZ_RES-EXACT_RES);
  155.    errors_[1][2] = abs(SIMPS_RES-EXACT_RES);
  156.    errors_[1][3] = abs(GL_RES-EXACT_RES);
  157.    std::cout << "***************************************\n";
  158.    
  159.    N=5;
  160.    degrees.push_back(double(N));
  161.  
  162.    MID_RES = nIntegrationMID(ToIntegrate,xSTART,xEND,N);
  163.    TRPZ_RES = nIntegrationTRAPZ(ToIntegrate,xSTART,xEND,N);
  164.    SIMPS_RES = nIntegrationSIMPS(ToIntegrate,xSTART,xEND,N);
  165.    GL_RES = nIntegrationGL(ToIntegrate,xSTART,xEND,N);
  166.   
  167.   
  168.    std::cout << "********** TEST WITH N="<<N<<"**************\n";
  169.    std::cout << "EXACT-RESULT of the integration: "<<EXACT_RES <<"\n";
  170.    std::cout << "Mid-point-result : "   <<   MID_RES << "\n";
  171.    std::cout << "Trapezoidal-result : " << TRPZ_RES << "\n";
  172.    std::cout << "Simpson-result : " <<     SIMPS_RES << "\n";
  173.    std::cout << "Gauss-Legendre-result : "<< GL_RES << "\n";
  174.    
  175.    // Fill the error vector:
  176.    errors_[2][0] = abs(MID_RES-EXACT_RES);
  177.    errors_[2][1] = abs(TRPZ_RES-EXACT_RES);
  178.    errors_[2][2] = abs(SIMPS_RES-EXACT_RES);
  179.    errors_[2][3] = abs(GL_RES-EXACT_RES);
  180.    std::cout << "***************************************\n";
  181.    N=8;
  182.    degrees.push_back(double(N));
  183.  
  184.    MID_RES = nIntegrationMID(ToIntegrate,xSTART,xEND,N);
  185.    TRPZ_RES = nIntegrationTRAPZ(ToIntegrate,xSTART,xEND,N);
  186.    SIMPS_RES = nIntegrationSIMPS(ToIntegrate,xSTART,xEND,N);
  187.    GL_RES = nIntegrationGL(ToIntegrate,xSTART,xEND,N);
  188.   
  189.   
  190.    std::cout << "********** TEST WITH N="<<N<<"**************\n";
  191.    std::cout << "EXACT-RESULT of the integration: "<<EXACT_RES <<"\n";
  192.    std::cout << "Mid-point-result : "   <<   MID_RES << "\n";
  193.    std::cout << "Trapezoidal-result : " << TRPZ_RES << "\n";
  194.    std::cout << "Simpson-result : " <<     SIMPS_RES << "\n";
  195.    std::cout << "Gauss-Legendre-result : "<< GL_RES << "\n";
  196.    
  197.    // Fill the error vector:
  198.    errors_[3][0] = abs(MID_RES-EXACT_RES);
  199.    errors_[3][1] = abs(TRPZ_RES-EXACT_RES);
  200.    errors_[3][2] = abs(SIMPS_RES-EXACT_RES);
  201.    errors_[3][3] = abs(GL_RES-EXACT_RES);
  202.    std::cout << "***************************************\n";
  203.    
  204.    std::vector<double> mid_error = {errors_[0][0],errors_[1][0],errors_[2][0],errors_[3][0]};
  205.    std::vector<double> trz_error = {errors_[0][1],errors_[1][1],errors_[2][1],errors_[3][1]};
  206.    std::vector<double> simps_error = {errors_[0][2],errors_[1][2],errors_[2][2],errors_[3][2]};
  207.    std::vector<double> gl_error = {errors_[0][3],errors_[1][3],errors_[2][3],errors_[3][3]};

字符串
现在，问题是，当我尝试使用valgrind。
附件中你可以找到一个屏幕截图，显示了该程序（kcachegrind）的主要用途。
首先，我不明白什么是_dl_start，为什么它需要相对总成本的82%。有人能给予我一些解释吗？
第二个问题是：代码分析和优化代码的最佳实践是什么？特别是，有一些指导方针可以检测主要瓶颈并使代码更快？
抱歉，如果我太笼统，但我是新来的，我不知道的东西在具体的。
谢谢大家的回答。
valgrind: kcachegrind

c++

2条答案

按热度按时间
qyzbxkaa

qyzbxkaa1#

_dl_start是“动态库”代码，用于加载共享库并执行符号的运行时链接。如果你在这些例程上花费了超过80%的时间，那么你的测试程序肯定只是在做一些微不足道的事情。你需要做一个更大的测试，这样callgrind就有更多的东西要测量。
或者，你需要使用客户端请求机制。你可以使用这个机制，callgrind不会检测任何东西，直到你告诉它，这将是你想要分析的函数。如果你有一个小的测试用例，这将允许你从谷壳中挑选小麦。

赞(0）分享  回复(0）举报  2024-01-09
hwamh0ep

hwamh0ep2#

Valgrind是一个强大的工具，用于检测C和C++程序中的内存泄漏，内存损坏和其他内存相关问题。要使用Valgrind执行良好的代码分析，请按照以下步骤操作：

1.安装Valgrind：

确保Valgrind已安装在您的系统上。您可以使用特定于您的操作系统的软件包管理器安装它。例如，在基于Debian的系统上：
sudo apt-get install valgrind

2.使用编译符号编译代码：

确保您的代码使用调试符号（-g标志）进行编译，以从Valgrind获得更准确和信息丰富的结果。
gcc -g -o your_program your_source_code.c

3.内存泄漏检测：

使用Valgrind运行你的程序来检测内存泄漏。Valgrind的memcheck工具通常用于此目的。
valgrind --leak-check=full ./your_program
--leak-check=full：提供有关内存泄漏的详细信息。检查Valgrind输出是否有任何报告的内存泄漏。它将提供有关内存分配位置和丢失位置的信息。

4.地址和内存错误：

Valgrind的memcheck工具还有助于检测内存损坏和其他与内存相关的错误。
valgrind --tool=memcheck --track-origins=yes ./your_program
--tool=memcheck：使用memcheck工具。--track-origins=yes：尝试显示未初始化值的来源。检查Valgrind输出中的任何报告错误，并在代码中解决它们。

5.分析调用：

Valgrind的callgrind工具可以用于代码分析，以识别热点和测量函数调用频率。
valgrind --tool=callgrind ./your_program
这将生成一个callgrind.out文件。
kcachegrind callgrind. out. *
kcachegrind callgrind. out. *

温馨提示：

**抑制文件：**您可能会在第三方库中遇到误报或不相关的问题。请创建抑制文件以从Valgrind输出中排除特定问题。
**Valgrind选项：**Valgrind提供各种自定义选项。根据您的需求查看文档以获取其他选项。
**迭代过程：**一次解决一个问题，重新运行Valgrind以确保您取得进展。

通过遵循这些步骤，您可以有效地使用Valgrind分析您的C或C++代码，识别与内存相关的问题，并提高软件的整体质量。

展开查看全部
赞(0）分享  回复(0）举报  2024-01-09
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com