Home
QNX Software Development Platform
Programming
Programmer's Guide
The QNX OS Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX OS.
Understanding the Microkernel's Concept of Time
Whether you're working with timers or simply getting the time of day, it's important that you understand how the OS works with time.
What time is it?
QNX OS maintains two clocks in the system: one is a monotonic count of time since the kernel was initialized (CLOCK_MONOTONIC), and the other is a wall-clock time since January 1st, 1970 (CLOCK_REALTIME).

QNX Momentics IDE User's Guide
QNX Software Development Platform
- Quickstart Guide
- System Architecture
  The System Architecture guide accompanies the QNX OS and is intended for both application developers and end-users.
- OS Components
- Graphics
- Programming
  - Getting Started with the QNX OS
    Getting Started with the QNX OS: A Guide for Realtime Programmers is intended to introduce you to the QNX OS and help you develop applications and resource managers for it.
  - Programmer's Guide
    The QNX OS Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX OS.
    - Compiling and Debugging
      Let's start by looking at some things you should consider when you start to write a program for the QNX OS.
    - QNX OS Architecture and Concepts
      The QNX OS architecture consists of the microkernel and several cooperating processes. These processes communicate with each other via various forms of interprocess communication (IPC). Message passing is the primary form of IPC in QNX OS.
    - Processes
      Your applications should be written in a way that reflects the architecture of the QNX OS—as a set of cooperating processes. In this chapter, we see how to start processes (also known as creating processes) from code, how to terminate them, and how to detect their termination.
    - Multicore Processing
      Multiprocessing systems, whether discrete or multicore, can greatly improve your applications' performance.
    - Working with Access Control Lists (ACLs)
      Some filesystems, such as the Power-Safe (fs-qnx6.so) filesystem, extend file permissions with Access Control Lists, which are based on the withdrawn IEEE POSIX 1003.1e and 1003.2c draft standards.
    - Understanding the Microkernel's Concept of Time
      Whether you're working with timers or simply getting the time of day, it's important that you understand how the OS works with time.
      - Short delays
      - Oversleeping: errors in delays
        The tick size becomes important just about every time you ask the kernel to do something related to pausing or delaying your process.
      - Another hiccup with hardware timers
      - What time is it?
        QNX OS maintains two clocks in the system: one is a monotonic count of time since the kernel was initialized (CLOCK_MONOTONIC), and the other is a wall-clock time since January 1st, 1970 (CLOCK_REALTIME).
      - Reducing the power consumption of clocks and timers
        If your system needs to manage power consumption, you can set up your timers to help the system to sleep for longer intervals, saving power.
      - Tolerant and high-resolution timers
        You can use timer tolerance to specify how strictly the kernel should enforce a timer's expiry time.
      - Monitoring execution times
        QNX OS includes some special CPU-time clocks that you can use to monitor the execution times for processes and threads.
    - Handling Hardware Interrupts
      This chapter explains the QNX OS mechanisms for quickly reacting to hardware events.
    - Working with Memory
      (or The Persistence of Memory, with a nod to Salvador Dali) In the Process Manager chapter of the System Architecture guide, we looked at how the OS manages memory. This chapter describes how you can work with memory.
    - Freedom from Hardware and Platform Dependencies
      The QNX OS can run on many different hardware platforms. The way in which applications can access peripheral devices and how data is stored varies between platforms. This chapter explains our solutions for minimizing the impact of such platform dependencies.
    - Conventions for Recursive Makefiles and Directories
      In this chapter, we'll look at the supplementary files used in the QNX OS development environment. Although we use the standard make command to create libraries and executables, we also use some of our own conventions in the Makefile syntax.
    - Glossary
  - Writing a Resource Manager
- System Security Guide
  The QNX System Security Guide is intended for both system integrators who are responsible for the security of a QNX OS system and developers who want to create a QNX OS resource manager free from vulnerabilities.
- Utilities & Libraries
- Migrating to QNX OS 8.0
QNX Software in the Cloud
QNX Toolkit for Visual Studio Code
This User's Guide describes the QNX Toolkit for Visual Studio Code. The guide introduces you to the QNX Toolkit by explaining the QNX development environment and how to build, run, and debug your QNX OS applications and systems.
Typographical Conventions, Support, and Licensing
This section describes the typographical conventions used throughout the documentation and explains how to obtain technical support.

What time is it?

QNX SDP8.0Programmer's GuideDeveloper

QNX OS maintains two clocks in the system: one is a monotonic count of time since the kernel was initialized (CLOCK_MONOTONIC), and the other is a wall-clock time since January 1st, 1970 (CLOCK_REALTIME).

The OS actually just counts time since booting, and if asked for the current time, adds an adjustment value (SYSPAGE_ENTRY(qtime)->nsec_tod_adjust) to the monotonic time to get the current time. Any functions that change the current time simply modify the adjustment value.

There are several functions that you can use to determine the current time, for use in timestamps or for calculating execution times, including:

time(): Return the current time in seconds.
clock_gettime(): Return the current or monotonic time in seconds and nanoseconds since the last second.
ClockTime(): Set or get the current or monotonic time in 64-bit nanoseconds

Previous releases used an unsigned 32-bit value for seconds since the start of January 1st, 1970, allowing for time representations through approximately the year 2100. This release of QNX OS uses a signed 64-bit value for seconds since January 1st, 1970. This supports a time range that can be considered infinite.

For a high resolution timestamp without the overhead of a kernel call, you can use ClockCycles().

Note: The hardware underlying ClockCycles() must be synchronized across all processors on an SMP system. If it isn't, you might encounter some unexpected behavior, such as drifting times and timers. Using synchronized hardware means that you no longer have to use a runmask for threads to prevent them from migrating to other processors between calls to ClockCycles().

Some information for each processor:

x86_64: Uses the RDTSC instruction.
aarch64: Reads from a 64-bit CNTVCT_EL0 register.

To convert a ClockCycles() delta to seconds, use SYSPAGE_ENTRY(qtime)->cycles_per_sec.

Page updated: May 17, 2024