Returns the number of elements in the vector.

Returns the raw pointer to the allocated memory.

Returns a reference to the protected data. This method is rarely needed since the guard implements `Deref`.

* @brief Returns the number of threads in the thread-pool, including the main thread. * @retval 0 if the thread-pool is not initialized, 1 if o

Appends an element to the back of the vector. # Arguments `value` - The element to append # Errors Returns an error if allocation fails when growi

Returns an iterator over the vector.

Creates a new thread pool with the specified number of threads. By default, uses `CallerExclusivity::Inclusive`, meaning the calling thread participa

Returns a mutable raw pointer to the vector's buffer.

Executes a function on each thread of the pool, returning a closure object. This operation provides explicit control over broadcast and join phases,

Gets a mutable reference to the protected data. Since this requires a mutable reference to the mutex, no locking is needed as we have exclusive acces

Distributes `n` similar duration calls between threads by individual indices. Uses static load balancing where each thread gets a predetermined set o

Spawns a pool with the specified number of threads.

@brief Safely cast `fu_pool_t*` to `opaque_pool_t*` avoiding alignment violation warnings. */

Executes `n` uneven tasks on all threads, greedily stealing work. Uses dynamic load balancing with work-stealing. Threads that finish their assigned

Returns the allocated memory as a mutable byte slice.

Returns the allocated memory as an immutable byte slice.

Returns the number of colocations (and thus the number of `PinnedVec`s).

Reserves capacity for at least `additional` more elements. # Arguments `additional` - The number of additional elements to reserve space for # Erro

Returns a mutable iterator over the vector.

@brief Blocks the calling thread until the currently broadcasted task finishes. */

* @brief Allocates a memory for `size` elements of `value_type`. * @param[in] size The number of elements to allocate. * @param[in] page_

Returns the number of threads in a specific colocation. This method is useful for NUMA-aware load balancing, allowing you to understand how many thre

Wait for all threads to complete their work. If broadcast() hasn't been called yet, this will call it first.

Converts a global thread index to a local thread index within a colocation. This is useful for distributed thread pools where threads are grouped int

* @brief Stops all threads and deallocates the thread-pool after the last call finishes. * @note Can be called from @b any thread at any time.

Allocates exactly the requested number of bytes on this allocator's NUMA node. # Arguments `bytes` - The exact number of bytes to allocate # Errors

Returns the number of elements the vector can hold without reallocating.

Returns the number of distinct thread colocations available. A "colocation" represents a group of threads that share the same: - **NUMA memory domain

Returns the number of NUMA nodes available on the system.

Returns `true` if the vector contains no elements.

Acquires the lock, returning a guard that provides access to the protected data. This method will spin until the lock is acquired. If the lock is alr

Creates a mutable parallel slice view over the vector.

* @brief Converts a @p `global_thread_index` to a local thread index within a @b colocation. * @return Same value as `global_thread_index`, as

Allocates memory with at least the requested size on this allocator's NUMA node. Returns both the actual allocated size and page size information, wh

Clears the vector, removing all values. # Examples ```rust use fork_union::*; let allocator = PinnedAllocator::new(0).expect("Failed to create allo

* @brief Returns the first thread index in the thread-pool. * @retval 0 as this pool isn't intended for colocated/distributed topologies.

Helper function to visit every element exactly once with mutable access.

Distributes `n` similar duration calls between threads in slices. Instead of individual task assignment, this method groups tasks into contiguous sli

@brief Checks if the thread-pool's core synchronization points are lock-free. */

* @brief Harvests CPU-memory topology. * @retval false if the kernel lacks NUMA support or the harvest failed. * @retval true if the harv

Benchmark search performance

Broadcast the work to all threads without waiting for completion. This is safe to call multiple times - subsequent calls are no-ops.

Returns the page size used for this allocation.

* @brief Number of individual sub-pool with the same NUMA-locality and QoS. * @retval 1 constant for compatibility. */

Returns the number of logical CPU cores available on the system.

* @brief Represents the CPU capabilities for hardware-friendly yielding. * @note Combine with @b `ram_capabilities()` to get the full set of librar

Helper function to visit every element exactly once with dynamic work-stealing.

Gets a reference to the `PinnedVec` at the specified colocation. # Arguments `colocation_index` - The colocation index # Returns A reference to th

Converts a local index within a specific NUMA node to the global round-robin index. This is useful when you have a reference to an element within a s

Creates a read-only parallel slice view over the vector.

* @brief Represents the memory-system capabilities, retrieved from the Linux Sysfs. * @note Combine with @b `cpu_capabilities()` to get the full se

Swaps two elements in the vector.

Shortens the vector, keeping the first `len` elements and dropping the rest.

* @brief Copy-assigns the topology from @p other. * * Instead of a copy-constructor we expose an explicit operation that can * FAIL

* @brief Creates a thread-pool with the given number of threads. * @param[in] threads The number of threads to be used. * @param[in] excl

* @brief Allocates memory for at least `size` elements of `value_type`. * @param[in] size The number of elements to allocate. * @param[in