cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

sd_flags.h (5522B)

      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 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 */
    119SD_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 */
    130SD_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 */
    140SD_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 */
    150SD_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 */
    158SD_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 */
    166SD_FLAG(SD_NUMA, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)