Topology

include/smp/topology.h View source View on GitHub

Structs

cpu_mask

struct cpu_mask {
    bool    uses_large;
    union {
        _Atomic uint64_t  small;
        _Atomic uint64_t  *large;
    };
    size_t  nbits;
};

topology_cache_info

struct topology_cache_info {
    uint8_t   level;
    uint8_t   type;
    uint32_t  size_kb;
    uint32_t  line_size;
    uint32_t  cores_sharing;
};

topology_package_info

struct topology_package_info {
    uint32_t         package_id;
    struct cpu_mask  cores;
};

topology_node

struct topology_node {
    enum topology_level   level;
    uint64_t              id;
    uint64_t              parent;
    struct topology_node  *parent_node;
    int32_t               first_child;
    int32_t               nr_children;
    struct cpu_mask       cpus;
    struct cpu_mask       idle;
    struct cpu_mask       rt_shed_rq_active;
    struct core           *core;
    union {
        struct numa_node              *numa;
        struct topology_cache_info    *cache;
        struct topology_package_info  *package;
    } data;
};

topology

struct topology {
    struct topology_node  *level[TOPOLOGY_LEVEL_MAX];
    uint16_t              count[TOPOLOGY_LEVEL_MAX];
};

Enums

topology_level

enum topology_level {
    TOPOLOGY_LEVEL_SMT,
    TOPOLOGY_LEVEL_CORE,
    TOPOLOGY_LEVEL_NUMA,
    TOPOLOGY_LEVEL_LLC,
    TOPOLOGY_LEVEL_PACKAGE,
    TOPOLOGY_LEVEL_MACHINE,
    TOPOLOGY_LEVEL_MAX,
    TOPOLOGY_LEVEL_COUNT = TOPOLOGY_LEVEL_MAX,
};

Functions

cpu_mask_create

struct cpu_mask * cpu_mask_create(void);

cpu_mask_init

bool cpu_mask_init(struct cpu_mask *m, size_t nbits);

cpu_mask_set

void cpu_mask_set(struct cpu_mask *m, size_t cpu);

cpu_mask_set_all

void cpu_mask_set_all(struct cpu_mask *m);

cpu_mask_clear

void cpu_mask_clear(struct cpu_mask *m, size_t cpu);

cpu_mask_test

bool cpu_mask_test(const struct cpu_mask *m, size_t cpu);

cpu_mask_or

void cpu_mask_or(struct cpu_mask *dst, const struct cpu_mask *b);

cpu_mask_empty

bool cpu_mask_empty(const struct cpu_mask *mask);

cpu_mask_clear_all

void cpu_mask_clear_all(struct cpu_mask *m);

cpu_mask_popcount

size_t cpu_mask_popcount(struct cpu_mask *m);

cpu_mask_free

void cpu_mask_free(struct cpu_mask *m);

cpu_mask_deinit

void cpu_mask_deinit(struct cpu_mask *m);

topology_mark_core_idle

void topology_mark_core_idle(cpu_id_t cpu_id, bool idle);

topology_find_idle_core

struct core * topology_find_idle_core(struct core *local_core, enum topology_level max_search);

topology_get_smts_under_numa

struct core * * topology_get_smts_under_numa(struct topology_node *numa, size_t *count);

topology_level_name

const char * topology_level_name(enum topology_level l);

Macros

CPU_MASK_WORD_BITS

#define CPU_MASK_WORD_BITS 64

CPU_MASK_WORDS

#define CPU_MASK_WORDS(nbits) \
    (((nbits) + CPU_MASK_WORD_BITS - 1) / CPU_MASK_WORD_BITS)

cpu_mask_for_each

#define cpu_mask_for_each(iter, mask) \
    for (iter = 0; iter < (mask).nbits; ++iter) \
        if ((mask).uses_large \
                ? atomic_load(&(mask).large[iter / CPU_MASK_WORD_BITS]) & \
                      (1ULL << (iter % CPU_MASK_WORD_BITS)) \
                : atomic_load(&(mask).small) & (1ULL << iter))

---