Go back to Richel Bilderbeek's homepage.

Go back to Richel Bilderbeek's C++ page.

 

 

 

 

 

(C++) Qt Creator gprof example 2: profiling a simple console application in Qt Creator, using Qt project file

 

This example shows how to use gprof under Qt Creator to profile a simple console application.

 

 

To be able to use gprof to profile a project, add the following lines to a Qt project file:

 

QMAKE_CXXFLAGS_DEBUG += -pg
QMAKE_LFLAGS_DEBUG += -pg

 

then, for a terminal, type the following lines:

 

qmake -config debug
make clean
make
./CppGprofQtCreatorExample2
gprof CppGprofQtCreatorExample2 > gprof.txt

 

Or easier, run the script profile.sh:

 

./profile.sh

 

 

 

 

 

Technical facts

 

Application type(s)

Operating system(s) or programming environment(s)

IDE(s):

Project type:

C++ standard:

Compiler(s):

Libraries used:

 

 

 

 

 

Qt project file: CppGprofQtCreatorExample2.pro

 

#-------------------------------------------------
#
# Project created by QtCreator 2011-07-06T14:00:50
#
#-------------------------------------------------
QT       += core
QT       -= gui
QMAKE_CXXFLAGS_DEBUG += -pg
QMAKE_LFLAGS_DEBUG += -pg
TARGET = CppGprofQtCreatorExample2
CONFIG   += console
CONFIG   -= app_bundle
TEMPLATE = app
SOURCES += main.cpp

 

 

 

 

 

main.cpp

 

#include <algorithm>
#include <cassert>
#include <vector>
#include <boost/foreach.hpp>

//From http://www.richelbilderbeek.nl/CppBubbleSort.htm
template <class T>
void BubbleSort(std::vector<T>& v)
{
  const int size = v.size();
  for(int i=0; i!=size-1; ++i)
  {
    for(int j=0; j!=size-i-1; ++j)
    {
      if(v[j] > v[j+1])
      {
        std::swap(v[j],v[j+1]);
      }
    }
  }
}

//From http://www.richelbilderbeek.nl/CppInsertionSort.htm
template <typename T>
void InsertionSort(std::vector<T>& v)
{
  const int size = v.size();
  for(int i=1; i!=size; ++i)
  {
    for(int j=0; j!=i; ++j)
    {
      if (v[j]>v[i])
      {
        const int temp=v[j];
        v[j]=v[i];
        for(int k=i;k>j;--k) { v[k]=v[k-1]; }
        v[j+1]=temp;
      }
    }
  }
}

//From http://www.richelbilderbeek.nl/CppSelectionSort.htm
template <typename T>
void SelectionSort(std::vector<T>& v)
{
  const int size = v.size();
  for(int i=0; i!=size-1; ++i)
  {
    for(int j=i+1; j!=size; ++j)
    {
      if (v[i]> v[j])
      {
        std::swap(v[i],v[j]);
      }
    }
  }
}

//From http://www.richelbilderbeek.nl/CppSortVector.htm
template <class T>
void SortVector(std::vector<T>& v)
{
  std::sort(v.begin(), v.end());
}

const std::vector<int> CreateShuffledVector(const std::size_t sz)
{
  std::vector<int> v(sz);

  int value = 0;
  BOOST_FOREACH(int i,v)
  {
    i = value;
    ++value;
  }
  std::random_shuffle(v.begin(),v.end());
  return v;
}


int main()
{
  const std::vector<int> v = CreateShuffledVector(100000);

  std::vector<int> v1(v);
  std::vector<int> v2(v);
  std::vector<int> v3(v);
  std::vector<int> v4(v);

  BubbleSort(v1);
  InsertionSort(v2);
  SelectionSort(v3);
  SortVector(v4);

  assert(v1==v2);
  assert(v2==v3);
  assert(v3==v4);
}

 

 

 

 

 

profile.sh

 

#!/bin/sh
echo "Removing user file"
rm *.pro.user

echo "Creating profile executable"
qmake -config debug
make clean
make

echo "Removing makefile"
rm Makefile

echo "Removing object files"
rm *.o

echo "Start the application"
./CppGprofQtCreatorExample2

echo "Analyse the gprof results"
gprof CppGprofQtCreatorExample2 > gprof.txt

echo "Remove temporary gprof file"
rm gmon.out

 

 

 

 

 

Profiling results

 

Here I show the results comparing the five functions, copied from the results file:

 

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total          
time   seconds   seconds    calls   s/call   s/call  name    
12.51    172.28    29.52        1    29.52    77.11  void BubbleSort<int>(std::vector<int, std::allocator<int> >&)
12.39    201.51    29.23        1    29.23    76.82  void InsertionSort<int>(std::vector<int, std::allocator<int> >&)
12.06    229.97    28.45        1    28.45    76.04  void SelectionSort<int>(std::vector<int, std::allocator<int> >&)
  0.00    235.89     0.00        1     0.00     0.52  void SortVector<int>(std::vector<int, std::allocator<int> >&)
  0.00    235.89     0.00        1     0.00     0.09  CreateShuffledVector(unsigned int)

 

Conclusion: as expected, SortVector (a QuickSort) is by far the quickest sorting algorithm.

 

 

 

 

 

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

 

Valid XHTML 1.0 Strict