Other Tools

Last modified Thursday, 13-Nov-2025 16:43:17 UTC.

gprof

gprof produces an execution profile of programs compiled with the -pg option
After compiling the program with -pg, run it, and a file called either gmon.out or <program>.gmon is produced.
Run gprof on the <program> to get information the number of calls to, and the time spent, each of your functions and system functions called.
Useful gprof flags are:
- -b - suppresses the printing of the field descriptions
- -l - suppresses the printing of the call graph profile

Example: ProfileThis.c

prompt> gcc -Wall -pg ProfileThis.c -o ProfileThis
prompt> ProfileThis 41
LinearFibonacci(41)      = 9227465
QuadraticFibonacci(41)   = 9227465
ExponentialFibonacci(41) = 9227465
prompt> gprof -b ProfileThis
Flat profile:

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total
 time   seconds   seconds    calls  ms/call  ms/call  name
 94.89      0.82     0.82        1   816.09   816.09  ExponentialFibonacci
  3.51      0.85     0.03        1    30.23    30.23  QuadraticFibonacci
  2.34      0.87     0.02                             main
  0.00      0.87     0.00        1     0.00     0.00  LinearFibonacci


			Call graph


granularity: each sample hit covers 2 byte(s) for 1.15% of 0.87 seconds

index % time    self  children    called     name
                                                 
[1]    100.0    0.02    0.85                 main [1]
                0.82    0.00       1/1           ExponentialFibonacci [2]
                0.03    0.00       1/1           QuadraticFibonacci [3]
                0.00    0.00       1/1           LinearFibonacci [4]
-----------------------------------------------
                             331160280             ExponentialFibonacci [2]
                0.82    0.00       1/1           main [1]
[2]     94.2    0.82    0.00       1+331160280 ExponentialFibonacci [2]
                             331160280             ExponentialFibonacci [2]
-----------------------------------------------
                0.03    0.00       1/1           main [1]
[3]      3.5    0.03    0.00       1         QuadraticFibonacci [3]
-----------------------------------------------
                0.00    0.00       1/1           main [1]
[4]      0.0    0.00    0.00       1         LinearFibonacci [4]
-----------------------------------------------


Index by function name

   [2] ExponentialFibonacci    [3] QuadraticFibonacci
   [4] LinearFibonacci         [1] main

gdb
- GDB allows you to see what is going on inside a program while it executes
- GDB can do four main kinds of things to help you catch bugs in the act:
  - Start your program, specifying anything that might affect its behavior.
  - Make your program stop on specified conditions.
  - Examine what has happened, when your program has stopped.
  - Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.
- To use gdb compile the target program with the -g option.
- To run a program under gdb specify the program name as the argument to gdb
- Here are some of the most frequently needed GDB commands:
  - break [file:]function
    Set a breakpoint at function (in file).
  - run [arglist]
    Start your program (with arglist, if specified).
  - bt
    Backtrace: display the program stack.
  - print expr
    Display the value of an expression.
  - c
    Continue running your program (after stopping, e.g. at a breakpoint).
  - next
    Execute next program line (after stopping); step over any function calls in the line.
  - step
    Execute next program line (after stopping); step into any function calls in the line.
  - help [name]
    Show information about GDB command name, or general information about using GDB.
  - quit
    Exit from GDB.
- Example: ProfileThis.c
```
gdb ProfileThis
   ...
(gdb) break LinearFibonacci
Breakpoint 1 at 0x11a9: file ProfileThis.c, line 12.
(gdb) run 35
Starting program: /fs/bragg/home/graph/geoff/CSC322/MyCode.CTools/ProfileThis 35

Breakpoint 1, LinearFibonacci (Number=21845) at ProfileThis.c:12
12	long LinearFibonacci(int Number) {
(gdb) print Number
$1 = 21845
(gdb) step
14	    long Previous = 0;
(gdb) print Number
$2 = 35
(gdb) c
Continuing.
LinearFibonacci(35)      = 5702887
QuadraticFibonacci(35)   = 93824992254624
ExponentialFibonacci(35) = 5702887
[Inferior 1 (process 2320434) exited normally]
(gdb) quit
          
```

valgrind

The Valgrind tool suite provides a number of debugging and profiling tools.
The default valgrind tool is Memcheck. Memcheck detects memory-related errors that are common in C programs.
Compile your program with the -g and -O0 flags.
Run you program under valgrind with the --leak-check=yes option. Your program will run much slower than normal, and use a lot more memory.

Example: ProfileThis.c

gcc -g -O0 -Wall -o ProfileThis ProfileThis.c
valgrind --leak-check=yes ProfileThis 41

==7930== Memcheck, a memory error detector
==7930== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==7930== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==7930== Command: ProfileThis 41
==7930==
LinearFibonacci(41)      = 102334155
QuadraticFibonacci(41)   = 102334155
ExponentialFibonacci(41) = 102334155
==7930==
==7930== HEAP SUMMARY:
==7930==     in use at exit: 16 bytes in 1 blocks
==7930==   total heap usage: 41 allocs, 40 frees, 656 bytes allocated
==7930==
==7930== 16 bytes in 1 blocks are definitely lost in loss record 1 of 1
==7930==    at 0x4C29F73: malloc (vg_replace_malloc.c:309)
==7930==    by 0x4006F4: QuadraticFibonacci (ProfileThis.c:50)
==7930==    by 0x400805: main (ProfileThis.c:79)
==7930==
==7930== LEAK SUMMARY:
==7930==    definitely lost: 16 bytes in 1 blocks
==7930==    indirectly lost: 0 bytes in 0 blocks
==7930==      possibly lost: 0 bytes in 0 blocks
==7930==    still reachable: 0 bytes in 0 blocks
==7930==         suppressed: 0 bytes in 0 blocks
==7930==
==7930== For lists of detected and suppressed errors, rerun with: -s
==7930== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

valgrind does not run on Apple M chips. Use Apple's leaks program instead - (here is some documentation).

Other Tools

Exercises

Exam Style Questions