BlackBerry QNX Training Modules
Choose the Training Modules You Need
If you opt for on-site training, you can choose from our existing courses or design a custom program by selecting the modules you need. To have an instructor help you select from the following modules, contact training@qnx.com.
| Module name | Module Description | Prerequisites | Duration |
|---|---|---|---|
| Adaptive Partitioning Scheduler | Learn how to use the QNX® Adaptive Partitioning Scheduler, or APS, to group threads and/or processes into partitions according to their CPU requirements and/or to protect them from CPU starvation. APS is useful for safety and/or hypervisor related products or any product where partitioning the CPU may be needed. We will discuss the architecture of APS, how to add APS to an image, define and understand partitions, critical priorities and bankruptcy. There are hands-on exercises to explore administering APS from both the command line and with the APS API. | QNX® Neutrino® RTOS Architecture, Building a Boot Image | 3.5 hours |
| Application Profiling | Learn how to use the application profiler in the QNX® Momentics® Tool Suite 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 and post-mortem profiling are covered. | IDE Basics or Compiling and Debugging | 1 hour |
| Building a QNX Neutrino Boot/OS Image | A detailed look at building boot images, which contain the binaries that run just after the reset vector. Boot images typically include components such as startup code, the process manager, the kernel, drivers, and a startup script. We also explore various ways to load a boot image onto your target. | IDE Basics or Compiling and Debugging | 1 hour |
| Code Coverage | Determining the effectiveness of a test suite takes work. In this section well see the IDE tools determining how much of your code has actually been executed, broken down to the source line, by your testing. | IDE Basics or Compiling and Debugging | 1 hour |
| Comparing QNX IPC Methods | A quick look at the relative advantages and disadvantages of the various IPC methods supported by QNX with a view to choosing which method(s) to use in your system. | Inter-process Communication | 0.5 hour |
| Compiling and Debugging |
This section provides a quick introduction to editing, compiling, running, and debugging your application from the QNX Momentics IDE, giving the minimum needed to do the programming exercises in the programming sections. Note: This module is a light replacement for the Editing and Compiling and Running and Debugging modules. If you take one of those modules, it isn‘t necessary to take this one. |
None | 2 hours |
| 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. | IDE Basics or Compiling and Debugging | 2 hours |
| 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 to build code and how the IDE identifies problems with the build. | IDE Basics or Compiling and Debugging | 1.5 hours |
| File System Resource Managers | A discussion on how to write file system resource managers, which are processes that represent data in the form of files or file systems. You will learn to write a resource manager that presents a tar file as a file system. | Writing a Resource Manager | 3.5 hours |
| Further Topics for Resource Managers | Explores the various ways to return from handlers, manage access and modification times, leave clients blocked, use multi-threaded resource managers, implement combine messages, perform unblock handling, receive pulses, and make select() and ionotify() work. Resource manager concepts are reinforced through a variety of hands-on exercises. | Threads and Synchronization, Introduction to Resource Managers | 6 hours |
| High Availability | We start with how QNX architecture lends itself to high availability, then look at how to design applications that take advantage of that architecture. Next, we explore the high availability toolkit in detail, starting with how to use the high availability manager for doing process restart and multistage restart. We then cover the client recovery library, also included in the toolkit, which helps clients to restore broken connections. | QNX Neutrino RTOS Architecture | 3.5 hours |
| IDE Basics | Focusing on Eclipse fundamentals, this section provides necessary background for anyone working with the IDE in the QNX® Momentics® Tool Suite. Starting with the central concepts of the IDE, you‘ll become adept at navigation in the IDE and configuring it to suit your personal needs and likes. We then talk about projects, workspaces and the host-target model, introducing various ways to interface to your target. We end with pointing out several preference settings that can make your work easier. | None | 2 hours |
| Inter-Process Communication | Explores the various methods that the QNX Neutrino RTOS provides for allowing two or more processes to exchange information and control. We focus on the QNX message passing that is fundamental to how QNX Neutrino works, but also examine pulses and shared memory. | Threads and Synchronization | 9 hours |
| Interrupts | Explores how the QNX Neutrino RTOS makes it relatively easy to write and debug interrupt handlers. We present several approaches to interrupt handlers. | Inter-Process Communication (recommended) | 2.5 hours |
| Introduction to Hardware Programming | An introduction to hardware access methods including IO-mapped and memory-mapped IO, allocating DMA-safe memory, and interrupt handling. | None | 1.5 hours |
| Introduction to Resource Managers | Any process can be a resource manager, and drivers usually are. This section looks at the capabilities of resource managers, including pathname-space resolution, IPC message formats, and general structure. Through a set of exercises we‘ll look at the initialization of a simple resource manager and the handling of read() and write() operations. | Inter-Process Communication | 3 hours |
| I/O | Covers in detail the I/O aspects of a driver, including how to do port I/O and memory-mapped I/O, how to perform DMA memory configuration, and how to use the PCI API. | None | 1.5 hours |
| I/O Exercises |
A collection of challenging exercises that are a must for anyone learning to write device drivers. The exercises used depend on the hardware available. You can choose from: •VGA Text Mode driver exercise (2.5 hours) You‘ll write an I/O manager that does read()s from, write()s to, and devctl()s for changing the configuration of VGA text mode memory. •Keyboard driver exercise (1.5 hours) You will write a simple driver that handles x86 keyboard input. |
I/O, Introduction to Resource Managers | Depends on which exercises are chosen. |
| Managing C/C++ Projects | The basic container for code in the IDE is a project. We cover the two types of projects for C/C++ code: a project where the entire contents and build structure are up to you, and a project with a predefined structure that supports multiple platforms. We cover both header file and project dependencies and discuss how to get code from elsewhere and place it into your projects. | None | 2 hours |
| More on Threads and Synchronization | Covers additional issues for anyone who wants to know a lot about threads, including reader/writer locks, once control, and thread local storage. | Threads and Synchronization | 1.5 hours |
| Multicore Processing | Discusses how to configure your application for Multicore, how scheduling works, where ISRs run, and processor affinity. Also examines how to perform synchronization among threads and between threads and ISRs. | QNX Neutrino RTOS Architecture | 1 hour |
| POSIX Inter-process Communication in QNX | QNX supplies a rich set of POSIX IPC methods. This section looks at signals, shared memory, pipes, POSIX message queues, and TCP/IP. | None | 2 hours |
| Processes, Threads and Synchronization | Unlike many common legacy RTOSs, the QNX Neutrino RTOS executes programs in separate, memory protected, processes. This section touches on how a system design problem can be broken down into separate processes, and how processes are started and terminated. In addition, in this section we‘ll discuss what a thread is, how to start and stop a thread, and how to synchronize resource access via QNX Neutrino RTOS and POSIX function calls. Several hands-on lab exercises form a significant component of this section. | QNX Neutrino RTOS Architecture | 4 hours |
| QNX® Hypervisor Overview | An overview of the QNX Hypervisor and of how your applications make use of it. We cover the types of devices available to your guest OSes, where your guests run, their virtual CPUs, privileges and priorities. We then touch on how guests communicate with each other and/or with the QNX Hypervisor host, and how they can share devices. Next, we introduce how time and interrupts work. Thick and thin designs are then compared, and we finish with safety issues and an overview of the QNX Hypervisor for Safety. | QNX Neutrino RTOS Architecture | 5 hours |
| 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 and where shared objects fit in. | None | 4.5 hours |
| QNX Neutrino RTOS Programming Basics |
A review of basic programming topics for the QNX Neutrino RTOS, such as threads, mutexes, message passing, pulses, and timing. This module provides a refresher course to students familiar with QNX programming and offers a good background for other course material. Note: You don‘t have to select this module if you‘re taking other modules that cover the same topics in more detail. |
None | 3 hours |
| QNX Neutrino Security | We discuss a variety of security topics for QNX Neutrino, starting with the basics of a microkernel architecture and Unix file permissions. We look at how QNX breaks down root abilities using procmgr abilities, discovering needed abilities, and using security policy to specify these. We delve into specific security features of QNX Neutrino, including Pathspace Control. And we look at various new optional subsystems such as hashed and encrypted filesystems, and Pathtrust. Several hands-on exercises are included. | QNX Neutrino Architecture | 8 hours |
| Running and Debugging | A look at launching programs with either "run" or from the debugger. We explain the fundamental debugging features, including stepping through code; setting breakpoints; performing post-mortem debugging; attaching to a running process; debugging shared libraries; and examining data. | IDE Basics or Compiling and Debugging | 2.5 hours |
| 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 QNX Momentics 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. |
QNX Neutrino RTOS Architecture, Inter-Process Communication |
3.5 hours |
| Timers, Clocks, and Timeouts | An explanation of how to meet deterministic timing requirements. We discuss timing architecture and how to handle periodic timing, one-shot timing, time-stamping, benchmarking, and timeouts. | Inter-Process Communication (recommended) | 3 hours |
| Writing a character (e.g. serial) driver | We‘ll look at using the Neutrino io-char library to write a driver for character devices such as serial chipsets that support the RS-232 protocol. | Introduction to Resource Managers | 1 hour |
| Writing a Resource Manager | A look at the capabilities of resource managers, including pathname-space resolution, IPC message formats, and general structure. We provide several exercises, from a very simple resource manager that implements /dev/null to more complex examples that support multiple devices. | QNX Neutrino RTOS Architecture, Inter-Process Communication | 7 hours |
| Module Description | |
|---|---|
| Adaptive Partitioning Scheduler | Learn how to use the QNX® Adaptive Partitioning Scheduler, or APS, to group threads and/or processes into partitions according to their CPU requirements and/or to protect them from CPU starvation. APS is useful for safety and/or hypervisor related products or any product where partitioning the CPU may be needed. We will discuss the architecture of APS, how to add APS to an image, define and understand partitions, critical priorities and bankruptcy. There are hands-on exercises to explore administering APS from both the command line and with the APS API. |
| Application Profiling | Learn how to use the application profiler in the QNX® Momentics® Tool Suite 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 and post-mortem profiling are covered. |
| Building a QNX Neutrino Boot/OS Image | A detailed look at building boot images, which contain the binaries that run just after the reset vector. Boot images typically include components such as startup code, the process manager, the kernel, drivers, and a startup script. We also explore various ways to load a boot image onto your target. |
| Code Coverage | Determining the effectiveness of a test suite takes work. In this section well see the IDE tools determining how much of your code has actually been executed, broken down to the source line, by your testing. |
| Comparing QNX IPC Methods | A quick look at the relative advantages and disadvantages of the various IPC methods supported by QNX with a view to choosing which method(s) to use in your system. |
| Compiling and Debugging |
This section provides a quick introduction to editing, compiling, running, and debugging your application from the QNX Momentics IDE, giving the minimum needed to do the programming exercises in the programming sections. Note: This module is a light replacement for the Editing and Compiling and Running and Debugging modules. If you take one of those modules, it isn‘t necessary to take this one. |
| 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. |
| 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 to build code and how the IDE identifies problems with the build. |
| File System Resource Managers | A discussion on how to write file system resource managers, which are processes that represent data in the form of files or file systems. You will learn to write a resource manager that presents a tar file as a file system. |
| Further Topics for Resource Managers | Explores the various ways to return from handlers, manage access and modification times, leave clients blocked, use multi-threaded resource managers, implement combine messages, perform unblock handling, receive pulses, and make select() and ionotify() work. Resource manager concepts are reinforced through a variety of hands-on exercises. |
| High Availability | We start with how QNX architecture lends itself to high availability, then look at how to design applications that take advantage of that architecture. Next, we explore the high availability toolkit in detail, starting with how to use the high availability manager for doing process restart and multistage restart. We then cover the client recovery library, also included in the toolkit, which helps clients to restore broken connections. |
| IDE Basics | Focusing on Eclipse fundamentals, this section provides necessary background for anyone working with the IDE in the QNX® Momentics® Tool Suite. Starting with the central concepts of the IDE, you‘ll become adept at navigation in the IDE and configuring it to suit your personal needs and likes. We then talk about projects, workspaces and the host-target model, introducing various ways to interface to your target. We end with pointing out several preference settings that can make your work easier. |
| Inter-Process Communication | Explores the various methods that the QNX Neutrino RTOS provides for allowing two or more processes to exchange information and control. We focus on the QNX message passing that is fundamental to how QNX Neutrino works, but also examine pulses and shared memory. |
| Interrupts | Explores how the QNX Neutrino RTOS makes it relatively easy to write and debug interrupt handlers. We present several approaches to interrupt handlers. |
| Introduction to Hardware Programming | An introduction to hardware access methods including IO-mapped and memory-mapped IO, allocating DMA-safe memory, and interrupt handling. |
| Introduction to Resource Managers | Any process can be a resource manager, and drivers usually are. This section looks at the capabilities of resource managers, including pathname-space resolution, IPC message formats, and general structure. Through a set of exercises we‘ll look at the initialization of a simple resource manager and the handling of read() and write() operations. |
| I/O | Covers in detail the I/O aspects of a driver, including how to do port I/O and memory-mapped I/O, how to perform DMA memory configuration, and how to use the PCI API. |
| I/O Exercises |
A collection of challenging exercises that are a must for anyone learning to write device drivers. The exercises used depend on the hardware available. You can choose from: •VGA Text Mode driver exercise (2.5 hours) You‘ll write an I/O manager that does read()s from, write()s to, and devctl()s for changing the configuration of VGA text mode memory. •Keyboard driver exercise (1.5 hours) You will write a simple driver that handles x86 keyboard input. |
| Managing C/C++ Projects | The basic container for code in the IDE is a project. We cover the two types of projects for C/C++ code: a project where the entire contents and build structure are up to you, and a project with a predefined structure that supports multiple platforms. We cover both header file and project dependencies and discuss how to get code from elsewhere and place it into your projects. |
| More on Threads and Synchronization | Covers additional issues for anyone who wants to know a lot about threads, including reader/writer locks, once control, and thread local storage. |
| Multicore Processing | Discusses how to configure your application for Multicore, how scheduling works, where ISRs run, and processor affinity. Also examines how to perform synchronization among threads and between threads and ISRs. |
| POSIX Inter-process Communication in QNX | QNX supplies a rich set of POSIX IPC methods. This section looks at signals, shared memory, pipes, POSIX message queues, and TCP/IP. |
| Processes, Threads and Synchronization | Unlike many common legacy RTOSs, the QNX Neutrino RTOS executes programs in separate, memory protected, processes. This section touches on how a system design problem can be broken down into separate processes, and how processes are started and terminated. In addition, in this section we‘ll discuss what a thread is, how to start and stop a thread, and how to synchronize resource access via QNX Neutrino RTOS and POSIX function calls. Several hands-on lab exercises form a significant component of this section. |
| QNX® Hypervisor Overview | An overview of the QNX Hypervisor and of how your applications make use of it. We cover the types of devices available to your guest OSes, where your guests run, their virtual CPUs, privileges and priorities. We then touch on how guests communicate with each other and/or with the QNX Hypervisor host, and how they can share devices. Next, we introduce how time and interrupts work. Thick and thin designs are then compared, and we finish with safety issues and an overview of the QNX Hypervisor for Safety. |
| 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 and where shared objects fit in. |
| QNX Neutrino RTOS Programming Basics |
A review of basic programming topics for the QNX Neutrino RTOS, such as threads, mutexes, message passing, pulses, and timing. This module provides a refresher course to students familiar with QNX programming and offers a good background for other course material. Note: You don‘t have to select this module if you‘re taking other modules that cover the same topics in more detail. |
| QNX Neutrino Security | We discuss a variety of security topics for QNX Neutrino, starting with the basics of a microkernel architecture and Unix file permissions. We look at how QNX breaks down root abilities using procmgr abilities, discovering needed abilities, and using security policy to specify these. We delve into specific security features of QNX Neutrino, including Pathspace Control. And we look at various new optional subsystems such as hashed and encrypted filesystems, and Pathtrust. Several hands-on exercises are included. |
| Running and Debugging | A look at launching programs with either "run" or from the debugger. We explain the fundamental debugging features, including stepping through code; setting breakpoints; performing post-mortem debugging; attaching to a running process; debugging shared libraries; and examining data. |
| 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 QNX Momentics 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. |
| Timers, Clocks, and Timeouts | An explanation of how to meet deterministic timing requirements. We discuss timing architecture and how to handle periodic timing, one-shot timing, time-stamping, benchmarking, and timeouts. |
| Writing a character (e.g. serial) driver | We‘ll look at using the Neutrino io-char library to write a driver for character devices such as serial chipsets that support the RS-232 protocol. |
| Writing a Resource Manager | A look at the capabilities of resource managers, including pathname-space resolution, IPC message formats, and general structure. We provide several exercises, from a very simple resource manager that implements /dev/null to more complex examples that support multiple devices. |
| Prerequisites | |
|---|---|
| Adaptive Partitioning Scheduler | QNX® Neutrino® RTOS Architecture, Building a Boot Image |
| Application Profiling | IDE Basics or Compiling and Debugging |
| Building a QNX Neutrino Boot/OS Image | IDE Basics or Compiling and Debugging |
| Code Coverage | IDE Basics or Compiling and Debugging |
| Comparing QNX IPC Methods | Inter-process Communication |
| Compiling and Debugging | None |
| Debugging Memory Problems | IDE Basics or Compiling and Debugging |
| Editing and Compiling | IDE Basics or Compiling and Debugging |
| File System Resource Managers | Writing a Resource Manager |
| Further Topics for Resource Managers | Threads and Synchronization, Introduction to Resource Managers |
| High Availability | QNX Neutrino RTOS Architecture |
| IDE Basics | None |
| Inter-Process Communication | Threads and Synchronization |
| Interrupts | Inter-Process Communication (recommended) |
| Introduction to Hardware Programming | None |
| Introduction to Resource Managers | Inter-Process Communication |
| I/O | None |
| I/O Exercises | I/O, Introduction to Resource Managers |
| Managing C/C++ Projects | None |
| More on Threads and Synchronization | Threads and Synchronization |
| Multicore Processing | QNX Neutrino RTOS Architecture |
| POSIX Inter-process Communication in QNX | None |
| Processes, Threads and Synchronization | QNX Neutrino RTOS Architecture |
| QNX® Hypervisor Overview | QNX Neutrino RTOS Architecture |
| QNX Neutrino RTOS Architecture | None |
| QNX Neutrino RTOS Programming Basics | None |
| QNX Neutrino Security | QNX Neutrino Architecture |
| Running and Debugging | IDE Basics or Compiling and Debugging |
| System Profiling |
QNX Neutrino RTOS Architecture, Inter-Process Communication |
| Timers, Clocks, and Timeouts | Inter-Process Communication (recommended) |
| Writing a character (e.g. serial) driver | Introduction to Resource Managers |
| Writing a Resource Manager | QNX Neutrino RTOS Architecture, Inter-Process Communication |
| Duration | |
|---|---|
| Adaptive Partitioning Scheduler | 3.5 hours |
| Application Profiling | 1 hour |
| Building a QNX Neutrino Boot/OS Image | 1 hour |
| Code Coverage | 1 hour |
| Comparing QNX IPC Methods | 0.5 hour |
| Compiling and Debugging | 2 hours |
| Debugging Memory Problems | 2 hours |
| Editing and Compiling | 1.5 hours |
| File System Resource Managers | 3.5 hours |
| Further Topics for Resource Managers | 6 hours |
| High Availability | 3.5 hours |
| IDE Basics | 2 hours |
| Inter-Process Communication | 9 hours |
| Interrupts | 2.5 hours |
| Introduction to Hardware Programming | 1.5 hours |
| Introduction to Resource Managers | 3 hours |
| I/O | 1.5 hours |
| I/O Exercises | Depends on which exercises are chosen. |
| Managing C/C++ Projects | 2 hours |
| More on Threads and Synchronization | 1.5 hours |
| Multicore Processing | 1 hour |
| POSIX Inter-process Communication in QNX | 2 hours |
| Processes, Threads and Synchronization | 4 hours |
| QNX® Hypervisor Overview | 5 hours |
| QNX Neutrino RTOS Architecture | 4.5 hours |
| QNX Neutrino RTOS Programming Basics | 3 hours |
| QNX Neutrino Security | 8 hours |
| Running and Debugging | 2.5 hours |
| System Profiling | 3.5 hours |
| Timers, Clocks, and Timeouts | 3 hours |
| Writing a character (e.g. serial) driver | 1 hour |
| Writing a Resource Manager | 7 hours |
DATES AND LOCATIONS
All BlackBerry QNX training courses are hands-on, instructor led using real-world examples to give your development team the grounding they need in QNX best practices so that you get the most out of your investment.