Skip to content
charmOS docs

CPU Mask

include/structures/cpu_mask.h View source View on GitHub

Functions

Section titled “Functions”

cpu_mask_init

Section titled “cpu_mask_init”
void cpu_mask_init(struct cpu_mask *m, size_t nbits)
source

cpu_mask_create

Section titled “cpu_mask_create”
struct cpu_mask * cpu_mask_create(void)
source

cpu_mask_free

Section titled “cpu_mask_free”
void cpu_mask_free(struct cpu_mask *m)
source

cpu_mask_copy

Section titled “cpu_mask_copy”
void cpu_mask_copy(struct cpu_mask *dst, const struct cpu_mask *src)
source

cpu_mask_set

Section titled “cpu_mask_set”
void cpu_mask_set(struct cpu_mask *m, size_t cpu)
source

cpu_mask_of

Section titled “cpu_mask_of”
struct cpu_mask cpu_mask_of(size_t cpu)
source

Mask with only cpu set, usable as a runtime initializer

cpu_mask_clear

Section titled “cpu_mask_clear”
void cpu_mask_clear(struct cpu_mask *m, size_t cpu)
source

cpu_mask_toggle

Section titled “cpu_mask_toggle”
void cpu_mask_toggle(struct cpu_mask *m, size_t cpu)
source

cpu_mask_test

Section titled “cpu_mask_test”
bool cpu_mask_test(const struct cpu_mask *m, size_t cpu)
source

cpu_mask_test_and_set

Section titled “cpu_mask_test_and_set”
bool cpu_mask_test_and_set(struct cpu_mask *m, size_t cpu)
source

cpu_mask_test_and_clear

Section titled “cpu_mask_test_and_clear”
bool cpu_mask_test_and_clear(struct cpu_mask *m, size_t cpu)
source

cpu_mask_set_atomic

Section titled “cpu_mask_set_atomic”
void cpu_mask_set_atomic(struct cpu_mask *m, size_t cpu)
source

cpu_mask_clear_atomic

Section titled “cpu_mask_clear_atomic”
void cpu_mask_clear_atomic(struct cpu_mask *m, size_t cpu)
source

cpu_mask_toggle_atomic

Section titled “cpu_mask_toggle_atomic”
void cpu_mask_toggle_atomic(struct cpu_mask *m, size_t cpu)
source

cpu_mask_test_atomic

Section titled “cpu_mask_test_atomic”
bool cpu_mask_test_atomic(const struct cpu_mask *m, size_t cpu)
source

cpu_mask_test_and_set_atomic

Section titled “cpu_mask_test_and_set_atomic”
bool cpu_mask_test_and_set_atomic(struct cpu_mask *m, size_t cpu)
source

cpu_mask_test_and_clear_atomic

Section titled “cpu_mask_test_and_clear_atomic”
bool cpu_mask_test_and_clear_atomic(struct cpu_mask *m, size_t cpu)
source

cpu_mask_clear_all

Section titled “cpu_mask_clear_all”
void cpu_mask_clear_all(struct cpu_mask *m)
source

cpu_mask_zero

Section titled “cpu_mask_zero”
void cpu_mask_zero(struct cpu_mask *m)
source

cpu_mask_fill

Section titled “cpu_mask_fill”
void cpu_mask_fill(struct cpu_mask *m)
source

cpu_mask_set_range

Section titled “cpu_mask_set_range”
void cpu_mask_set_range(struct cpu_mask *m, size_t start, size_t len)
source

cpu_mask_clear_range

Section titled “cpu_mask_clear_range”
void cpu_mask_clear_range(
    struct cpu_mask *m,
    size_t start,
    size_t len
)
source

cpu_mask_or

Section titled “cpu_mask_or”
void cpu_mask_or(struct cpu_mask *dst, const struct cpu_mask *b)
source

cpu_mask_or2

Section titled “cpu_mask_or2”
void cpu_mask_or2(
    struct cpu_mask *dst,
    const struct cpu_mask *a,
    const struct cpu_mask *b
)
source

cpu_mask_and

Section titled “cpu_mask_and”
void cpu_mask_and(
    struct cpu_mask *dst,
    const struct cpu_mask *a,
    const struct cpu_mask *b
)
source

cpu_mask_xor

Section titled “cpu_mask_xor”
void cpu_mask_xor(
    struct cpu_mask *dst,
    const struct cpu_mask *a,
    const struct cpu_mask *b
)
source

cpu_mask_andnot

Section titled “cpu_mask_andnot”
void cpu_mask_andnot(
    struct cpu_mask *dst,
    const struct cpu_mask *a,
    const struct cpu_mask *b
)
source

cpu_mask_intersects

Section titled “cpu_mask_intersects”
bool cpu_mask_intersects(
    const struct cpu_mask *a,
    const struct cpu_mask *b
)
source

cpu_mask_equal

Section titled “cpu_mask_equal”
bool cpu_mask_equal(
    const struct cpu_mask *a,
    const struct cpu_mask *b
)
source

cpu_mask_subset

Section titled “cpu_mask_subset”
bool cpu_mask_subset(
    const struct cpu_mask *subset,
    const struct cpu_mask *superset
)
source

cpu_mask_popcount

Section titled “cpu_mask_popcount”
size_t cpu_mask_popcount(const struct cpu_mask *m)
source

cpu_mask_weight

Section titled “cpu_mask_weight”
size_t cpu_mask_weight(const struct cpu_mask *m)
source

cpu_mask_empty

Section titled “cpu_mask_empty”
bool cpu_mask_empty(const struct cpu_mask *m)
source

cpu_mask_full

Section titled “cpu_mask_full”
bool cpu_mask_full(const struct cpu_mask *m)
source

cpu_mask_first_set

