2. Automatic NUMA Balancing Agenda
â˘What is NUMA, anyway?
â˘Automatic NUMA balancing internals
â˘Automatic NUMA balancing performance
â˘What workloads benefit from manual NUMA tuning
â˘Future developments
â˘Conclusions
4. What is NUMA, anyway?
â˘Non Uniform Memory Access
â˘Multiple physical CPUs in a system
â˘Each CPU has memory attached to it
â˘Local memory, fast
â˘Each CPU can access other CPU's memory, too
â˘Remote memory, slower
5. NUMA terminology
â˘Node
â˘A physical CPU and attached memory
â˘Could be multiple CPUs (with off-chip memory controller)
â˘Interconnect
â˘Bus connecting the various nodes together
â˘Generally faster than memory bandwidth of a single node
â˘Can get overwhelmed by traffic from many nodes
8. NUMA performance considerations
â˘NUMA performance penalties from two main sources
â˘Higher latency of accessing remote memory
â˘Interconnect contention
â˘Processor threads and cores share resources
â˘Execution units (between HT threads)
â˘Cache (between threads and cores)
9. Automatic NUMA balancing strategies
â˘CPU follows memory
â˘Try running tasks where their memory is
â˘Memory follows CPU
â˘Move memory to where it is accessed
â˘Both strategies are used by automatic NUMA balancing
â˘Various mechanisms involved
â˘Lots of interesting corner cases...
12. NUMA hinting page faults
â˘Periodically, each task's memory is unmapped
â˘Period based on run time, and NUMA locality
â˘Unmapped âa little bitâ at a time (chunks of 256MB)
â˘Page table set to âno access permissionâ marked as NUMA pte
â˘Page faults generated as task tries to access memory
â˘Used to track the location of memory a task uses
⢠Task may also have unused memory âjust sitting aroundâ
â˘NUMA faults also drive NUMA page migration
13. NUMA page migration
â˘NUMA page faults are relatively cheap
â˘Page migration is much more expensive
â˘... but so is having task memory on the âwrong nodeâ
â˘Quadratic filter: only migrate if page is accessed twice
â˘From same NUMA node, or
â˘By the same task
â˘CPU number & low bits of pid in page struct
â˘Page is migrated to where the task is running
14. Fault statistics
â˘Fault statistics are used to place tasks (cpu-follows-memory)
â˘Statistics kept per task, and per numa_group
â˘âWhere is the memory this task (or group) is accessing?â
â˘âNUMA page faultsâ counter per NUMA node
â˘After a NUMA fault, account the page location
⢠If the page was migrated, account the new location
â˘Kept as a floating average
15. Types of NUMA faults
â˘Locality
â˘âLocal faultâ - memory on same node as CPU
â˘âRemote faultâ - memory on different node than CPU
â˘Private vs shared
â˘âPrivate faultâ - memory accessed by same task twice in a row
â˘âShared faultâ - memory accessed by different task than last time
18. Task placement
â˘Best place to run a task
â˘Where most of its memory accesses happen
â˘It is not that simple
â˘Tasks may share memory
⢠Some private accesses, some shared accesses
⢠60% private, 40% shared is possible â group tasks together for best performance
â˘Tasks with memory on the node may have more threads than can run in
one node's CPU cores
â˘Load balancer may have spread threads across more physical CPUs
⢠Take advantage of more CPU cache
19. Task placement constraints
â˘NUMA task placement may not create a load imbalance
â˘The load balancer would move something else
â˘Conflict can lead to tasks âbouncing around the systemâ
⢠Bad locality
⢠Lots of NUMA page migrations
â˘NUMA task placement may
â˘Swap tasks between nodes
â˘Move a task to an idle CPU if no imbalance is created
20. Task placement algorithm
â˘For task A, check each NUMA node N
â˘Check whether node N is better than task A's current node (C)
⢠Task A has a larger fraction of memory accesses on node N, than on current node C
⢠Score is the difference of fractions
â˘If so, check all CPUs on node N
⢠Is the current task (T) on CPU better off on node C?
⢠Is the CPU idle, and can we move task A to the CPU?
⢠Is the benefit of moving task A to node N larger than the downside of moving task T
to node C?
â˘For the CPU with the best score, move task A (and task T, to node C).
21. Task placement examples
NODE CPU TASK
0 0 A
0 1 T
1 2 (idle)
1 3 (idle)
Fault
statistics
TASK A TASK T
NODE 0 30% (*) 60% (*)
NODE 1 70% 40%
â˘Moving task A to node 1: 40% improvement
â˘Moving a task to node 1 removes a load imbalance
â˘Moving task A to an idle CPU on node 1 is desirable
22. Task placement examples
NODE CPU TASK
0 0 A
0 1 (idle)
1 2 T
1 3 (idle)
Fault
statistics
TASK A TASK T
NODE 0 30% (*) 60%
NODE 1 70% 40% (*)
â˘Moving task A to node 1: 40% improvement
â˘Moving task T to node 0: 20% improvement
â˘Swapping tasks A & T is desirable
23. Task placement examples
NODE CPU TASK
0 0 A
0 1 (idle)
1 2 T
1 3 (idle)
Fault
statistics
TASK A TASK T
NODE 0 30% (*) 40%
NODE 1 70% 60% (*)
â˘Moving task A to node 1: 40% improvement
â˘Moving task T to node 0: 20% worse
â˘Swapping tasks A & T: overall a 20% improvement, do it
24. Task placement examples
NODE CPU TASK
0 0 A
0 1 (idle)
1 2 T
1 3 (idle)
Fault
statistics
TASK A TASK T
NODE 0 30% (*) 20%
NODE 1 70% 80% (*)
â˘Moving task A to node 1: 40% improvement
â˘Moving task T to node 0: 60% worse
â˘Swapping tasks A & T: overall 20% worse, leave things alone
25. Task grouping
â˘Multiple tasks can access the same memory
â˘Threads in a large multi-threaded process (JVM, virtual machine, ...)
â˘Processes using shared memory segment (eg. Database)
â˘Use CPU num & pid in struct page to detect shared memory
â˘At NUMA fault time, check CPU where page was last faulted
â˘Group tasks together in numa_group, if PID matches
â˘Grouping related tasks improves NUMA task placement
â˘Only group truly related tasks
â˘Only group on write faults, ignore shared libraries like libc.so
26. Task grouping & task placement
â˘Group stats are the sum of the NUMA fault stats for tasks in group
â˘Task placement code similar to before
â˘If a task belongs to a numa_group, use the numa_group stats for
comparison instead of the task stats
â˘Pulls groups together, for more efficient access to shared memory
â˘When both compared tasks belong to the same numa_group
â˘Use task stats, since group numbers are the same
â˘Efficient placement of tasks within a group
29. Pseudo-interleaving
â˘Sometimes one workload spans multiple nodes
â˘More threads running than one node has CPU cores
â˘Spread out by the load balancer
â˘Goals
â˘Maximize memory bandwidth available to workload
â˘Keep private memory local to tasks using it
â˘Minimize number of page migrations
30. Pseudo-interleaving problem
Tasks
Node 0 Node 1
â˘Most memory on node 0, sub-optimal use of memory bandwidth
â˘How to fix? Spread out the memory more evenly...
31. Pseudo-interleaving algorithm
â˘Determine nodes where workload is actively running
â˘CPU time used & NUMA faults
â˘Always allow private faults (same task) to migrate pages
â˘Allow shared faults to migrate pages only from a more heavily
used node, to a less heavily used node
â˘Block NUMA page migration on shared faults from one node to
another node that is equally or more heavily used
35. Evaluation of Automatic NUMA balancing â Status update
⢠Goal : Study the impact on out-of-box performance with different workloads on
bare-metal & KVM guests.
⢠Workloads being used*:
⢠2 Java workloads
⢠SPECjbb2005 used as a workload
⢠Multi-JVM server workload
⢠Database
⢠A synthetic DSS workload (using tmpfs)
⢠Other DB workloads (with I/O) are in the pipeline...
* Note: These sample workloads are being used for relative performance comparisons. This is not an official benchmarking exercise!
36. Experiments with bare-metal
⢠Platforms used :
⢠4-socket Ivy Bridge EX server
⢠8-socket Ivy Bridge EX prototype server.
⢠Misc. settings:
⢠Hyper-threading off, THP enabled & cstates set to 1 (i.e. intel_idle.max_cstate=1 processor.max_cstate=1)
⢠Configurations :
⢠Baseline :
⢠No manual pinning of the workload
⢠No Automatic NUMA balancing
⢠Pinned :
⢠Manual (numactl) pinning of the workload
⢠Automatic NUMA balancing :
⢠No manual pinning of the workload.
37. SPECjbb2005 - bare-metal
(4-socket IVY-EX server vs. 8-socket IVY-EX prototype server)
4-1s wide 2-2s wide 1-4s wide
baseline
pinned
Automatic NUMA bal.
# of instances - socket width of each instance
Averageoperationspersecond
8-1s wide 4-2s wide 2-4s wide 1-8s wide
baseline
pinned
Automatic NUMA bal.
# instances - socket width of each instance
Averageoperationspersecond
Delta between Automatic NUMA balancing case &
the Pinned case was as high as ~20+%
Automatic NUMA balancing case &
the Pinned case were pretty close (+/- 4%).
1s wide = 15 warehouse threads, 2s wide = 30 warehouse threads; 4s wide = 60 warehouse threads, 8s wide = 120 warehouse threads
38. Remote vs. local memory access (RMA/LMA samples)*
(Workload : Multiple 1 socket-wide instances of SPECjbb2005)
4-socket IVY-EX server 8-socket IVY-EX prototype server
Baseline Baseline
Pinned
Pinned
Pinned
Automatic NUMA balancing
Automatic NUMA balancing
* Courtesy numatop v1.0.2 Higher RMA/LMA
39. Multi-JVM server workload â bare-metal
(4-socket IVY-EX server vs. 8-socket IVY-EX prototype server)
1 group/1socket 2 groups/2sockets 4 groups/4sockets
baseline - max OPS
pinned - max-OPS
Automatic NUMA bal - max-OPS
baseline - critical OPS
pinned - critical OPS
Automatic NUMA bal. - critical OPS
# of groups/# of sockets
#ofoperationspersecond
1 group/1socket 2 groups/2sockets 4 groups/4sockets 8 groups/8sockets
baseline - max OPS
pinned - max OPS
Automatic NUMA bal. - max OPS
baseline - critical OPS
pinned - critical OPS
Automatic NUMA bal. - critical OPS
# of groups/# of sockets
#ofoperationspersecond
Entities within each of the multiple Groups communicate with a Controller (using IPC) within the same host &
the frequency of communication increases as the # of Groups increase
Two key metrics : Max throughput (max-OPS) with no constraints & Critical throughput (critical-OPS) under fixed SLA constraints
Some workloads will still need manual pinning !
40. Database workload - bare-metal
(4-socket IVY-EX server)
100 users 200 users 300 users 400 users
Synthetic DSS workload (using tmpfs)
10GB Database size
Automatic NUMA bal.
100 users 200 users 300 users 400 users
# of users
Avg.#oftransactionspersecond
Static 2M huge pages used for SGA
~9-18% improvement in Average transactions per second with Automatic NUMA balancing
41. KVM guests
⢠Size of the guests continue to increase
⢠Use cases include classic enterprise scale-up guests & guests in private cloud environments.
⢠[Manual] pinning/tuning of individual guests using libvirt/virsh (after taking into account host's NUMA
topology) are required to achieve low overhead & predictable performance for workloads running in
mid/large sized guests. This is especially true on larger scale-up hosts (e.g. >= 4 socket servers)
⢠⌠but, its harder to live migrate such pinned guest across hosts â as similar set of backing resources may
not be available on the target host (or) the target host may have a different NUMA topology !
<cputune>
<vcpupin vcpu='0' cpuset='0'/>
<vcpupin vcpu='1' cpuset='1'/>
<vcpupin vcpu='2' cpuset='2'/>
<vcpupin vcpu='3' cpuset='3'/>
âŚ
âŚ
âŚ
<vcpupin vcpu='29'
cpuset='29'/>
</cputune>
<numatune>
<memory mode='preferred' nodeset='0-1'/>
</numatune>
42. KVM guests (contd.)
⢠Automatic NUMA balancing could help avoid the need for having to manually pin the guest resources
⢠Exceptions include cases where a guest's backing memory pages on the host can't be migrated :
⢠Guests relying on hugetlbfs (instead of THPs)
⢠Guests with direct device assignment (get_user_pages())
⢠Guests with real time needs (mlock_all()).
⢠As the guest size spans more than 1 socket it is highly recommended to enable Virtual NUMA nodes in
the guest => helps the guest OS instance to scale/perform.
⢠Virtual NUMA nodes in the guest OS => Automatic NUMA balancing enabled in the guest OS instance.
⢠Users can still choose to pin the workload to these Virtual NUMA nodes, if it helps their use case.
<cpu>
<topology sockets='2' cores='15' threads='1'/>
<numa>
<cell cpus='0-14' memory='134217728'/>
<cell cpus='15-29' memory='134217728'/>
</numa>
</cpu>
43. Experiments with KVM guests
⢠Platform used : 4-socket Ivy Bridge EX server
⢠Guest sizes:
⢠1s-wide guest â 15VCPUs/128GB
⢠2s-wide guest â 30VCPUs/256GB (2 virtual NUMA nodes)
⢠4s-wide guest â 60VCPUs/512GB (4 virtual NUMA nodes)
⢠Configurations tested: (different possible permutations, but we chose to focus on the following three)
⢠Baseline guest (=> a typical public/private cloud guest today)
⢠No pinning of VCPUs or memory,
⢠No Virtual NUMA nodes enabled in the guest (even for >1s wide guest).
⢠No Automatic NUMA balancing in Host or Guest OS.
⢠Workload not pinned in the guest.
⢠Pinned guest (=> a typical enterprise scale-up guest today)
⢠VCPUs and memory pinned
⢠Virtual NUMA nodes enabled in the guest (for >1s wide guest),
⢠Workload is pinned in the guest (to the virtual NUMA nodes).
⢠Automatic NUMA bal. guest : (=> âout of boxâ for any type of guest)
⢠No manual pinning of VCPUs or memory,
⢠Virtual NUMA nodes enabled in the guest (for >1s wide guest),
⢠Automatic NUMA balancing in Host and Guest OS.
⢠Workload not pinned in the guest. [a user could choose to pin a workload to the virtual NUMA nodes...without tripping over live migration issues.]
44. SPECjbb2005 in KVM guests
(4 socket IVY-EX server)
4 guests/1s wide 2 guests/2s wide 1 guest/1s wide
baseline guest
pinned guest
Automatic NUMA balancing
#of guests / socket width of the guest
Averageoperationspersecond
Automatic NUMA balancing case &
the Pinned guest case were pretty close (+/- 3%).
45. Multi-JVM server workload â KVM guests
(4-socket IVY-EX server)
1 group / each of 4 - 1 socket-wide guests 2 groups /each of 2 - 2 socket wide guests 4 groups / 1 - 4 socket wide guest
Baseline guest -max OPS
pinned guest-max OPS
Automatic NUMA bal. guest - max OPS
Baseline guest - critical OPS
pinned guest - critical OPS
Automatic bal. guest - critical OPS
# of groups in each of the guests
Averageofmax/criticaloperationspersecond(OPS)
Delta between the Automatic NUMA
balancing guest case &
the Pinned case was much higher
(~14% max-OPS and ~24% of critical-OPS)
Pinning the workload to the virtual NUMA nodes does help
46. KVM â server consolidation example
(Two 2-socket wide (30VCPU/256GB) guests each running a different workload hosted on 4 Socket IVY-EX server)
100 200 400
Sythetic DSS workload (using tmpfs)
10GB Databse size
baseline guest
pinned guest
Automatic NUMA bal. guest
# of users
AverageTransactionspersecond
30 warehouses
SPECjbb2005
baseline guest
pinned guest
Automatic NUMA bal. guest
# of warehouse threads
OperationspersecondAutomatic NUMA balancing case & the Pinned case were pretty close (~ 1-2%).
48. NUMA balancing future considerations
â˘Complex NUMA topologies & pseudo-interleaving
â˘Unmovable memory
â˘KSM
â˘Interrupt locality
â˘Inter Process Communication
49. Complex NUMA topologies & pseudo-interleaving
â˘Differing distances between NUMA nodes
â˘Local node, nearby nodes, far away nodes
â˘Eg. 20% & 100% performance penalty for nearby vs. far away
â˘Workloads that are spread across multiple nodes work better
when those nodes are near each other
â˘Unclear how to implement this
â˘When is the second-best node no longer the second best?
50. NUMA balancing & unmovable memory
â˘Unmovable memory
â˘Mlock
â˘Hugetlbfs
â˘Pinning for KVM device assignment & RDMA
â˘Memory is not movable ...
â˘But the tasks are
â˘NUMA faults would help move the task near the memory
â˘Unclear if worthwhile, needs experimentation
51. KSM
â˘Kernel Samepage Merging
â˘De-duplicates identical content between KVM guests
â˘Also usable by other programs
â˘KSM has simple NUMA option
â˘âOnly merge between tasks on the same NUMA nodeâ
â˘Task can be moved after memory is merged
â˘May need NUMA faults on KSM pages, and re-locate memory if needed
â˘Unclear if worthwhile, needs experimentation
52. Interrupt locality
â˘Some tasks do a lot of IO
â˘Performance benefit to placing those tasks near the IO device
â˘Manual binding demonstrates that benefit
â˘Currently automatic NUMA balancing only does memory & CPU
â˘Would need to be enhanced to consider IRQ/device locality
â˘Unclear how to implement this
â˘When should IRQ affinity outweigh CPU/memory affinity?
53. Inter Process Communication
â˘Some tasks communicate a LOT with other tasks
â˘Benefit from NUMA placement near tasks they communicate with
â˘Do not necessarily share any memory
â˘Loopback TCP/UDP, named socket, pipe, ...
â˘Unclear how to implement this
â˘How to weigh against CPU/memory locality?
54. Conclusions
â˘NUMA systems are increasingly common
â˘Automatic NUMA balancing improves performance for many
workloads, on many kinds of systems
â˘Can often get within a few % of optimal manual tuning
â˘Manual tuning can still help with certain workloads
â˘Future improvements may expand the range of workloads and
systems where automatic NUMA placement works nearly optimal