Topology

include/smp/topology.h

struct cpu_mask

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

struct 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;
};

struct topology_package_info

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

struct topology_package_info referenced types:

• struct cpu_mask

struct 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;
};

struct topology_node referenced types:

• enum topology_level
• struct topology_node
• struct cpu_mask
• struct core
• struct numa_node
• struct topology_cache_info
• struct topology_package_info

struct topology

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

struct topology referenced types:

• struct topology_node

enum 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,
};

cpu_mask_create

struct cpu_mask * cpu_mask_create(void);

cpu_mask_create referenced types:

• struct cpu_mask

cpu_mask_init

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

cpu_mask_init referenced types:

• struct cpu_mask

cpu_mask_set

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

cpu_mask_set referenced types:

• struct cpu_mask

cpu_mask_set_all

void cpu_mask_set_all(struct cpu_mask *m);

cpu_mask_set_all referenced types:

• struct cpu_mask

cpu_mask_clear

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

cpu_mask_clear referenced types:

• struct cpu_mask

cpu_mask_test

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

cpu_mask_test referenced types:

• struct cpu_mask

cpu_mask_or

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

cpu_mask_or referenced types:

• struct cpu_mask

cpu_mask_empty

bool cpu_mask_empty(struct cpu_mask *mask);

cpu_mask_empty referenced types:

• struct cpu_mask

cpu_mask_clear_all

void cpu_mask_clear_all(struct cpu_mask *m);

cpu_mask_clear_all referenced types:

• struct cpu_mask

cpu_mask_popcount

size_t cpu_mask_popcount(struct cpu_mask *m);

cpu_mask_popcount referenced types:

• struct cpu_mask

cpu_mask_free

void cpu_mask_free(struct cpu_mask *m);

cpu_mask_free referenced types:

• struct cpu_mask

cpu_mask_deinit

void cpu_mask_deinit(struct cpu_mask *m);

cpu_mask_deinit referenced types:

• struct cpu_mask

topology_mark_core_idle

void topology_mark_core_idle(size_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_find_idle_core referenced types:

• struct core
• enum topology_level

topology_get_smts_under_numa

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

topology_get_smts_under_numa referenced types:

• struct core
• struct topology_node

topology_level_name

char * topology_level_name(enum topology_level l);

topology_level_name referenced types:

• enum topology_level

Defines

CPU_MASK_WORD_BITS

#define CPU_MASK_WORD_BITS 64

CPU_MASK_WORDS(nbits)

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

cpu_mask_for_each(iter, mask)

#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))

---