This page describes two different ways how you can analyze and profile your code in polymake.

Using the tool valgrind is an easy way to get many pieces of information about your code. Once valgrind is installed on your system you are able to use many analyzing tools, as callgrind and cachegrind. You will find more details in the manual.

You can run polymake and your code with valgrind via the command

valgrind --tool=callgrind perl/polymake

or your corresponding path to polymake.

polymake will start and you can execute your code, while valgrind is collecting data. But be aware that this will slow down your program, such that you should just test your code with very small examples.

A typical shell output looks like this:

==30738== Callgrind, a call-graph generating cache profiler
==30738== Copyright (C) 2002-2009, and GNU GPL'd, by Josef Weidendorfer et al.
==30738== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info
==30738== Command: perl/polymake

==30738==
==30738== For interactive control, run 'callgrind_control -h'.
Welcome to polymake version 2.12.3, rev. 11104 [DEVELOPER MODE]
Copyright (c) 1997-2012
Ewgenij Gawrilow, Michael Joswig (TU Darmstadt)
http://www.polymake.org

This is free software licensed under GPL; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Press F1 or enter 'help;' for basic instructions.

Application polytope currently uses following third-party software packages:
cddlib, geomview, graphviz, jreality, lrslib, nauty, normaliz2, permlib, povray, qhull, sketch, sympol, tosimplex
For more details:  show_credits;
polytope > script("my_script.pl");
polytope > exit;
==30738==
==30738== Events    : Ir
==30738== Collected : 2091660153168
==30738==
==30738== I   refs:      2,091,660,153,168

After closing polymake you will find files called callgrind.out.*, where * is a session number. The file stores all information about the run, in the above example callgrind.out.30738. You can open the file using kcachegrind.

Picture1

In our example you can see from this file, that mostly called is the interior function _gmpz_mul, as subroutine of dd_LPSolve_gmp. This gives the hint that many Linear Programs will be solved that nearly all time is needed for that.

Another useful tool is cachegrind. You can run your code similar to the above via the command

valgrind --tool=cachegrind perl/polymake

you will produce a file called cachegrind.out.* and also the shell output is similar. The data you will get tells you about the cach misses in your Program.

A weak point of this methode is that also other information than your code is analyzed, as recompiling and the files which where execute by the start of polymake. You can start your code as Callable Library to reduces this.

Another way is using gprof. To run this we start our code as Callable Library and have to install polymake again, this time compiling under the flags '-g', '-pg' and '-O2'.

You can change compiler flags in the file '/build.x86_64/conf.make'. It should look like this (with your corresponding paths):

...
Cflags := -march=native -g -pg -Wall -I/.../mpfr/include
CXXflags := -march=native -g -pg -ftemplate-depth-200 -Wall -Wno-strict-aliasing -Wno-parentheses -fno-inline-functions-called-once -I/.../mpfr/include
...
CXXOPT := -O2
...
LDflags :=  -g -pg -L/.../mpfr/lib -Wl,-rpath,/.../mpfr/lib
LDsharedFlags := -shared -O2 -g -pg -L/usr/local/lib -fstack-protector
LDcallableFlags := -shared -O2 -g -pg -L/usr/local/lib -fstack-protector  -fstack-protector -L/usr/local/lib
...

For this version of polymake we execute our code as Callable Library also compiled under the flags '-g' and '-pg'. Therefore you can use the makefile from the example. We execute our c++ program 'test' via the command

./test

This takes a while and produces the file 'gmon.out' which stores all profling data and can convert to a readable file via the command

gprof [executable file] [> Outfile]