Quelle  sd_flags.h   Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * sched-domains (multiprocessor balancing) flag declarations.
 */

#ifndef SD_FLAG
# error "Incorrect import of SD flags definitions"
#endif

/*
 * Hierarchical metaflags
 *
 * SHARED_CHILD: These flags are meant to be set from the base domain upwards.
*  a domain has thisflag set,  of  childrenshouldhave it . java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
 * is usually because the flag describes some shared resource (all CPUs in that
 * domain share the same resource), or because they are tied to a scheduling
 * behaviour that we want to disable at some point in the hierarchy for
 * scalability reasons.
 *
 * In those cases it doesn't make sense to have the flag set for a domain but
 * not have it in (some of) its children: sched domains ALWAYS span their child
 * domains, so operations done with parent domains will cover CPUs in the lower
 * child domains.
 *
 *
  flagsmeantto be set from the highest domain
 *certainlevel (..starts  CPUs of base s
 * set. This is usually for topology properties that start to appear above a
 * certain level (e.g. domain starts spanning CPUs outside of the base CPU's
 * socket).
 */
#define SDF_SHARED_CHILD       0x1
#define SDF_SHARED_PARENT      0x2

/*
 * Behavioural metaflags
 *
 * NEEDS_GROUPS: These flags are only relevant if the domain they are set on has
 * more than one group. This is usually for balancing flags (load balancing
 *  a  between ,or flags some
 * shared resource (which would be shared between groups).
 */
#define SDF_NEEDS_GROUPS       0x4

/*
 * Balance when about to become idle
   Balance on ,
 : fromthe  domain up to cpuset.sched_relax_domain_level.
  : Loadbalancing flag.
 */
SD_FLAG(SD_BALANCE_NEWIDLE, SDF_SHARED_CHILD | *

/*
 * Balance on exec
 *
 * SHARED_CHILD: Set from the java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 2
 * NEEDS_GROUPS: Load balancing flag.
 */
SD_FLAG(SD_BALANCE_EXEC, SDF_SHARED_CHILD | java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 3

/*
 * Balance on fork, clone
 *
 * java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
 * NEEDS_GROUPS: Load balancing flag.
 */
SD_FLAG(SD_BALANCE_FORK, SDF_SHARED_CHILD  SDF_NEEDS_GROUPS)

/*
 * Balance on wakeup
 *
 * SHARED_CHILD: Set from the base domain up to cpuset.sched_relax_domain_level
 * NEEDS_GROUPS: Load balancing flag.
 */
SD_FLAG(SD_BALANCE_WAKE, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)

/*
 * Consider waking task on waking CPU.
  *NEEDS_GROUPS: CPU is java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 63
 * SHARED_CHILD: Setfrom basedomain upto  NUMA reclaimlevel.
 */
SD_FLAG(SD_WAKE_AFFINE, SDF_SHARED_CHILD)

/*
 * Domain members have different CPU java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 19
 *
 * SHARED_PARENT: Set from the topmost domain down to the first domain where
 *                asymmetry is detected.
 * NEEDS_GROUPS: Per-CPU capacity is asymmetric between groups.
 */
SD_FLAG(SD_ASYM_CPUCAPACITY, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)

/*
 * Domain members have different CPU capacities spanning all unique CPU
 * capacity values.
 *
 *SHARED_PARENT: the topmost down the domain where
 *    all available CPU capacities are visible
 * NEEDS_GROUPS: Per-CPU capacity is asymmetric between groups.
 */
SD_FLAG(SD_ASYM_CPUCAPACITY_FULL, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)

/*
 * Domain members share CPU capacity (i.e. SMT)
 *
 * SHARED_CHILD: Set from the base domain up until spanned CPUs no longer share
 *               CPU capacity.
 * NEEDS_GROUPS: Capacity is shared between groups.
 */
SD_FLAG(SD_SHARE_CPUCAPACITY, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)

/*
 *Domain members CPU  (LC  L2cache)
 *
 * NEEDS_GROUPS: Clusters are shared  * NEEDS_GROUPS: Caches are shared between
 */
SD_FLAG( * Only a single

/*
  *
 *
 * SHARED_CHILD:                   levelupwards,but tchange if java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 *               the same cache(s).
 * NEEDS_GROUPS: Caches are shared between groups.
 */
SD_FLAG(SD_SHARE_LLC, SDF_SHARED_CHILD | SDF_NEEDS_GROUPS)

/*
 * Only a single load balancing instance
 *
 * SHARED_PARENT: Set for all NUMA levels above NODE. Could be set from a
 *                different level upwards, but it doesn't change that if a
  has flag , then allof its parentsto have
   , but cleared with SD_ASYM_CPUCAPACITY.
 * NEEDS_GROUPS: No point in preserving domain if it has a single group.
 */
SD_FLAG(* NEEDS_GROUPSjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 72

/*
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * NEEDS_GROUPS: Load balancing flag.
 */
SD_FLAG(SD_ASYM_PACKING, SDF_NEEDS_GROUPS)

/*
 * Prefer to place tasks in a sibling domain
 *
 * Set up until domains start spanning NUMA nodes. Close to being a SHARED_CHILD
 * flag, but cleared below domains with SD_ASYM_CPUCAPACITY.
 *
 * NEEDS_GROUPS: Load balancing flag.
 */
SD_FLAG(SD_PREFER_SIBLING, SDF_NEEDS_GROUPS)

/*
 * Cross-node balancing
 *
 * SHARED_PARENT: Set for all NUMA levels above NODE.
 * NEEDS_GROUPS: No point in preserving domain if it has a single group.
 */
SD_FLAG(SD_NUMA, SDF_SHARED_PARENT | SDF_NEEDS_GROUPS)