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