Question

我正在尝试学习使用gprof并且想要测试返回副本并返回指向新ed对象的指针的相同函数之间的速度差异。然后我发现gprof似乎并没有真正运行整个程序，因为它比单独运行程序花费的时间少，而且它也没有准确地显示应该调用某个函数的次数。

这是我的计划：

#include "heap.hpp"
#include <random>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <functional>

using namespace std;

int main()
{

    typedef SorterMAX<int> SRT;

    random_device rnd_device;
    mt19937 mersenne_engine(rnd_device());
    uniform_int_distribution<int> dist(0, 9999);

    auto gen = std::bind(dist, mersenne_engine);
    vector<int> vec(10000000);
    generate(begin(vec), end(vec), gen);

    SRT s;

    Heap<SRT> h(vec, s);

    while (! (h.size() == 0))
    {
    std::cout << h.size() << std::endl;
        h.top_with_copy();
    }
}

这是它使用的类：

#include<iostream>
#include<vector>

/// minheap sorter
template <class N>
class SorterMIN
{
public:
    typedef N NODE;
    bool operator()(const NODE& n1, const NODE& n2) const
    {
    return (n1 <= n2);
    }
};


/// maxheap sorter
template <class N>
class SorterMAX
{
public:
    typedef N NODE;
    bool operator()(const NODE& n1, const NODE& n2) const
    {
    return (n1 >= n2);
    }
};


template <class SORTER>
class Heap
{
public:
    typedef typename SORTER::NODE NODE;

    Heap(std::vector<NODE>& v, SORTER& s)
    : data(v), sorter(s)
    {
    for (auto node_itr = v.begin()+(v.size()/2); node_itr != v.begin()-1; node_itr--)
    {
        sift_down(node_itr - v.begin(), v, s);
    }
    data = v;
    _size = v.size();
    }

    NODE top_with_copy()
    {
        NODE top = *(data.begin());
    std::cout << "copy\n";
        data[0] = *(data.end()-1);
        data.pop_back();
        sift_down(0, data, sorter);
        _size--;
        return top;
    }

    // NODE* top_with_pointer()
    // {
    //  NODE* top = new NODE(1);
    //  std::cout << "pointer\n";
    //  top = &(*(data.begin()));
    //  data[0] = *(data.end()-1);
    //  data.pop_back();
    //  sift_down(0, data, sorter);
    //  _size--;
    //  return top;
    // }

    int size()
    {
    return _size;
    }

    void sift_down(int node_index, std::vector<NODE>& v, const SORTER& s)
    {
    int left_child_index= 2*node_index+1;
    int right_child_index = 2*node_index+2;
    int to_swap_index;
    if (right_child_index <= v.size()-1)
    {
        if (s(v[left_child_index], v[right_child_index]))
        {
        to_swap_index = left_child_index;
        }
        else
        {
        to_swap_index = right_child_index;
        }
    }
    else if (left_child_index <= v.size()-1)
    {
        to_swap_index = left_child_index;
    }
    else
    {
        return;
    }
    // if sorter returns false, then order is incorrect
    if (!s(v[node_index], v[to_swap_index]))
    {
        NODE tmp = v[node_index];
        v[node_index] = v[to_swap_index];
        v[to_swap_index] = tmp;
        sift_down(to_swap_index, v, s);
    }
    }

private:
    std::vector<NODE>& data;
    SORTER& sorter;
    int _size;
};

现在，我希望top()被称为10000000次。但在gprof输出中，它表示它被称为三次。

0.00      2.07     0.00        3     0.00     0.00  Heap<SorterMAX<int> >::top_with_copy()

我起诉的命令是这些：

g++ heap.hpp; g++ -pg heapteast.cpp; gprof a.out gmon.out > analysis_returncopy

程序的一些输出显示top()确实被称为超过三次：

9882766
copy
9882765
copy
9882764
copy
9882763
copy
9882762
copy
9882761
copy
9882760
copy
9882759
copy
9882758
copy
9882757
copy
9882756

这里发生了什么？如何让gprof运行整个程序并显示正确的数字？

gprof不运行整个程序并显示不正确的呼叫计数

0 个答案: