Home
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running QNX Neutrino 7.1.
Programming
Getting Started with QNX Neutrino
Getting Started with QNX Neutrino: A Guide for Realtime Programmers is intended to introduce you to the QNX Neutrino RTOS and help you develop applications and resource managers for it.
Clocks, Timers, and Getting a Kick Every So Often
It's time to take a look at everything related to time in the QNX Neutrino RTOS. We'll see how and why you'd use timers and the theory behind them. Then we'll take a look at getting and setting the realtime clock.
Advanced topics
Now that we've seen the basics of timers, we'll look at a few advanced topics.
Other clock sources
We've seen the clock source CLOCK_REALTIME, and mentioned that a POSIX-conforming implementation may supply as many different clock sources as it feels like, provided that it at least provides CLOCK_REALTIME.
So what does CLOCK_SOFTTIME do?
If we wanted to sort our clock sources by hardness we'd have the following ordering: You can think of CLOCK_MONOTONIC as being a freight train—it doesn't stop for anyone. Next on the list is CLOCK_REALTIME, because it can be pushed around a bit (as we saw with the time adjustment). Finally, we have CLOCK_SOFTTIME, which we can push around a lot.

QNX Momentics IDE User's Guide
This User's Guide describes version 7.1 of the Integrated Development Environment (IDE) that's part of the QNX Momentics tool suite.
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running QNX Neutrino 7.1.
- Quickstart Guide
- OS Components & Operations
- Audio & Graphics API
- Multimedia
- Networking Middleware
- Programming
  - Getting Started with QNX Neutrino
    Getting Started with QNX Neutrino: A Guide for Realtime Programmers is intended to introduce you to the QNX Neutrino RTOS and help you develop applications and resource managers for it.
    - Processes and Threads
    - Message Passing
      In this chapter, we'll look at the most distinctive feature of QNX Neutrino, message passing. Message passing lies at the heart of the operating system's microkernel architecture, giving the OS its modularity.
    - Clocks, Timers, and Getting a Kick Every So Often
      It's time to take a look at everything related to time in the QNX Neutrino RTOS. We'll see how and why you'd use timers and the theory behind them. Then we'll take a look at getting and setting the realtime clock.
      - Clocks and timers
        Let's look at a typical system, say a car. In this car, we have a bunch of programs, most of which are running at different priorities. Some of these need to respond to actual external events (like the brakes or the radio tuner), while others need to operate periodically (such as the diagnostics system). In this section, we'll explain how clocks and timers can help us achieve this.
      - Using timers
        Having looked at all this wonderful theory, let's turn our attention to some specific code samples to see what you can do with timers.
      - Advanced topics
        Now that we've seen the basics of timers, we'll look at a few advanced topics.
        Other clock sources
        We've seen the clock source CLOCK_REALTIME, and mentioned that a POSIX-conforming implementation may supply as many different clock sources as it feels like, provided that it at least provides CLOCK_REALTIME.
        CLOCK_MONOTONIC
        The POSIX people thought about this, and the solution they came up with was another clock source called CLOCK_MONOTONIC.
        So what does CLOCK_SOFTTIME do?
        If we wanted to sort our clock sources by hardness we'd have the following ordering: You can think of CLOCK_MONOTONIC as being a freight train—it doesn't stop for anyone. Next on the list is CLOCK_REALTIME, because it can be pushed around a bit (as we saw with the time adjustment). Finally, we have CLOCK_SOFTTIME, which we can push around a lot.
        Using different clock sources
        To specify one of the different clock sources, use a POSIX timing function that accepts a clock ID.
        Kernel timeouts
        QNX Neutrino lets you have a timeout associated with all kernel blocking states. We talked about the blocking states in the Processes and Threads chapter, in the section Kernel states. Most often, you'll want to use this with message passing; a client will send a message to a server, but the client won't want to wait forever for the server to respond. In that case, a kernel timeout is suitable. Kernel timeouts are also useful with the pthread_join() function. You might want to wait for a thread to finish, but you might not want to wait too long.
        Summary
        We've looked at QNX Neutrino's time-based functions, including timers and how they can be used, as well as kernel timeouts. Relative timers provide some form of event in a certain number of seconds, while absolute timers provide this event at a certain time. Timers (and, generally speaking, the struct sigevent) can cause the delivery of a pulse or a signal, or the creation of a thread.
    - Interrupts
      In this chapter, we'll take a look at interrupts, how we deal with them under QNX Neutrino, their impact on scheduling and realtime, and some interrupt-management strategies.
    - Resource Managers
      In this chapter, we'll take a look at what you need to understand in order to write a resource manager. Resource managers are another distintive feature of QNX Neutrino that allow you to access services through standard POSIX calls.
    - Sample Programs
      This appendix contains the complete versions of some of the sample programs discussed in this book.
    - Glossary
  - Programmer's Guide
    The QNX Neutrino Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX Neutrino RTOS.
  - The QNX Neutrino Cookbook: Recipes for Programmers
  - Writing a Resource Manager
- Sensor Framework
- System Security Guide
  The QNX System Security Guide is intended for both system integrators who are responsible for the security of a QNX Neutrino RTOS system and developers who want to create a QNX Neutrino resource manager free from vulnerabilities.
- Utilities & Libraries
QNX Hypervisor
The QNX Hypervisor allows you to run multiple OSs on a target system so you can separate critical and non-critical functions, support a wide variety of applications, and reduce hardware costs.
QNX Software in the Cloud
QNX Software in the Cloud enables developers to use the QNX software in Amazon Web Services (AWS) and Microsoft Azure (Azure).
QNX Advanced Virtualization Frameworks User's Guide
This User's Guide is aimed at all systems integrators and developers who want to design and build embedded systems using the QNX Advanced Virtualization Frameworks.
Typographical Conventions, Support, and Licensing
This section describes the typographical conventions used throughout the documentation and explains how to obtain technical support.

So what does CLOCK_SOFTTIME do?

If we wanted to sort our clock sources by hardness we'd have the following ordering: You can think of CLOCK_MONOTONIC as being a freight train—it doesn't stop for anyone. Next on the list is CLOCK_REALTIME, because it can be pushed around a bit (as we saw with the time adjustment). Finally, we have CLOCK_SOFTTIME, which we can push around a lot.

The main use of CLOCK_SOFTTIME (a QNX Neutrino extension to POSIX) is for things that are soft—things that aren't going to cause a critical failure if they don't get done. CLOCK_SOFTTIME is active only when the CPU is running. (Yes, this does sound obvious :-) but wait!) When the CPU is powered down because power management has detected that nothing is going to happen for a little while, CLOCK_SOFTTIME gets powered down as well!

Here's a timing chart showing the three clock sources:


Real time	QNX Neutrino time	Activity
11:22:05	11:22:00	Wake up at now + 00:00:30 (see below)
11:22:15	11:22:15	Clock gets adjusted as before
11:22:20	11:22:20	Power management turns off CPU
11:22:30	11:22:30	CLOCK_REALTIME wakes up
11:22:35	11:22:35	CLOCK_MONOTONIC wakes up
11:45:07	11:45:07	Power management turns on CPU, and CLOCK_SOFTTIME wakes up

There are a few things to note here:

We precomputed our wakeup time as now plus 30 seconds and used an absolute timer to wake us up at the computed time. This is different from waking up in 30 seconds using a relative timer.
Note that for convenience of putting the example on one timeline, we've lied a little bit. If the CLOCK_REALTIME thread did indeed wake up (and later the same for CLOCK_MONOTONIC), it would have caused us to exit out of power-management mode at that time, which would then cause CLOCK_SOFTTIME to wake up.

When CLOCK_SOFTTIME oversleeps, it wakes up as soon as it's able—it doesn't stop timing while the CPU is powered down, it's just not in a position to wake up until after the CPU powers up. Other than that, CLOCK_SOFTTIME is just like CLOCK_REALTIME.

Page updated: March 12, 2026