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 * SHARED_CHILD: Usually set on the SMT level. Technically could be set further 136 * up, but currently assumed to be set from the base domain 137 * upwards (see update_top_cache_domain()). 138 * NEEDS_GROUPS: Load balancing flag. 139 */ 140 SD_FLAG(SD_ASYM_PACKING, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) 141 142 /* 143 * Prefer to place tasks in a sibling domain 144 * 145 * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD 146 * flag, but cleared below domains with SD_ASYM_CPUCAPACITY. 147 * 148 * NEEDS_GROUPS: Load balancing flag. 149 */ 150 SD_FLAG(SD_PREFER_SIBLING, SDF_NEEDS_GROUPS) 151 152 /* 153 * sched_groups of this level overlap 154 * 155 * SHARED_PARENT: Set for all NUMA levels above NODE. 156 * NEEDS_GROUPS: Overlaps can only exist with more than one group. 157 */ 158 SD_FLAG(SD_OVERLAP, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS) 159 160 /* 161 * Cross-node balancing 162 * 163 * SHARED_PARENT: Set for all NUMA levels above NODE. 164 * NEEDS_GROUPS: No point in preserving domain if it has a single group. 165 */ 166 SD_FLAG(SD_NUMA, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS) 167