Processor affinity

Short description: Assignment of a task to a given core of a CPU

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed.
Find sources: "Processor affinity" – news · newspapers · books · scholar · JSTOR (June 2021) (Learn how and when to remove this template message)

|

In computer science, processor affinity, also called CPU pinning or cache affinity, enables the binding and unbinding of a process or a thread to a central processing unit (CPU) or a range of CPUs, so that the process or thread will execute only on the designated CPU or CPUs rather than any CPU. This can be viewed as a modification of the native central queue scheduling algorithm in a symmetric multiprocessing operating system. Each item in the queue has a tag indicating its kin processor. At the time of resource allocation, each task is allocated to its kin processor in preference to others.

On most operating systems, the set of processors a process or thread is allowed (or preferred) to run on is expressed as an affinity mask, which is a bit mask corresponding to the system's cores.[1]

## Contents

* 1 Purpose
* 1.1 Locality of cache and memory
* 1.2 Division of resources
* 2 Specific operating systems
* 2.1 Unix-like
* 2.1.1 macOS
* 2.2 Windows NT
* 3 See also
* 4 References
* 5 External links

## Purpose

There are several reasons for processor affinity to be used.

### Locality of cache and memory

The execution of a thread may be interrupted by the OS scheduler to make space for other programs or threads during an interrupt. If the thread was later dispatched to the processor it was previously running on, there may be some remaining data in the CPU cache that can be reused, allowing for fewer cache misses. Setting the processor affinity would make sure the thread always runs on the same processor(s), but at the same time forces it to wait for the processor(s) to become available again. This feature is especially useful for CPU-intensive processes with few interrupts. Doing the same to an ordinary program might instead slow it down as they tend to be interrupted more frequently and end up waiting more.[2] A practical example of processor affinity is executing multiple instances of a single-threaded application, such as some graphics-rendering software. On CPUs with simultaneous multi-threading (SMT, also loosely known as hyper-threading, a genericized trademark of Intel), the two or more "threads" (logical processors, "virtual cores") on a physical core share the L1 and L2 caches. As far as affinity for locality purposes is concerned, they are identical.[3]

On non-uniform memory access (NUMA) systems a similar problem exists, except the latency comes not from L1/L2 cache misses, but from L3 misses and cross-node memory access. Constraining all threads of a program to the same NUMA node (or at least the same CPU socket) would ensure they can share their L3 caches. Additional configuration may be necessary to ensure that memory is allocated from the local NUMA node.[4]

### Division of resources

Processor affinity also enforces a static division of processing resources. As a result, it can be used to limit the amount of CPU cores used by a CPU-intensive process, leaving other cores available for the other programs to use. This is, of course, not optimal, as it would leave resources completely unused when there are no other programs running as well as still allow other programs to compete with the CPU-intensive program for resources on the few cores it's allowed to run on. More advanced methods to divide resources include CPU priority settings, CPU utilization shares, and hard utilization percentage limits.[5][3]

Again on CPUs with SMT, non-SMT-aware schedulers might make the mistake of scheduling work on a non-busy core with a busy partner when non-busy physical cores are present. This would cause unnecessary competition for resources between the two threads. As a result, multithreaded CPU-intensive programs often manually assign the affinity of its threads to make sure they do not end fighting over the same physical core.[6]

## Specific operating systems

### Unix-like

On Linux, the CPU affinity of a process can be altered with the taskset(1) program[7] and the sched_setaffinity(2) system call. The affinity of a thread can be altered with one of the library functions: `pthread_setaffinity_np`(3) or `pthread_attr_setaffinity_np`(3).

On SGI systems, dplace binds a process to a set of CPUs.[8]

On NetBSD 5.0, FreeBSD 7.2, DragonFly BSD 4.7 and later versions can use `pthread_setaffinity_np` and `pthread_getaffinity_np`.[9] In NetBSD, the psrset utility[10] to set a thread's affinity to a certain CPU set. In FreeBSD, cpuset[11] utility is used to create CPU sets and to assign processes to these sets.

On DragonFly BSD 1.9 (2007) and later versions, `usched_set` system call can be used to control the affinity of a process.[12][13] In DragonFly BSD 3.1 (2012) and later, usched utility can be used for assigning processes to a certain CPU set.[14]

On Solaris it is possible to control bindings of processes and LWPs to processor using the pbind(1)[15] program. To control the affinity programmatically processor_bind(2)[16] can be used. There are more generic interfaces available such as pset_bind(2)[17] or lgrp_affinity_get(3LGRP)[18] using processor set and locality groups concepts.

On AIX it is possible to control bindings of processes using the bindprocessor command[19][20] and the bindprocessor() API.[19][21] The AIX scheduler is SMT-aware and is able to switch the SMT states of the POWER7/8/9 cores from 1 to 8 threads to maximize throughput.[22]

#### macOS

macOS does not offer an API that manages the set of processors a process, task, or thread is allowed to run on. Instead it offers the Thread Affinity API, which tells the kernel which threads should be scheduled to share the same L2 cache, i.e. run on the same physical CPU core.[23] The XNU kernel internally translates each affinity tag to a set of allowed logical cores corresponding to a physical core. When a tag is set, it creates a Thread Affinity namespace when there is not one already. It then becomes bound to the core with the fewest tags already bound. A tag do not migrate between cores in XNU version 8792; as a result, so long as there are not more tags than there are physical cores, each tag will correspond to exactly one physical core. Namespaces as well as tags are inherited between parent and child processes.[24]

