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 * sched_groups of this level overlap 158 * 159 * SHARED_PARENT: Set for all NUMA levels above NODE. 160 * NEEDS_GROUPS: Overlaps can only exist with more than one group. 161 */ 162SD_FLAG(SD_OVERLAP, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS) 163 164/* 165 * Cross-node balancing 166 * 167 * SHARED_PARENT: Set for all NUMA levels above NODE. 168 * NEEDS_GROUPS: No point in preserving domain if it has a single group. 169 */ 170SD_FLAG(SD_NUMA, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS) 171