Philippe Waroquiers

This talk describes how performance aspects of a big Air Traffic Flow Management mission critical application are tracked from development to operations.

Tracking performance is needed when new functionality is added, to balance the additional services versus the resource increase needed. Measuring and tracking performance is also critical to ensure a new release can cope with the current or expected load.

We will discuss various aspects such as which tools and techniques are used for performance tracking and measurements, what are the traps and pitfalls encountered for these activities. The application in question is using Ada, but most of the items discussed are not particularly Ada related.

Making Valgrind faster is a never ending challenge. In this talk, we will describe 2 optimisations in Valgrind.

A first optimisation is a speedup of Helgrind (a race detection tool). A very simple observation has led to an optimisation in the way helgrind captures stack traces for its 'full recording' of where a piece of memory was modified. This optimisation gives a typical speed up of 25%. We will describe the issues encountered during the implementation and discuss the reasons why this optimisation is not (yet?) committed in the Valgrind sources.

The second optimisation is the implementation of the execution tree concept : this generalises the way Massif (a heap profiler) records the memory usage of a program. We will show how a (maybe counter-intuitive) representation of a tree using a hash table of flat stack traces has doubled the speed of Massif for some workloads.

This talk is aimed at Valgrind developers and any application developer interested in data structures and algorithm optimisations.

Valgrind and its different tools are providing a rich set of functionality to track memory problems such as dangling pointers, memory leaks, race conditions, etc.

In this talk, we will describe some old and new features that help to understand what happens in your application. Among others, we will give a demo and/or discuss:

• how to use valgrind with your application specific memory pool

• how to (interactively) ask Valgrind to describe a piece of memory

• some heuristics used by Valgrind to reduce the number of 'possibly lost' leaks with C++ code

• ...

We will discuss more in detail the concept of execution trees, which will be available in the next Valgrind release. An execution tree associates stack traces of your program with some data. Execution trees allow Memcheck and Helgrind to provide a memory profile of your application. We will show how such an execution tree memory profile can be visualised using tools such as Massif visualiser or kcachegrind.

The Eurocontrol Flow Management System provides a simulation functionality to evaluate air traffic flow management measures (such as delay assignments or reroutings) before applying them operationally. This implies to upload a day worth of traffic in a simulation environment.

This talk will describe various techniques and tools used to optimize the simulation startup time, and will discuss the gains reached via micro-optimization (among others using Valgrind) or via macro-optimization (such as using parallelism features of Ada).

Valgrind runs properly multi-threaded applications, but effectively only uses one CPU at a time to run them. In other words, Valgrind cannot make use of multi-core CPUs when running a multi-threaded application.

A prototype of a 'multi-core' Valgrind was developped. This talk will describe this prototype and discuss the challenges to obtain a production quality Valgrind that makes use of multiple core.

Valgrind with its set of tools provides a lot of powerful/sophisticated functionalities. However, this power has a price in CPU and memory.

This talk will discuss various ways to balance CPU and/or memory versus more (or less) functionalities.

Among others, we will explore command line options that control tools such as memcheck or helgrind, in order to detect more (or less) classes of errors, or tune the amount of data recorded by these tools.

We will analyse the impact of such command line options on the CPU and memory.

We will also look at the various ways to investigate the behaviour of Valgrind regarding memory or cpu behaviour.

Demo and small test cases will be used to illustrate the discussed functionalities.

This talk will describe basic and more advanced functionalities provided by the combination of GDB and Valgrind.

Valgrind has an embedded GDB server. That means it is possible to control a Valgrind run from GDB, doing all the usual things that GDB can do (single stepping, breakpoints, examining data, etc). Interactive Valgrind tool-specific functionality is available. For example, it is possible to query the definedness state of variables or memory from within GDB when running Memcheck; arbitrarily large memory watchpoints are supported; incremental leak search etc.

If time permits, a demo or description will be given for all or most or many or some of the below:

• basic use

  • how to activate the Valgrind gdbserver and connect GDB to it using the vgdb relay.
  • valgrind monitor command handling
  • Valgrind output redirection
  • List the errors (or last error) found by Valgrind

• Memcheck advanced functionalities

  • interactive leak search
  • display the addresses and content of leaked blocks
  • find who still has pointer(s) to a not freed piece of memory
  • arbitrary large memory watchpoints (unlimited 'simulated' hardware watchpoints)
  • examine or change the Accessibility and Validity bits
  • shadow registers examination

• Use vgdb to command Valgrind tools from the shell or from shell scripts.

• Other Valgrind tools interactive control

  • Massif memory snaphots
  • Dump or zero Callgrind counters

• Other Valgrind gdbserver "core" functionality

  • Threads state display
  • Display "leaked" file descriptors
  • Display some internal information about Valgrind
  • Limitations of the Valgrind gdbserver

Eurocontrol provides pan-European Air Traffic Management services and uses various open source tools to ensure high software quality.

We will discuss the use of gcc, valgrind, Ada and other tools for the detection of memory management bugs, race conditions and performance issues. We will cover Valgrind tools and new functionality in more detail.