Skip to content
charmOS docs

CPU Mask

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

Structs

Section titled “Structs”

cpu_mask

Section titled “cpu_mask”
struct cpu_mask {
    bitmap_word_t  bits[CPU_MASK_WORDS];
};

Functions

Section titled “Functions”

cpu_mask_init

Section titled “cpu_mask_init”
bool cpu_mask_init(struct cpu_mask *m, size_t nbits);

cpu_mask_deinit

Section titled “cpu_mask_deinit”
void cpu_mask_deinit(struct cpu_mask *m);

cpu_mask_create

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

cpu_mask_free

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

cpu_mask_copy

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

cpu_mask_set

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

cpu_mask_clear

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

cpu_mask_toggle

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

cpu_mask_test

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

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

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

cpu_mask_set_atomic

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

cpu_mask_clear_atomic

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

cpu_mask_toggle_atomic

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

cpu_mask_test_atomic

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

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

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

cpu_mask_clear_all

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

cpu_mask_zero

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

cpu_mask_fill

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

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

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

cpu_mask_or

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

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

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

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

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

cpu_mask_intersects

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

cpu_mask_equal

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

cpu_mask_subset

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

cpu_mask_popcount

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

cpu_mask_weight

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

cpu_mask_empty

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

cpu_mask_full

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

cpu_mask_first_set

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

cpu_mask_first_clear

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

cpu_mask_next_set

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

cpu_mask_next_clear

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

Macros

Section titled “Macros”

CPU_MASK_BITS

Section titled “CPU_MASK_BITS”
#define CPU_MASK_BITS 128

CPU_MASK_WORD_BITS

Section titled “CPU_MASK_WORD_BITS”
#define CPU_MASK_WORD_BITS 64

CPU_MASK_WORDS

Section titled “CPU_MASK_WORDS”
#define CPU_MASK_WORDS BITMAP_WORDS(CPU_MASK_BITS)

CPU_MASK_INIT

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

CPU_MASK_ERR

Section titled “CPU_MASK_ERR”
#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() \
    (global.core_count ? global.core_count : CPU_MASK_BITS)

cpu_mask_set_all

Section titled “cpu_mask_set_all”
#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) \
    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) \
    for (iter = 0; iter < cpu_mask_active_bits(); iter++) \
        if (bitmap_test((mask).bits, iter))

cpu_mask_for_each_clear

Section titled “cpu_mask_for_each_clear”
#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) \
    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) \
    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) \
    for (iter = (start); iter < cpu_mask_active_bits() && iter <= (end); \
         iter++) \
        if (!bitmap_test((mask).bits, iter))