Developing, Debugging and Analyzing Performance with the QNX Momentics IDE

Prerequisites

You must have a good working knowledge of C or C++. A general understanding of programming under the QNX^® Neutrino^® RTOS is an asset.

Objectives

To learn how to use the IDE in the QNX^® Momentics^® Tool Suite to:

1. Develop your applications
2. Debug complex problems
3. Analyze performance issues of complete systems

By the end of the course, you will have used the IDE to work with many sample programs and systems, either self-hosted or using cross development, and will have learned to apply these skills to real-world applications.

Topics

The course consists of the following sections:

• Introduction

  Outlines what topics will be covered.

• QNX Neutrino RTOS architecture

  Gives an overview of the QNX Neutrino RTOS architecture, covering what the microkernel and the process manager do. We talk about standards, protected address spaces, process/thread model, timing, and scheduling. We also introduce various types of IPC, synchronization, what a resource manager is, where shared objects fit in, and the QNX Photon microGUI^® windowing system.

• IDE basics

  Provides the background that anyone working with the IDE in the QNX Momentics Tool Suite must have. Starting with the central concepts of the IDE, you'll become adept at navigating in the IDE and configuring it to suit your personal needs. We then talk about projects, workspaces, and the host-target model, introducing the various ways to interface with your target. We end with a handful of the preferences that can make your life easier, along with pointers to various sources of documentation.

• Managing C/C++ projects

  The basic container for code in the IDE is a project. We cover the three types of projects for C/C++ code: a project where the entire contents and build structure are up to you, a project with a predefined structure that supports multiple platforms, and library projects. We cover both header file and project dependencies and discuss how to get code from elsewhere and place it into your projects.

• Editing and Compiling

  This section will focus on the code editor in the Momentics IDE, including the many powerful, time-saving, features. In addition, we look at how build code, and how the IDE identifies problems with the build.
  

• Running and Debugging

  In this section, we look at launching programs, both a simple "run", as well as launching in the debugger. An overview of the fundamental debugging features such as stepping through code; setting breakpoints; performing post-mortem debugging; attaching to a running process; debugging shared libraries, and examining data is provided.

• Debugging Memory Problems

  Memory problems, such as memory corruption, can often be subtle and uncaught by testing. In this section we explore the powerful Momentics IDE tools for finding memory corruption, leaks, and excessive memory consumption.

• Application profiling

  All the details on using the IDE's application profiler to profile a single process. Using the profiler, you can pinpoint which parts of your code are consuming the most CPU, at both the function level and the source-line level. You can then use that information to make your code more efficient. Both live profiling and postmortem profiling are covered.

• Code Coverage

  Determining the effectiveness of a test suite takes work. In this section we'll see the IDE tools determining how much of your code has actually been executed, broken down to the source line, by your testing.

• System profiling

  With system profiling, you can examine your system as a whole to see what's going on. Detail is available down to the kernel level. We start by covering what is happening on the kernel side and how to do the necessary setup. Next, we look at how to log the activity through the IDE, from the command line, or under program control. Then, we look at how to use the IDE's system profiling perspective to analyze the resulting data. We finish off with how to insert your own data into logs.

• Conclusion

  Provides a summary of what was learned and where to go next for further information.