1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * sched-domains (multiprocessor balancing) flag declarations.
4  */
5 
6 #ifndef SD_FLAG
7 # error "Incorrect import of SD flags definitions"
8 #endif
9 
10 /*
11  * Hierarchical metaflags
12  *
13  * SHARED_CHILD: These flags are meant to be set from the base domain upwards.
14  * If a domain has this flag set, all of its children should have it set. This
15  * is usually because the flag describes some shared resource (all CPUs in that
16  * domain share the same resource), or because they are tied to a scheduling
17  * behaviour that we want to disable at some point in the hierarchy for
18  * scalability reasons.
19  *
20  * In those cases it doesn't make sense to have the flag set for a domain but
21  * not have it in (some of) its children: sched domains ALWAYS span their child
22  * domains, so operations done with parent domains will cover CPUs in the lower
23  * child domains.
24  *
25  *
26  * SHARED_PARENT: These flags are meant to be set from the highest domain
27  * downwards. If a domain has this flag set, all of its parents should have it
28  * set. This is usually for topology properties that start to appear above a
29  * certain level (e.g. domain starts spanning CPUs outside of the base CPU's
30  * socket).
31  */
32 #define SDF_SHARED_CHILD       0x1
33 #define SDF_SHARED_PARENT      0x2
34 
35 /*
36  * Behavioural metaflags
37  *
38  * NEEDS_GROUPS: These flags are only relevant if the domain they are set on has
39  * more than one group. This is usually for balancing flags (load balancing
40  * involves equalizing a metric between groups), or for flags describing some
41  * shared resource (which would be shared between groups).
42  */
43 #define SDF_NEEDS_GROUPS       0x4
44 
45 /*
46  * Balance when about to become idle
47  *
48  * SHARED_CHILD: Set from the base domain up to cpuset.sched_relax_domain_level.
49  * NEEDS_GROUPS: Load balancing flag.
50  */
51 SD_FLAG(SD_BALANCE_NEWIDLE, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
52 
53 /*
54  * Balance on exec
55  *
56  * SHARED_CHILD: Set from the base domain up to the NUMA reclaim level.
57  * NEEDS_GROUPS: Load balancing flag.
58  */
59 SD_FLAG(SD_BALANCE_EXEC, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
60 
61 /*
62  * Balance on fork, clone
63  *
64  * SHARED_CHILD: Set from the base domain up to the NUMA reclaim level.
65  * NEEDS_GROUPS: Load balancing flag.
66  */
67 SD_FLAG(SD_BALANCE_FORK, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
68 
69 /*
70  * Balance on wakeup
71  *
72  * SHARED_CHILD: Set from the base domain up to cpuset.sched_relax_domain_level.
73  * NEEDS_GROUPS: Load balancing flag.
74  */
75 SD_FLAG(SD_BALANCE_WAKE, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
76 
77 /*
78  * Consider waking task on waking CPU.
79  *
80  * SHARED_CHILD: Set from the base domain up to the NUMA reclaim level.
81  */
82 SD_FLAG(SD_WAKE_AFFINE, SDF_SHARED_CHILD)
83 
84 /*
85  * Domain members have different CPU capacities
86  *
87  * SHARED_PARENT: Set from the topmost domain down to the first domain where
88  *                asymmetry is detected.
89  * NEEDS_GROUPS: Per-CPU capacity is asymmetric between groups.
90  */
91 SD_FLAG(SD_ASYM_CPUCAPACITY, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)
92 
93 /*
94  * Domain members have different CPU capacities spanning all unique CPU
95  * capacity values.
96  *
97  * SHARED_PARENT: Set from the topmost domain down to the first domain where
98  *		  all available CPU capacities are visible
99  * NEEDS_GROUPS: Per-CPU capacity is asymmetric between groups.
100  */
101 SD_FLAG(SD_ASYM_CPUCAPACITY_FULL, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)
102 
103 /*
104  * Domain members share CPU capacity (i.e. SMT)
105  *
106  * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share
107  *               CPU capacity.
108  * NEEDS_GROUPS: Capacity is shared between groups.
109  */
110 SD_FLAG(SD_SHARE_CPUCAPACITY, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
111 
112 /*
113  * Domain members share CPU package resources (i.e. caches)
114  *
115  * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share
116  *               the same cache(s).
117  * NEEDS_GROUPS: Caches are shared between groups.
118  */
119 SD_FLAG(SD_SHARE_PKG_RESOURCES, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
120 
121 /*
122  * Only a single load balancing instance
123  *
124  * SHARED_PARENT: Set for all NUMA levels above NODE. Could be set from a
125  *                different level upwards, but it doesn't change that if a
126  *                domain has this flag set, then all of its parents need to have
127  *                it too (otherwise the serialization doesn't make sense).
128  * NEEDS_GROUPS: No point in preserving domain if it has a single group.
129  */
130 SD_FLAG(SD_SERIALIZE, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)
131 
132 /*
133  * Place busy tasks earlier in the domain
134  *
135  * NEEDS_GROUPS: Load balancing flag.
136  */
137 SD_FLAG(SD_ASYM_PACKING, SDF_NEEDS_GROUPS)
138 
139 /*
140  * Prefer to place tasks in a sibling domain
141  *
142  * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD
143  * flag, but cleared below domains with SD_ASYM_CPUCAPACITY.
144  *
145  * NEEDS_GROUPS: Load balancing flag.
146  */
147 SD_FLAG(SD_PREFER_SIBLING, SDF_NEEDS_GROUPS)
148 
149 /*
150  * sched_groups of this level overlap
151  *
152  * SHARED_PARENT: Set for all NUMA levels above NODE.
153  * NEEDS_GROUPS: Overlaps can only exist with more than one group.
154  */
155 SD_FLAG(SD_OVERLAP, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)
156 
157 /*
158  * Cross-node balancing
159  *
160  * SHARED_PARENT: Set for all NUMA levels above NODE.
161  * NEEDS_GROUPS: No point in preserving domain if it has a single group.
162  */
163 SD_FLAG(SD_NUMA, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)
164