API

Returns the ID (starting at zero) of the CPU-thread on which the calling Julia thread is currently running on.

Returns the IDs (starting at zero) of the CPU-threads on which the Julia threads are currently running on.

Returns the NUMA node associated with the CPU-thread on which the calling Julia thread is currently running on.

Returns the NUMA nodes associated with the CPU-threads on which the Julia threads are currently running on.

Returns the number CPU-threads available on this system.

Returns the number of NUMA nodes available on this system.

which_numa_node(arr::AbstractArray) -> Int64
which_numa_node(arr::AbstractArray, i; kwargs...) -> Int64

Query on which NUMA node the given array is allocated (assuming that it is allocated on a single node).

Technically only the address of a single element is checked (by default the first one). The optional second integer argument can be used to specify this element.

The optional keyword argument variant can be used to switch between methods used to determine the NUMA node. Valid options are :move_pages (default) and :get_mempolicy.

Note: Returned NUMA node IDs start at zero!

which_numa_node(ptr::Ptr{T}; variant) -> Int64

Query on which NUMA node the page associated with the given memory address (pointer) is located.

The optional keyword argument variant can be used to switch between methods used to determine the NUMA node. Valid options are :move_pages (default) and :get_mempolicy.

Note: Returned NUMA node IDs start at zero!

numalocal() -> NUMA.NUMALocal

Returns an array initializer that represents the local NUMA node. To be used as, e.g., Vector{Float64}(numalocal(), 1024).

numanode(i::Integer) -> NUMA.NUMANode

Returns an array initializer that represents a specific NUMA node. To be used as, e.g., Vector{Float64}(numanode(1), 1024).

Represents a bit mask. To be used to indicate, e.g., node masks or cpu masks.

Example:

julia> bm = Bitmask()
Bitmask (trunc): 00000000

julia> fill!(bm, 1); bm
Bitmask (trunc): 11111111

julia> bm[2] = 0; bm
Bitmask (trunc): 11111101

julia> numa_set_membind(bm)

julia> numa_get_membind()
Bitmask (trunc): 11111101

numa_allocate_cpumask() -> Bitmask

Returns a bitmask of a size equal to the kernel's cpu mask. In other words, large enough to represent all cpus.

numa_allocate_nodemask() -> Bitmask

Returns a bitmask of a size equal to the kernel's node mask. In other words, large enough to represent all nodes.

numa_available() -> Bool

Is this a NUMA system?

numa_bitmask_alloc() -> Bitmask
numa_bitmask_alloc(n::Integer) -> Bitmask

Allocates a bitmask structure and its associated bit mask. The memory allocated for the bit mask contains enough words (type UInt64) to contain n bits. If n isn't provided, nnumanodes() is used.

The bit mask is zero-filled.

numa_bitmask_clearall!(bm::Bitmask)

Set all bits in the given Bitmask to zero.

numa_bitmask_clearbit!(bm::Bitmask, n::Integer)

Clear the n-th bit of the given Bitmask.

numa_bitmask_setall!(bm::Bitmask)

Set all bits in the given Bitmask to one.

numa_bitmask_setbit!(bm::Bitmask, n::Integer)

Set the n-th bit of the given Bitmask.

numa_get_membind() -> Bitmask

Returns the mask of nodes from which memory can currently be allocated

numa_get_mems_allowed() -> Bitmask

Returns the mask of nodes from which the process is allowed to allocate memory in it's current cpuset context

numa_max_node() -> Int64

Highest node number available on the system

numa_max_possible_node() -> Int64

Number of the highest possible node in a system

numa_node_of_cpu() -> Int64
numa_node_of_cpu(cpuid::Integer) -> Int64

Returns the NUMA node that the cpu with the given id (starting at zero) belongs to.

numa_node_size(

) -> NamedTuple{(:memtot, :memfree), Tuple{Int64, Int64}}
numa_node_size(
    node::Integer
) -> NamedTuple{(:memtot, :memfree), Tuple{Int64, Int64}}

Returns a named tuple holding the total memory and free memory of the given NUMA node. If no node index is provided as an argument, current_numa_node() is used.

numa_num_possible_nodes() -> Int64

Returns the size of kernel's node mask, i.e. large enough to represent the maximum number of nodes that the kernel can handle

numa_pagesize() -> Int64

Returns the number of bytes in a page

numa_preferred() -> Int64

Preferred NUMA node of the current task

numa_set_localalloc()

Sets the memory allocation policy for the calling task to local allocation

numa_set_membind(bm::Bitmask)

Sets the memory allocation mask. The task will only allocate memory from the nodes set in the given nodemask. Passing an empty nodemask or a nodemask that contains nodes other than those in the mask returned by numa_get_mems_allowed() will result in an error.