Engine Profiling

Development < Engine Profiling

Engine Profiling

Linux

Intro

There are several ways to profile an application.

gprof

The compiler injects special code in the binary that self profiles it when it runs. this is what cmake -DCMAKE_BUILD_TYPE=PROFILING is here for. We are not going to use this. It does not interfere with normal program's work-flow. With spring, it gets so slow that it is unusable for profiling anything in late game (which is where it is needed the most). It requires special compiling options.

oprof

OProfile uses statistical sampling. It is a kernel module, which every n clock ticks, registers which function is currently being processed. It is lightweight; it may run with almost 0 performance impact. This method always profiles your profiles your whole system; relevant info has to be filtered out after the profiling run has finished. The downside of statistical profiling, is that it requires at least a certain sample size to achieve good accuracy. Also remember, that oprof still requires the debug symbols, to resolve addresses into function names. It can be turned on/off at any time, so for instance, you may skip spring loading so you would only profile in-game runtime. You can also merge multiple profiling sessions.

Setting up oprof

Required stuff:

• oprof kernel module
• oprof package

Using oprof

Note: Modern CPUs have special statistical sampling timing functions to make profiling with software like oprof fast.

You will have to load the kernel module. The profiling daemon is controlled using opcontrol as root. As regular user, you can do post-processing using opreport.

Recommended settings

Use a call-graph depth of 16, disable kernel profiling and enable user-space profiling, separate each thread and application in its own profile. You can always merge them later, using opreport.

A typical profiling session

# We need to be root
su -

# In case the kernel module is not already loaded ...
insmod oprofile

# This has to be sent only once; it will be saved
opcontrol --event=CPU_CLK_UNHALTED:1000000:0x0:0:1 \
          --callgraph=16 \
          --separate=thread,library \
          --no-vmlinux

# -- Bring spring into a state where you want to start profiling --

# start the profiler
opcontrol --start

# -- In spring, do whatever you want to profile --

# stop the profiler
opcontrol --stop

# in order to make the profile data available to user-space,
# you have to dump the data
opcontrol --dump

Post processing oprof data

oprofile indexes stuff by thread id and process id since the setting i've made you use did tell it to do so :p so in order to generate a report, you'll have to tell which program, which threads to include, and which sampling sessions if you do not care much, you can just merge thread data and sampling data

BIN_PATH=~/Projects/spring/installs/cmake/master/linux64/debug/spring
DATA_FILE_PATH=./springProfilingData.oprof
GRAPH_FILE_PATH=./springProfilingGraph.dot

# Caution: this will take a long time!
#          ~ 2h for a spring in-game time of 10min
opreport -cfg --demangle=smart --merge=tid,tgid -i=${BIN_PATH} -o=${DATA_FILE_PATH}

-c tells it to plot a full callgraph table, which can be parsed by other tools if instead you want a flat txt table, omit it to generate the dot graph out of the -c version

gprof2dot --format=oprofile -o=${GRAPH_FILE_PATH} ${DATA_FILE_PATH}

Then you can either use xdot to view it, or use dot to generate a png or svg pic

gprof2dot takes oprof data and outputs a nice dot-graph. Then you can use either graphviz to render to an image, or display the graph directly, for example with xdot. The will look about like this:

you might need help to output the oprof data in a way that gprof2dot can digest, tell me when you reach there

Windows

<Please add>