ccNUMA Overview

HP-UX thread-launch and process-launch policies are independent of one another.
When a process creates another process (via fork() or vfork()), the child process inherits the parent process’s
launch policy. The initial thread in the child process inherits the launch policy of the creating thread (and not that
of its process). Other threads in a multi-threaded process inherit their launch policy from the creating thread.
The launch policies (except the None policy) guarantee that HP-UX binds threads and processes to the locality
domains in which they start execution. This locality binding causes HP-UX to not migrate the threads and processes
across localities.
HP-UX 11i v2 supports the following thread-launch and process-launch policies. Detailed descriptions are in
Table 2.
• None—Is the default launch policy for threads or processes; see “Default launch policies” for details
• Round Robin—Launches by alternating the thread or process placement among all locality domains until all
locality domains are selected once, then starts over as needed
• Fill First—Fills a locality by placing threads or processes in the locality until all processors are selected. It then
spills over to another locality as needed. Once all localities are filled, it starts over as needed.
• Packed—Places all threads or processes in the same locality domain; it does not spill over
• Least Loaded—Places each thread or process in the locality domain that is least-loaded at the time of its
creation
HP-UX supports these policies as thread-launch policies and as process-launch policies. The policies are inherited
by child threads and processes as described in the “Inheritance of launch policies” section below.
All launch policies permit the processors in a server’s localities to be oversubscribed. That is, the number of
threads and processes in an application may exceed the number of processors in a single locality, or it may
exceed the total number of processors in a server.
The Packed policy causes threads and processes to be launched only within a single locality. All other policies
distribute threads and processes among all locality domains using various methods.
Table 2. Launch policy descriptions
Launch policy description Interfaces
None
None is the default policy for launching threads and processes.
Under the None policy, HP-UX tries to launch threads and processes in
a manner that is best for performance.
Do not rely on this policy for a specific launch behavior, as None may
differ on future HP hardware platforms and HP-UX releases.
pthread_launch_policy_np() support:
PTHREAD_POLICY_NONE_NP
mpctl() system call support:
MPC_SETPROCESS_NONE and MPC_SETLWP_NONE
Round Robin
The Round Robin policy launches each new thread or process in a
round-robin (alternating) fashion across all locality domains.
Under Round Robin, the newly created thread or process is launched on
the least loaded locality, and each subsequent thread or process
launches round-robin into remaining localities, each time selecting the
least loaded of the remaining localities. Once all localities are used,
round-robin starts over, again allowing placement in all localities and
beginning with the least loaded locality.
The launch policy tree only extends from the parent to its immediate
children. The children then become the root of a new launch policy tree.
mpsched policy name: RR
pthread_launch_policy_np() support:
PTHREAD_POLICY_RR_NP
mpctl() system call support:
MPC_SETPROCESS_RR and
MPC_SETLWP_RR
Round Robin Tree
This request establishes a tree-based round-robin launch policy for the
specified thread. This request differs from PTHREAD_POLICY_RR_NP
in which threads become part of the launch tree. This launch policy
includes all descendents of the target thread in the launch tree.
The LDOMs used will be selected in the order in which they were
created at boot time. So, the process or thread distribution of an
application with several levels in the launch tree may vary between
runs.
mpsched policy name: RR_TREE
pthread_launch_policy_np() support:
PTHREAD_POLICY_RR_TREE_NP
mpctl() system call support:
MPC_LAUNCH_POLICY_RR_TREE
Fill First
The Fill First policy launches each new thread or process into the same
locality until the number of launched threads or processes equals the
number of processors in the locality. Threads or processes then spill
over into the next locality and launch there, as needed, until it is filled.
Once all localities are filled, the Fill First policy starts over. When this
occurs, all locality domains are again available for placement and Fill
First selects the least loaded locality, fills it as needed, and then selects
the least loaded of the remaining localities.
mpsched policy name: FILL
pthread_launch_policy_np() support:
PTHREAD_POLICY_FILL_NP
mpctl() system call support:
MPC_SETPROCESS_FILL and
MPC_SETLWP_FILL
10