The API is not available on arm64 (Apple Silicon), where `ml_get_max_affinity_sets` is hardcoded to return 0.[25]

### Windows NT

On Windows NT and its successors, thread and process CPU affinities can be set separately by using SetThreadAffinityMask[26] and SetProcessAffinityMask[27] API calls or via the Task Manager interface (for process affinity only).

Forcing of each OpenMP thread to distinct logical cores in Windows can be accomplished by means of the following C code:

#include <windows.h>
#include <omp.h>
// Set OpenMP thread affinity
void set_thread_affinity () {
#pragma omp parallel default(shared)

DWORD_PTR mask = (DWORD_PTR )1 << omp_get_thread_num();
SetThreadAffinityMask(GetCurrentThread(), mask);

## See also

* hwloc

## References

1. ↑ "SetThreadAffinityMask function (winbase.h) - Win32 apps" (in en-us). January 27, 2022. https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-setthreadaffinitymask.
2. ↑ "Processor affinity and binding". https://www.ibm.com/docs/en/aix/7.2?topic=architecture-processor-affinity-binding.
3. ↑ 3.0 3.1 "White Paper - Processor Affinity" \- From tmurgent.com. Accessed 2007-07-06.
4. ↑ "Chapter 27. Configuring CPU Affinity and NUMA policies using systemd". https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/managing_monitoring_and_updating_the_kernel/assembly_configuring-cpu-affinity-and-numa-policies-using-systemd_managing-monitoring-and-updating-the-kernel.
5. ↑ "Chapter 24. Using cgroups-v2 to control distribution of CPU time for applications | Managing, monitoring, and updating the kernel | Red Hat Enterprise Linux | 8 | Red Hat Documentation". https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/8/html/managing_monitoring_and_updating_the_kernel/using-cgroups-v2-to-control-distribution-of-cpu-time-for-applications_managing-monitoring-and-updating-the-kernel.
6. ↑ "Thread Affinity Interface" (in en). https://www.intel.com/content/www/us/en/docs/dpcpp-cpp-compiler/developer-guide-reference/2023-0/thread-affinity-interface.html.
7. ↑ `taskset(1)` – Linux User's Manual – User Commands
8. ↑ dplace.1 \- From sgi.com. Accessed 2007-07-06.
9. ↑ `pthread_setaffinity_np(3)` – NetBSD, FreeBSD and DragonFly BSD Library Functions Manual
10. ↑ `psrset(8)` – NetBSD System Manager's Manual
11. ↑ `cpuset(1)` – FreeBSD General Commands Manual
12. ↑ "`usched_set(2)` — setting up a proc's usched". DragonFly System Calls Manual. DragonFly BSD. http://mdoc.su/d/usched_set.2.
13. ↑ "`kern/kern_usched.c § sys_usched_set`". DragonFly BSD. http://bxr.su/d/sys/kern/kern_usched.c#sys_usched_set.
14. ↑ "`usched(8)` — run a program with a specified userland scheduler and cpumask". DragonFly System Manager's Manual. DragonFly BSD. http://mdoc.su/d/usched.8.
15. ↑ pbind(1M) \- Solaris man page
16. ↑ processor_bind(2) \- Solaris man page
17. ↑ pset_bind(2) \- Oracle Solaris 11.1 Information Library - man pages section 2
18. ↑ lgrp_affinity_get(3LGRP) \- Memory and Thread Placement Optimization Developer's Guide
19. ↑ 19.0 19.1 "Processor affinity on AIX". November 16, 2006. https://www.ibm.com/developerworks/aix/library/au-processinfinity.html.
20. ↑ "bindprocessor Command". https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/b_commands/bindprocessor.html.
21. ↑ "bindprocessor Subroutine". https://www.ibm.com/support/knowledgecenter/en/ssw_aix_72/b_bostechref/bindprocessor.html.
22. ↑ "POWER CPU Memory Affinity 3 - Scheduling processes to SMT and Virtual Processors" (in en). 13 June 2023. https://www.ibm.com/support/pages/power-cpu-memory-affinity-3-scheduling-processes-smt-and-virtual-processors.
23. ↑ "Thread Affinity API Release Notes". https://developer.apple.com/library/mac/#releasenotes/Performance/RN-AffinityAPI/index.html.
24. ↑ "xnu/osfmk/kern/affinity.c at e3723e1f17661b24996789d8afc084c0c3303b26 · apple-oss-distributions/xnu" (in en). https://github.com/apple-oss-distributions/xnu/blob/e3723e1f17661b24996789d8afc084c0c3303b26/osfmk/kern/affinity.c.
25. ↑ XNU source code: xnu/osfmk/arm/cpu_affinity.h
26. ↑ SetThreadAffinityMask \- MSDN Library
27. ↑ SetProcessAffinityMask \- MSDN Library

## External links

* MSDN article on SetThreadAffinityMask function
* Taskset, a tool to set the affinity mask on Linux
* CPU Balancer, a free, open-source utility that distributes Windows XP processes uniformly over logical processors using the affinity mask

Template:Processor scheduling

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Processor affinity. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Processor_affinity&oldid=3956707"