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 */ 74 SD_FLAG(SD_BALANCE_WAKE, SDF_SHARED_CHILD) 75 76 /* 77 * Consider waking task on waking CPU. 78 * 79 * SHARED_CHILD: Set from the base domain up to the NUMA reclaim level. 80 */ 81 SD_FLAG(SD_WAKE_AFFINE, SDF_SHARED_CHILD) 82 83 /* 84 * Domain members have different CPU capacities 85 * 86 * NEEDS_GROUPS: Per-CPU capacity is asymmetric between groups. 87 */ 88 SD_FLAG(SD_ASYM_CPUCAPACITY, SDF_NEEDS_GROUPS) 89 90 /* 91 * Domain members share CPU capacity (i.e. SMT) 92 * 93 * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share 94 * CPU capacity. 95 * NEEDS_GROUPS: Capacity is shared between groups. 96 */ 97 SD_FLAG(SD_SHARE_CPUCAPACITY, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) 98 99 /* 100 * Domain members share CPU package resources (i.e. caches) 101 * 102 * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share 103 * the same cache(s). 104 * NEEDS_GROUPS: Caches are shared between groups. 105 */ 106 SD_FLAG(SD_SHARE_PKG_RESOURCES, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS) 107 108 /* 109 * Only a single load balancing instance 110 * 111 * SHARED_PARENT: Set for all NUMA levels above NODE. Could be set from a 112 * different level upwards, but it doesn't change that if a domain has this flag 113 * set, then all of its parents need to have it too (otherwise the serialization 114 * doesn't make sense). 115 */ 116 SD_FLAG(SD_SERIALIZE, SDF_SHARED_PARENT) 117 118 /* 119 * Place busy tasks earlier in the domain 120 * 121 * SHARED_CHILD: Usually set on the SMT level. Technically could be set further 122 * up, but currently assumed to be set from the base domain upwards (see 123 * update_top_cache_domain()). 124 */ 125 SD_FLAG(SD_ASYM_PACKING, SDF_SHARED_CHILD) 126 127 /* 128 * Prefer to place tasks in a sibling domain 129 * 130 * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD 131 * flag, but cleared below domains with SD_ASYM_CPUCAPACITY. 132 */ 133 SD_FLAG(SD_PREFER_SIBLING, 0) 134 135 /* 136 * sched_groups of this level overlap 137 * 138 * SHARED_PARENT: Set for all NUMA levels above NODE. 139 */ 140 SD_FLAG(SD_OVERLAP, SDF_SHARED_PARENT) 141 142 /* 143 * Cross-node balancing 144 * 145 * SHARED_PARENT: Set for all NUMA levels above NODE. 146 */ 147 SD_FLAG(SD_NUMA, SDF_SHARED_PARENT) 148