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 cluster (LLC tags or L2 cache) 114 * 115 * NEEDS_GROUPS: Clusters are shared between groups. 116 */ 117 SD_FLAG(SD_CLUSTER, SDF_NEEDS_GROUPS) 118 119 /* 120 * Domain members share CPU package resources (i.e. 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 */ 126 SD_FLAG(SD_SHARE_PKG_RESOURCES, 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 */ 137 SD_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 */ 144 SD_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 */ 154 SD_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 */ 162 SD_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 */ 170 SD_FLAG(SD_NUMA, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS) 171