sd_flags.h

  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 */
 51SD_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 */
 59SD_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 */
 67SD_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 */
 75SD_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 */
 82SD_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 */
 91SD_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 */
101SD_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 */
110SD_FLAG(SD_SHARE_CPUCAPACITY, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
111
112/*
113 * Domain members share CPU cluster (LLC tags or L2 cache)
114 *
115 * NEEDS_GROUPS: Clusters are shared between groups.
116 */
117SD_FLAG(SD_CLUSTER, SDF_NEEDS_GROUPS)
118
119/*
120 * Domain members share CPU Last Level Caches
121 *
122 * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share
123 *               the same cache(s).
124 * NEEDS_GROUPS: Caches are shared between groups.
125 */
126SD_FLAG(SD_SHARE_LLC, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)
127
128/*
129 * Only a single load balancing instance
130 *
131 * SHARED_PARENT: Set for all NUMA levels above NODE. Could be set from a
132 *                different level upwards, but it doesn't change that if a
133 *                domain has this flag set, then all of its parents need to have
134 *                it too (otherwise the serialization doesn't make sense).
135 * NEEDS_GROUPS: No point in preserving domain if it has a single group.
136 */
137SD_FLAG(SD_SERIALIZE, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)
138
139/*
140 * Place busy tasks earlier in the domain
141 *
142 * NEEDS_GROUPS: Load balancing flag.
143 */
144SD_FLAG(SD_ASYM_PACKING, SDF_NEEDS_GROUPS)
145
146/*
147 * Prefer to place tasks in a sibling domain
148 *
149 * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD
150 * flag, but cleared below domains with SD_ASYM_CPUCAPACITY.
151 *
152 * NEEDS_GROUPS: Load balancing flag.
153 */
154SD_FLAG(SD_PREFER_SIBLING, SDF_NEEDS_GROUPS)
155
156/*
157 * Cross-node balancing
158 *
159 * SHARED_PARENT: Set for all NUMA levels above NODE.
160 * NEEDS_GROUPS: No point in preserving domain if it has a single group.
161 */
162SD_FLAG(SD_NUMA, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)