numa.rst 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150
  1. .. _numa:
  2. Started Nov 1999 by Kanoj Sarcar <kanoj@sgi.com>
  3. =============
  4. What is NUMA?
  5. =============
  6. This question can be answered from a couple of perspectives: the
  7. hardware view and the Linux software view.
  8. From the hardware perspective, a NUMA system is a computer platform that
  9. comprises multiple components or assemblies each of which may contain 0
  10. or more CPUs, local memory, and/or IO buses. For brevity and to
  11. disambiguate the hardware view of these physical components/assemblies
  12. from the software abstraction thereof, we'll call the components/assemblies
  13. 'cells' in this document.
  14. Each of the 'cells' may be viewed as an SMP [symmetric multi-processor] subset
  15. of the system--although some components necessary for a stand-alone SMP system
  16. may not be populated on any given cell. The cells of the NUMA system are
  17. connected together with some sort of system interconnect--e.g., a crossbar or
  18. point-to-point link are common types of NUMA system interconnects. Both of
  19. these types of interconnects can be aggregated to create NUMA platforms with
  20. cells at multiple distances from other cells.
  21. For Linux, the NUMA platforms of interest are primarily what is known as Cache
  22. Coherent NUMA or ccNUMA systems. With ccNUMA systems, all memory is visible
  23. to and accessible from any CPU attached to any cell and cache coherency
  24. is handled in hardware by the processor caches and/or the system interconnect.
  25. Memory access time and effective memory bandwidth varies depending on how far
  26. away the cell containing the CPU or IO bus making the memory access is from the
  27. cell containing the target memory. For example, access to memory by CPUs
  28. attached to the same cell will experience faster access times and higher
  29. bandwidths than accesses to memory on other, remote cells. NUMA platforms
  30. can have cells at multiple remote distances from any given cell.
  31. Platform vendors don't build NUMA systems just to make software developers'
  32. lives interesting. Rather, this architecture is a means to provide scalable
  33. memory bandwidth. However, to achieve scalable memory bandwidth, system and
  34. application software must arrange for a large majority of the memory references
  35. [cache misses] to be to "local" memory--memory on the same cell, if any--or
  36. to the closest cell with memory.
  37. This leads to the Linux software view of a NUMA system:
  38. Linux divides the system's hardware resources into multiple software
  39. abstractions called "nodes". Linux maps the nodes onto the physical cells
  40. of the hardware platform, abstracting away some of the details for some
  41. architectures. As with physical cells, software nodes may contain 0 or more
  42. CPUs, memory and/or IO buses. And, again, memory accesses to memory on
  43. "closer" nodes--nodes that map to closer cells--will generally experience
  44. faster access times and higher effective bandwidth than accesses to more
  45. remote cells.
  46. For some architectures, such as x86, Linux will "hide" any node representing a
  47. physical cell that has no memory attached, and reassign any CPUs attached to
  48. that cell to a node representing a cell that does have memory. Thus, on
  49. these architectures, one cannot assume that all CPUs that Linux associates with
  50. a given node will see the same local memory access times and bandwidth.
  51. In addition, for some architectures, again x86 is an example, Linux supports
  52. the emulation of additional nodes. For NUMA emulation, linux will carve up
  53. the existing nodes--or the system memory for non-NUMA platforms--into multiple
  54. nodes. Each emulated node will manage a fraction of the underlying cells'
  55. physical memory. NUMA emluation is useful for testing NUMA kernel and
  56. application features on non-NUMA platforms, and as a sort of memory resource
  57. management mechanism when used together with cpusets.
  58. [see Documentation/admin-guide/cgroup-v1/cpusets.rst]
  59. For each node with memory, Linux constructs an independent memory management
  60. subsystem, complete with its own free page lists, in-use page lists, usage
  61. statistics and locks to mediate access. In addition, Linux constructs for
  62. each memory zone [one or more of DMA, DMA32, NORMAL, HIGH_MEMORY, MOVABLE],
  63. an ordered "zonelist". A zonelist specifies the zones/nodes to visit when a
  64. selected zone/node cannot satisfy the allocation request. This situation,
  65. when a zone has no available memory to satisfy a request, is called
  66. "overflow" or "fallback".
  67. Because some nodes contain multiple zones containing different types of
  68. memory, Linux must decide whether to order the zonelists such that allocations
  69. fall back to the same zone type on a different node, or to a different zone
  70. type on the same node. This is an important consideration because some zones,
  71. such as DMA or DMA32, represent relatively scarce resources. Linux chooses
  72. a default Node ordered zonelist. This means it tries to fallback to other zones
  73. from the same node before using remote nodes which are ordered by NUMA distance.
  74. By default, Linux will attempt to satisfy memory allocation requests from the
  75. node to which the CPU that executes the request is assigned. Specifically,
  76. Linux will attempt to allocate from the first node in the appropriate zonelist
  77. for the node where the request originates. This is called "local allocation."
  78. If the "local" node cannot satisfy the request, the kernel will examine other
  79. nodes' zones in the selected zonelist looking for the first zone in the list
  80. that can satisfy the request.
  81. Local allocation will tend to keep subsequent access to the allocated memory
  82. "local" to the underlying physical resources and off the system interconnect--
  83. as long as the task on whose behalf the kernel allocated some memory does not
  84. later migrate away from that memory. The Linux scheduler is aware of the
  85. NUMA topology of the platform--embodied in the "scheduling domains" data
  86. structures [see Documentation/scheduler/sched-domains.rst]--and the scheduler
  87. attempts to minimize task migration to distant scheduling domains. However,
  88. the scheduler does not take a task's NUMA footprint into account directly.
  89. Thus, under sufficient imbalance, tasks can migrate between nodes, remote
  90. from their initial node and kernel data structures.
  91. System administrators and application designers can restrict a task's migration
  92. to improve NUMA locality using various CPU affinity command line interfaces,
  93. such as taskset(1) and numactl(1), and program interfaces such as
  94. sched_setaffinity(2). Further, one can modify the kernel's default local
  95. allocation behavior using Linux NUMA memory policy. [see
  96. :ref:`Documentation/admin-guide/mm/numa_memory_policy.rst <numa_memory_policy>`].
  97. System administrators can restrict the CPUs and nodes' memories that a non-
  98. privileged user can specify in the scheduling or NUMA commands and functions
  99. using control groups and CPUsets. [see Documentation/admin-guide/cgroup-v1/cpusets.rst]
  100. On architectures that do not hide memoryless nodes, Linux will include only
  101. zones [nodes] with memory in the zonelists. This means that for a memoryless
  102. node the "local memory node"--the node of the first zone in CPU's node's
  103. zonelist--will not be the node itself. Rather, it will be the node that the
  104. kernel selected as the nearest node with memory when it built the zonelists.
  105. So, default, local allocations will succeed with the kernel supplying the
  106. closest available memory. This is a consequence of the same mechanism that
  107. allows such allocations to fallback to other nearby nodes when a node that
  108. does contain memory overflows.
  109. Some kernel allocations do not want or cannot tolerate this allocation fallback
  110. behavior. Rather they want to be sure they get memory from the specified node
  111. or get notified that the node has no free memory. This is usually the case when
  112. a subsystem allocates per CPU memory resources, for example.
  113. A typical model for making such an allocation is to obtain the node id of the
  114. node to which the "current CPU" is attached using one of the kernel's
  115. numa_node_id() or CPU_to_node() functions and then request memory from only
  116. the node id returned. When such an allocation fails, the requesting subsystem
  117. may revert to its own fallback path. The slab kernel memory allocator is an
  118. example of this. Or, the subsystem may choose to disable or not to enable
  119. itself on allocation failure. The kernel profiling subsystem is an example of
  120. this.
  121. If the architecture supports--does not hide--memoryless nodes, then CPUs
  122. attached to memoryless nodes would always incur the fallback path overhead
  123. or some subsystems would fail to initialize if they attempted to allocated
  124. memory exclusively from a node without memory. To support such
  125. architectures transparently, kernel subsystems can use the numa_mem_id()
  126. or cpu_to_mem() function to locate the "local memory node" for the calling or
  127. specified CPU. Again, this is the same node from which default, local page
  128. allocations will be attempted.