Section titled “cpu_mask_first_set”
size_t cpu_mask_first_set(const struct cpu_mask *m)
source

cpu_mask_first_clear

Section titled “cpu_mask_first_clear”
size_t cpu_mask_first_clear(const struct cpu_mask *m)
source

cpu_mask_next_set

Section titled “cpu_mask_next_set”
size_t cpu_mask_next_set(const struct cpu_mask *m, size_t start)
source

cpu_mask_next_clear

Section titled “cpu_mask_next_clear”
size_t cpu_mask_next_clear(const struct cpu_mask *m, size_t start)
source

Macros

Section titled “Macros”

CPU_MASK_BITS

Section titled “CPU_MASK_BITS”
#define CPU_MASK_BITS 128
source

CPU_MASK_WORD_BITS

Section titled “CPU_MASK_WORD_BITS”
#define CPU_MASK_WORD_BITS 64
source

CPU_MASK_WORDS

Section titled “CPU_MASK_WORDS”
#define CPU_MASK_WORDS BITMAP_WORDS_CONST(CPU_MASK_BITS)
source

CPU_MASK_INIT

Section titled “CPU_MASK_INIT”
#define CPU_MASK_INIT
source
Expansion
#define CPU_MASK_INIT \
    (struct cpu_mask) { \
        .bits = {0} \
    }

CPU_MASK_LAST_WORD_BITS

Section titled “CPU_MASK_LAST_WORD_BITS”
#define CPU_MASK_LAST_WORD_BITS ((CPU_MASK_BITS) % CPU_MASK_WORD_BITS)
source

CPU_MASK_INIT_ALL

Section titled “CPU_MASK_INIT_ALL”
#define CPU_MASK_INIT_ALL
source
Expansion
#define CPU_MASK_INIT_ALL \
    cc_wno_override_init_expr( \
        struct cpu_mask, \
        ((struct cpu_mask) { \
            .bits = { \
                [0 ...(CPU_MASK_WORDS - 1)] = ~(bitmap_word_t) 0, \
                [CPU_MASK_WORDS - 1] = \
                    (CPU_MASK_LAST_WORD_BITS == 0) \
                        ? ~(bitmap_word_t) 0 \
                        : (((bitmap_word_t) 1 << CPU_MASK_LAST_WORD_BITS) - \
                           1)}}))

CPU_MASK_ERR

Section titled “CPU_MASK_ERR”
#define CPU_MASK_ERR(e)
source

Used to overload cpu_mask to carry an error at times

Expansion
#define CPU_MASK_ERR(e) \
    (struct cpu_mask) { \
        .bits = {(bitmap_word_t) (e) } \
    }

cpu_mask_active_bits

Section titled “cpu_mask_active_bits”
#define cpu_mask_active_bits
source
Expansion
#define cpu_mask_active_bits \
    (global.core_count && global.core_count <= CPU_MASK_BITS \
         ? global.core_count \
         : CPU_MASK_BITS)

cpu_mask_set_all

Section titled “cpu_mask_set_all”
#define cpu_mask_set_all(m)
source
Expansion
#define cpu_mask_set_all(m) bitmap_fill((m)->bits, cpu_mask_active_bits)

for_each_cpu

Section titled “for_each_cpu”
#define for_each_cpu(cpu, mask_ptr)
source
Expansion
#define for_each_cpu(cpu, mask_ptr) \
    for ((cpu) = \
             bitmap_find_first_set((mask_ptr)->bits, cpu_mask_active_bits); \
         (cpu) < cpu_mask_active_bits; \
         (cpu) = bitmap_find_next_bit((mask_ptr)->bits, cpu_mask_active_bits, \
                                      (cpu) + 1))

cpu_mask_for_each

Section titled “cpu_mask_for_each”
#define cpu_mask_for_each(iter, mask)
source
Expansion
#define cpu_mask_for_each(iter, mask) \
    for (iter = 0; iter < cpu_mask_active_bits; iter++) \
        if (bitmap_test((mask).bits, iter))

cpu_mask_for_each_atomic

Section titled “cpu_mask_for_each_atomic”
#define cpu_mask_for_each_atomic(iter, mask)
source
Expansion
#define cpu_mask_for_each_atomic(iter, mask) \
    for (iter = 0; iter < cpu_mask_active_bits; iter++) \
        if (bitmap_atomic_test((mask).bits, iter))

cpu_mask_for_each_clear

Section titled “cpu_mask_for_each_clear”
#define cpu_mask_for_each_clear(iter, mask)
source
Expansion
#define cpu_mask_for_each_clear(iter, mask) \
    for (iter = 0; iter < cpu_mask_active_bits; iter++) \
        if (!bitmap_test((mask).bits, iter))

cpu_mask_for_all

Section titled “cpu_mask_for_all”
#define cpu_mask_for_all(iter, mask)
source
Expansion
#define cpu_mask_for_all(iter, mask) \
    for (iter = 0; iter < cpu_mask_active_bits; iter++)

cpu_mask_for_each_in

Section titled “cpu_mask_for_each_in”
#define cpu_mask_for_each_in(iter, mask, start, end)
source
Expansion
#define cpu_mask_for_each_in(iter, mask, start, end) \
    for (iter = (start); iter < cpu_mask_active_bits && iter <= (end); iter++) \
        if (bitmap_test((mask).bits, iter))

cpu_mask_for_each_clear_in

Section titled “cpu_mask_for_each_clear_in”
#define cpu_mask_for_each_clear_in(iter, mask, start, end)
source
Expansion
#define cpu_mask_for_each_clear_in(iter, mask, start, end) \
    for (iter = (start); iter < cpu_mask_active_bits && iter <= (end); iter++) \
        if (!bitmap_test((mask).bits, iter))