Standard Training Courses
Developing, Debugging and Analyzing Performance with the QNX Momentics IDE
You must have a good working knowledge of C or C++. A general understanding of programming under the QNX® Neutrino® RTOS is an asset.
To learn how to use the IDE in the QNX Momentics® to:
- develop your applications
- debug complex problems
- 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.
The course consists of the following sections:
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.
Provides the background that anyone working with the IDE in the QNX Momentics development 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 and examining data is provided.
Other debugging topics
This module broadens the definition of debugging by exploring capabilities that are beyond the reach of conventional tools. It starts with using the IDE to debug multithreaded processes and multiple processes, then explores how to debug IPC issues, debug callbacks, perform postmortem debugging, attach to a running process, and debug shared libraries.
- 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.
Overview of QNX embedded systems
Before doing actual embedding, you must understand the components that you want to embed and how they relate to each other. You also need this information when designing your embedded system. To explain all this, we cover many of the possible ways of booting, what components are involved, and how they all fit together. This includes everything from the IPL to what file systems are available.
Embedding with the QNX Momentics IDE
Details how to use the IDE in the QNX Momentics development suite to create a bootable image file that includes the components needed at boot time. Also explains how to create an embedded file system image that contains the components needed once your system has booted up. Often the IPL, images, and other components need to be converted to some intermediate form prior to putting on the target. We'll discuss how to perform that conversion. We'll also explore features that let you perform serial and TFTP downloads to a target.
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.
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.
- Performance analysis
Demonstrates how the application profiler and the system profiler can help you diagnose why an application is behaving slowly. We'll look at two or three systems that are not behaving as expected, and use the IDE's Performance Analysis tools to determine why things are going wrong.
Provides a summary of what was learned and where to go next for further information.