zxfoundation.memory.slub.types Module Reference

Data Structures
class	zxfoundation::memory::slub::kmem_cache
	SLUB slab cache descriptor. More...
struct	zxfoundation::memory::slub::kmem_cache_cpu
	Per-CPU hot allocation state. More...
struct	zxfoundation::memory::slub::kmem_cache_node
	Per-NUMA-node slab state. More...
class	zxfoundation::memory::slub::kmem_cache_ref< State >
	Type-safe, zero-overhead reference to a kmem_cache in a known lifecycle state. More...
struct	zxfoundation::memory::slub::slab_header
	Metadata embedded at the physical start of each slab frame. More...

Enumerations
enum class	zxfoundation::memory::slub::slub_flags : u32 {   none = 0 , typesafe_by_rcu = 1U << 0 , hwcache_align = 1U << 1 , poison = 1U << 2 ,   red_zone = 1U << 3 , no_reap = 1U << 4 }
	Cache creation flags. More...

Typedefs
using	zxfoundation::memory::slub::kmem_cache_ref_active = kmem_cache_ref<lifecycle_state::active>
using	zxfoundation::memory::slub::kmem_cache_ref_embryo = kmem_cache_ref<lifecycle_state::embryo>

Functions
auto	activate () noexcept -> void
	Activate: transition embryo → active after full initialisation.
auto	activate () noexcept -> kmem_cache_ref< lifecycle_state::active >
	Transition embryo -> active. Only valid on embryo refs.
auto	begin_destroy () noexcept -> void
	Begin teardown: transition active → dying.
auto	begin_destroy () noexcept -> kmem_cache_ref< lifecycle_state::dying >
	Transition active -> dying. Only valid on active refs.
	kmem_cache (const kmem_cache &)=delete
	kmem_cache (kmem_cache &&)=delete
	kmem_cache_ref (const kmem_cache_ref &) noexcept=default
	kmem_cache_ref (kmem_cache *p) noexcept
	operator bool () const noexcept
constexpr auto	zxfoundation::memory::slub::operator! (slub_flags a) noexcept -> bool
constexpr auto	zxfoundation::memory::slub::operator& (slub_flags a, slub_flags b) noexcept -> slub_flags
auto	operator* () const noexcept -> kmem_cache &
auto	operator-> () const noexcept -> kmem_cache *
auto	operator= (const kmem_cache &)=delete
auto	operator= (kmem_cache &&)=delete
auto	operator= (const kmem_cache_ref &) noexcept -> kmem_cache_ref &=default
constexpr auto	zxfoundation::memory::slub::operator| (slub_flags a, slub_flags b) noexcept -> slub_flags
auto	raw () const noexcept -> kmem_cache *
auto	ready () const noexcept -> bool
	Return true if the cache is accepting allocations.

Variables
u32	_pad {0}
u8	_pad {0}
u32	align {0}
objects::memory_object_ref	authority {}
kmem_cache *	cache {nullptr}
	Back-pointer to owning kmem_cache.
kmem_cache_cpu	cpu [base::config::CONFIG_ZX_MAX_CPUS] {}
u32	cpu_partial {SLUB_CPU_PARTIAL_DEFAULT}
slab_header *	cpu_partial_next {nullptr}
	CPU partial list (singly-linked).
slub_flags	flags {slub_flags::none}
u32	fp_offset {0}
void *	freelist {nullptr}
	Active slab's in-object freelist head.
void *	freelist {nullptr}
	In-object freelist head (when parked).
u8	frozen {0}
	1 = CPU owns its active freelist.
atomic< u32 >	inuse {0}
	Live allocated objects.
sync::qspinlock::qspinlock	list_lock {}
atomic< i64 >	live_objects {0}
u32	min_partial {SLUB_MIN_PARTIAL}
	Reclaim threshold.
const char *	name {nullptr}
slab_header *	next {nullptr}
	Node partial list linkage.
kmem_cache_node	node [numa::MAX_NUMA_NODES] {}
u8	node_id {0}
	PMM-selected NUMA owner node.
u32	nr_partial {0}
	Count of partial slabs.
u32	object_size {0}
u32	objects {0}
	Total objects in this slab.
u32	objects_per_slab {0}
u8	on_node_partial {0}
	Linked in its owner's partial list.
u32	order {0}
slab_header *	partial {nullptr}
	CPU partial list head.
slab_header *	partial {nullptr}
	Partially-filled slabs.
u32	partial_count {0}
	Objects in cpu_partial slabs.
u64	phys {0}
	Physical address of this slab frame.
slab_header *	prev {nullptr}
u64	random_seq {0}
sync::rcu::rcu_head	rcu {}
	For typesafe_by_rcu deferred free.
u32	rcu_order {0}
	PMM order stashed for RCU deferred free.
u32	size {0}
slab_header *	slab {nullptr}
	Active slab (HHDM pointer).
u32	slab_order {0}
	PMM order of this slab (set once, never changes).
constexpr u32	zxfoundation::memory::slub::SLUB_CPU_PARTIAL_DEFAULT = 13U
	Max objects on a CPU's partial list before spilling to node.
constexpr u32	zxfoundation::memory::slub::SLUB_MAX_CACHES = 64U
	Maximum number of distinct kmem_caches (static table).
constexpr u32	zxfoundation::memory::slub::SLUB_MAX_ORDER = 5U
	Maximum PMM order SLUB will use for slab pages.
constexpr u32	zxfoundation::memory::slub::SLUB_MAX_PARTIAL = 20U
constexpr u32	zxfoundation::memory::slub::SLUB_MAX_SIZE = 32768U
	Maximum SLUB allocation size (larger goes directly to PMM).
constexpr u32	zxfoundation::memory::slub::SLUB_MIN_PARTIAL = 5U
	Maximum partial slabs kept on the node partial list per cache.
atomic< u64 >	stat_alloc_fast {0}
atomic< u64 >	stat_alloc_slab {0}
atomic< u64 >	stat_alloc_slow {0}
u32	stat_fast_alloc {0}
	Fast-path alloc count (per-CPU, no atomics).
u32	stat_fast_free {0}
	Fast-path free count.
atomic< u64 >	stat_free_fast {0}
atomic< u64 >	stat_free_slab {0}
atomic< u64 >	stat_free_slow {0}
lifecycle_state	state {lifecycle_state::embryo}
atomic< u64 >	total_objects {0}
	Total objects (live + free) ever.
atomic< u64 >	total_slabs {0}
	Total slab pages allocated.

Files
file	zxfoundation/memory/slub.zcomponent/types.cxxm
	SLUB slab allocator type definitions.