What is Adaptive Partitioning?

This chapter includes:

• What are partitions and what is adaptive partitioning?
• System and user requirements
• The thread scheduler

What are partitions and what is adaptive partitioning?

As described in the Adaptive Partitioning chapter of the System Architecture guide, a partition is a virtual wall that separates competing processes or threads.

Partitions let the system designer allocate minimum amounts of system resources to each set of processes or threads. The primary resource considered is CPU time, but can also include any shared resource, such as memory and file space (disk or flash).

---

The initial version of Adaptive Partitioning implemented the budgeting of CPU time via the thread scheduler. Traditional partitions are static and work optimally when there's little or no dynamic deployment of software; in dynamic systems, static partitions can be inefficient.

---

Adaptive partitions are more flexible because:

• you can dynamically add and configure them
• they behave as a global hard real time scheduler under normal load, but can continue to provide minimal interrupt latencies when the system is fully loaded
• they distribute a partition's unused resources among partitions that require additional resources when the system isn't loaded

You can introduce adaptive partitioning without changing — or even recompiling — your application code, although you do have to rebuild your system's OS image.

Are partitions “box-like”? No, they're better. Many competing resource partitioning systems take their model from CPU virtualization, where the objective it to try to divide a computer into a set of smaller computers that interact as little as possible (into a number of “boxes”). This approach is not very flexible; every thread, process, and byte of memory is in exactly one box, and it can never move. Adaptive partitioning takes a much more flexible view.

To begin, QNX partitions are adaptive because:

• you can change configurations at run time
• they are typically fixed at one configuration time
• the partition behavior auto-adapts to conditions at run time. For example:
  • free time is redistributed to other scheduler partitions
  • filesystems can bill time to clients with a mechanism that temporarily moves threads between time partitions

As a result, adaptive partitions are not a box; they are much more powerful. In addition to being adaptive, the partitions allow us to easily model the fundamentally different behavior of CPU time when viewed as a resource.

Because adaptive partitions are not “boxes” what are they?

An adaptive partition is a named set of rules. The rules are selected to control the global resource behavior of the system. When a process or thread is associated with a particular partition (scheduler), then its actions are governed by the rules of that partition at that time.

For example, adaptive partitioning is similar to people who belong to clubs. Each person can join several different clubs. They can even move from one club to another club at times. However, while they are at a particular club, they agree to abide by the rules of that specific club.

System and user requirements

For adaptive partitioning to operate properly, your system should meet some requirements:

• On x86 systems, turn off any BIOS configuration that may cause the processor to enter System Management Mode (SMM). A typical example is USB legacy support. If the processor enters SMM, the adaptive partitioning thread scheduler continues to function correctly, but CPU percentages apportioned to partitions will be inaccurate.

  A typical reason for preventing SMM is that it introduces interrupt latencies of about 100 microseconds at unpredictable intervals.

• Adaptive partitioning isn't supported on 386 and 486 processors, because they don't have a timebase counter, which the adaptive partitioning thread scheduler needs in order to perform microbilling.

The thread scheduler

The adaptive partitioning thread scheduler is an optional thread scheduler that lets you guarantee minimum percentages of the CPU's throughput to groups of threads, processes, or applications. The percentage of the CPU time allotted to a partition is called a budget.

The thread scheduler was designed on top of the core QNX Neutrino architecture primarily to solve these problems in embedded systems design:

• to guarantee proper function when the system is fully loaded
• to prevent unimportant or untrusted applications from monopolizing the system

For more detailed information about the thread scheduler, see “Using the Thread Scheduler” in this guide. To quickly get started using the thread scheduler, try the Quickstart: Adaptive Partitioning Thread Scheduler example.