这篇博客详细介绍了Linux系统中关于NUMA（非一致性内存访问）的内存管理和调度机制。包括get_mempolicy、set_mempolicy、mbind等系统调用的使用，以及如何通过numa库来设置和查询内存分配策略。内容涵盖了NUMA节点、CPU、内存分配策略如本地分配、绑定、交织等，并讨论了它们在多任务和多进程环境中的应用。此外，还提到了numa库的一些实用函数，如numa_available()、numa_num_nodes()、numa_set_preferred()等，以及如何在程序中使用这些函数来优化内存分配和任务调度。
目录
get_mempolicy(2)
GET_MEMPOLICY(2) Linux Programmer's Manual GET_MEMPOLICY(2)
NAME
get_mempolicy - retrieve NUMA memory policy for a thread
SYNOPSIS
#include <numaif.h>
long get_mempolicy(int *mode, unsigned long *nodemask,
unsigned long maxnode, void *addr,
unsigned long flags); Link with -lnuma.
Note: There is no glibc wrapper for this system call; see NOTES.
DESCRIPTION
get_mempolicy() retrieves the NUMA policy of the calling thread
or of a memory address, depending on the setting of flags.
A NUMA machine has different memory controllers with different
distances to specific CPUs. The memory policy defines from which
node memory is allocated for the thread.
If flags is specified as 0, then information about the calling
thread's default policy (as set by set_mempolicy(2)) is returned,
in the buffers pointed to by mode and nodemask. The value
returned in these arguments may be used to restore the thread's
policy to its state at the time of the call to get_mempolicy()
using set_mempolicy(2). When flags is 0, addr must be specified
as NULL.
If flags specifies MPOL_F_MEMS_ALLOWED (available since Linux
2.6.24), the mode argument is ignored and the set of nodes
(memories) that the thread is allowed to specify in subsequent
calls to mbind(2) or set_mempolicy(2) (in the absence of any mode
flags) is returned in nodemask. It is not permitted to combine
MPOL_F_MEMS_ALLOWED with either MPOL_F_ADDR or MPOL_F_NODE.
If flags specifies MPOL_F_ADDR, then information is returned
about the policy governing the memory address given in addr.
This policy may be different from the thread's default policy if
mbind(2) or one of the helper functions described in numa(3) has
been used to establish a policy for the memory range containing
addr.
If the mode argument is not NULL, then get_mempolicy() will store
the policy mode and any optional mode flags of the requested NUMA
policy in the location pointed to by this argument. If nodemask
is not NULL, then the nodemask associated with the policy will be
stored in the location pointed to by this argument. maxnode
specifies the number of node IDs that can be stored into
nodemask—that is, the maximum node ID plus one. The value
specified by maxnode is always rounded to a multiple of
sizeof(unsigned long)*8.
If flags specifies both MPOL_F_NODE and MPOL_F_ADDR,
get_mempolicy() will return the node ID of the node on which the
address addr is allocated into the location pointed to by mode.
If no page has yet been allocated for the specified address,
get_mempolicy() will allocate a page as if the thread had
performed a read (load) access to that address, and return the ID
of the node where that page was allocated.
If flags specifies MPOL_F_NODE, but not MPOL_F_ADDR, and the
thread's current policy is MPOL_INTERLEAVE, then get_mempolicy()
will return in the location pointed to by a non-NULL mode
argument, the node ID of the next node that will be used for
interleaving of internal kernel pages allocated on behalf of the
thread. These allocations include pages for memory-mapped files
in process memory ranges mapped using the mmap(2) call with the
MAP_PRIVATE flag for read accesses, and in memory ranges mapped
with the MAP_SHARED flag for all accesses.
Other flag values are reserved.
For an overview of the possible policies see set_mempolicy(2).
RETURN VALUE
On success, get_mempolicy() returns 0; on error, -1 is returned
and errno is set to indicate the error.
ERRORS
EFAULT Part of all of the memory range specified by nodemask and
maxnode points outside your accessible address space.
EINVAL The value specified by maxnode is less than the number of
node IDs supported by the system. Or flags specified
values other than MPOL_F_NODE or MPOL_F_ADDR; or flags
specified MPOL_F_ADDR and addr is NULL, or flags did not
specify MPOL_F_ADDR and addr is not NULL. Or, flags
specified MPOL_F_NODE but not MPOL_F_ADDR and the current
thread policy is not MPOL_INTERLEAVE. Or, flags specified
MPOL_F_MEMS_ALLOWED with either MPOL_F_ADDR or
MPOL_F_NODE. (And there are other EINVAL cases.)
VERSIONS
The get_mempolicy() system call was added to the Linux kernel in
version 2.6.7.
CONFORMING TO
This system call is Linux-specific.
NOTES
Glibc does not provide a wrapper for this system call. For
information on library support, see numa(7).
SEE ALSO
getcpu(2), mbind(2), mmap(2), set_mempolicy(2), numa(3), numa(7), numactl(8)
COLOPHON
This page is part of release 5.11 of the Linux man-pages project.
A description of the project, information about reporting bugs,
and the latest version of this page, can be found at
https://www.kernel.org/doc/man-pages/.
Linux 2021-03-22 GET_MEMPOLICY(2)
Pages that refer to this page: mbind(2), migrate_pages(2), move_pages(2), set_mempolicy(2), syscalls(2), numa(3), cpuset(7), numa(7), migratepages(8), numactl(8)
DEMO
int
rte_vhost_get_numa_node(int vid)
{
#ifdef RTE_LIBRTE_VHOST_NUMA
struct virtio_net *dev = get_device(vid);
int numa_node;
int ret;
if (dev == NULL || numa_available() != 0)
return -1;
ret = get_mempolicy(&numa_node, NULL, 0, dev,
MPOL_F_NODE | MPOL_F_ADDR);
if (ret < 0) {
VHOST_LOG_CONFIG(ERR,
"(%d) failed to query numa node: %s\n",
vid, rte_strerror(errno));
return -1;
}
return numa_node;
#else
RTE_SET_USED(vid);
return -1;
#endif
}
set_mempolicy(2)
SET_MEMPOLICY(2) Linux Programmer's Manual SET_MEMPOLICY(2)
NAME
set_mempolicy - set default NUMA memory policy for a thread and
its children
SYNOPSIS
#include <numaif.h>
long set_mempolicy(int mode, const unsigned long *nodemask,
unsigned long maxnode);Link with -lnuma.
DESCRIPTION
set_mempolicy() sets the NUMA memory policy of the calling
thread, which consists of a policy mode and zero or more nodes,
to the values specified by the mode, nodemask, and maxnode
arguments.
A NUMA machine has different memory controllers with different
distances to specific CPUs. The memory policy defines from which
node memory is allocated for the thread.
This system call defines the default policy for the thread. The
thread policy governs allocation of pages in the process's
address space outside of memory ranges controlled by a more
specific policy set by mbind(2). The thread default policy also
controls allocation of any pages for memory-mapped files mapped
using the mmap(2) call with the MAP_PRIVATE flag and that are
only read (loaded) from by the thread and of memory-mapped files
mapped using the mmap(2) call with the MAP_SHARED flag,
regardless of the access type. The policy is applied only when a
new page is allocated for the thread. For anonymous memory this
is when the page is first touched by the thread.
The mode argument must specify one of MPOL_DEFAULT, MPOL_BIND,
MPOL_INTERLEAVE, MPOL_PREFERRED, or MPOL_LOCAL (which are
described in detail below). All modes except MPOL_DEFAULT
require the caller to specify the node or nodes to which the mode
applies, via the nodemask argument.
The mode argument may also include an optional mode flag. The
supported mode flags are:
MPOL_F_STATIC_NODES (since Linux 2.6.26)
A nonempty nodemask specifies physical node IDs. Linux
will not remap the nodemask when the process moves to a
different cpuset context, nor when the set of nodes
allowed by the process's current cpuset context changes.
MPOL_F_RELATIVE_NODES (since Linux 2.6.26)
A nonempty nodemask specifies node IDs that are relative
to the set of node IDs allowed by the process's current
cpuset.
nodemask points to a bit mask of node IDs that contains up to
maxnode bits. The bit mask size is rounded to the next multiple
of sizeof(unsigned long), but the kernel will use bits only up to
maxnode. A NULL value of nodemask or a maxnode value of zero
specifies the empty set of nodes. If the value of maxnode is
zero, the nodemask argument is ignored.
Where a nodemask is required, it must contain at least one node
that is on-line, allowed by the process's current cpuset context,
(unless the MPOL_F_STATIC_NODES mode flag is specified), and
contains memory. If the MPOL_F_STATIC_NODES is set in mode and a
required nodemask contains no nodes that are allowed by the
process's current cpuset context, the memory policy reverts to
local allocation. This effectively overrides the specified
policy until the process's cpuset context includes one or more of
the nodes specified by nodemask.
The mode argument must include one of the following values:
MPOL_DEFAULT
This mode specifies that any nondefault thread memory
policy be removed, so that the memory policy "falls back"
to the system default policy. The system default policy
is "local allocation"—that is, allocate memory on the node
of the CPU that triggered the allocation. nodemask must
be specified as NULL. If the "local node" contains no
free memory, the system will attempt to allocate memory
from a "near by" node.
MPOL_BIND
This mode defines a strict policy that restricts memory
allocation to the nodes specified in nodemask. If
nodemask specifies more than one node, page allocations
will come from the node with the lowest numeric node ID
first, until that node contains no free memory.
Allocations will then come from the node with the next
highest node ID specified in nodemask and so forth, until
none of the specified nodes contain free memory. Pages
will not be allocated from any node not specified in the
nodemask.
MPOL_INTERLEAVE
This mode interleaves page allocations across the nodes
specified in nodemask in numeric node ID order. This
optimizes for bandwidth instead of latency by spreading
out pages and memory accesses to those pages across
multiple nodes. However, accesses to a single page will
still be limited to the memory bandwidth of a single node.
MPOL_PREFERRED
This mode sets the preferred node for allocation. The
kernel will try to allocate pages from this node first and
fall back to "near by" nodes if the preferred node is low
on free memory. If nodemask specifies more than one node
ID, the first node in the mask will be selected as the
preferred node. If the nodemask and maxnode arguments
specify the empty set, then the policy specifies "local
allocation" (like the system default policy discussed
above).
MPOL_LOCAL (since Linux 3.8)
This mode specifies "local allocation"; the memory is
allocated on the node of the CPU that triggered the
allocation (the "local node"). The nodemask and maxnode
arguments must specify the empty set. If the "local node"
is low on free memory, the kernel will try to allocate
memory from other nodes. The kernel will allocate memory
from the "local node" whenever memory for this node is
available. If the "local node" is not allowed by the
process's current cpuset context, the kernel will try to
allocate memory from other nodes. The kernel will
allocate memory from the "local node" whenever it becomes
allowed by the process's current cpuset context.
The thread memory policy is preserved across an execve(2), and is
inherited by child threads created using fork(2) or clone(2).
RETURN VALUE
On success, set_mempolicy() returns 0; on error, -1 is returned
and errno is set to indicate the error.
ERRORS
EFAULT Part of all of the memory range specified by nodemask and
maxnode points outside your accessible address space.
EINVAL mode is invalid. Or, mode is MPOL_DEFAULT and nodemask is
nonempty, or mode is MPOL_BIND or MPOL_INTERLEAVE and
nodemask is empty. Or, maxnode specifies more than a page
worth of bits. Or, nodemask specifies one or more node
IDs that are greater than the maximum supported node ID.
Or, none of the node IDs specified by nodemask are on-line
and allowed by the process's current cpuset context, or
none of the specified nodes contain memory. Or, the mode
argument specified both MPOL_F_STATIC_NODES and
MPOL_F_RELATIVE_NODES.
ENOMEM Insufficient kernel memory was available.
VERSIONS
The set_mempolicy() system call was added to the Linux kernel in
version 2.6.7.
CONFORMING TO
This system call is Linux-specific.
NOTES
Memory policy is not remembered if the page is swapped out. When
such a page is paged back in, it will use the policy of the
thread or memory range that is in effect at the time the page is
allocated.
For information on library support, see numa(7).
SEE ALSO
get_mempolicy(2), getcpu(2), mbind(2), mmap(2), numa(3), cpuset(7), numa(7), numactl(8)
COLOPHON
This page is part of release 5.11 of the Linux man-pages project.
A description of the project, information about reporting bugs,
and the latest version of this page, can be found at
https://www.kernel.org/doc/man-pages/.
Linux 2020-12-21 SET_MEMPOLICY(2)
Pages that refer to this page: getcpu(2), get_mempolicy(2), mbind(2), migrate_pages(2), move_pages(2), syscalls(2), numa(3), systemd.exec(5), tmpfs(5), cpuset(7), numa(7), migratepages(8), numactl(8)
mbind(2)
MBIND(2) Linux Programmer's Manual MBIND(2)
NAME
mbind - set memory policy for a memory range
SYNOPSIS
#include <numaif.h>
long mbind(void *addr, unsigned long len, int mode,
const unsigned long *nodemask, unsigned long maxnode,
unsigned int flags); Link with -lnuma.
Note: There is no glibc wrapper for this system call; see NOTES.
DESCRIPTION
mbind() sets the NUMA memory policy, which consists of a policy
mode and zero or more nodes, for the memory range starting with
addr and continuing for len bytes. The memory policy defines
from which node memory is allocated.
If the memory range specified by the addr and len arguments
includes an "anonymous" region of memory—that is a region of
memory created using the mmap(2) system call with the
MAP_ANONYMOUS—or a memory-mapped file, mapped using the mmap(2)
system call with the MAP_PRIVATE flag, pages will be allocated
only according to the specified policy when the application
writes (stores) to the page. For anonymous regions, an initial
read access will use a shared page in the kernel containing all
zeros. For a file mapped with MAP_PRIVATE, an initial read
access will allocate pages according to the memory policy of the
thread that causes the page to be allocated. This may not be the
thread that called mbind().
The specified policy will be ignored for any MAP_SHARED mappings
in the specified memory range. Rather the pages will be
allocated according to the memory policy of the thread that
caused the page to be allocated. Again, this may not be the
thread that called mbind().
If the specified memory range includes a shared memory region
created using the shmget(2) system call and attached using the
shmat(2) system call, pages allocated for the anonymous or shared
memory region will be allocated according to the policy
specified, regardless of which process attached to the shared
memory segment causes the allocation. If, however, the shared
memory region was created with the SHM_HUGETLB flag, the huge
pages will be allocated according to the policy specified only if
the page allocation is caused by the process that calls mbind()
for that region.
By default, mbind() has an effect only for new allocations; if
the pages inside the range have been already touched before
setting the policy, then the policy has no effect. This default
behavior may be overridden by the MPOL_MF_MOVE and
MPOL_MF_MOVE_ALL flags described below.
The mode argument must specify one of MPOL_DEFAULT, MPOL_BIND,
MPOL_INTERLEAVE, MPOL_PREFERRED, or MPOL_LOCAL (which are
described in detail below). All policy modes except MPOL_DEFAULT
require the caller to specify the node or nodes to which the mode
applies, via the nodemask argument.
The mode argument may also include an optional mode flag. The
supported mode flags are:
MPOL_F_STATIC_NODES (since Linux-2.6.26)
A nonempty nodemask specifies physical node IDs. Linux
does not remap the nodemask when the thread moves to a
different cpuset context, nor when the set of nodes
allowed by the thread's current cpuset context changes.
MPOL_F_RELATIVE_NODES (since Linux-2.6.26)
A nonempty nodemask specifies node IDs that are relative
to the set of node IDs allowed by the thread's current
cpuset.
nodemask points to a bit mask of nodes containing up to maxnode
bits. The bit mask size is rounded to the next multiple of
sizeof(unsigned long), but the kernel will use bits only up to
maxnode. A NULL value of nodemask or a maxnode value of zero
specifies the empty set of nodes. If the value of maxnode is
zero, the nodemask argument is ignored. Where a nodemask is
required, it must contain at least one node that is on-line,
allowed by the thread's current cpuset context (unless the
MPOL_F_STATIC_NODES mode flag is specified), and contains memory.
The mode argument must include one of the following values:
MPOL_DEFAULT
This mode requests that any nondefault policy be removed,
restoring default behavior. When applied to a range of
memory via mbind(), this means to use the thread memory
policy, which may have been set with set_mempolicy(2). If
the mode of the thread memory policy is also MPOL_DEFAULT,
the system-wide default policy will be used. The system-
wide default policy allocates pages on the node of the CPU
that triggers the allocation. For MPOL_DEFAULT, the
nodemask and maxnode arguments must be specify the empty
set of nodes.
MPOL_BIND
This mode specifies a strict policy that restricts memory
allocation to the nodes specified in nodemask. If
nodemask specifies more than one node, page allocations
will come from the node with sufficient free memory that
is closest to the node where the allocation takes place.
Pages will not be allocated from any node not specified in
the IR nodemask . (Before Linux 2.6.26, page allocations
came from the node with the lowest numeric node ID first,
until that node contained no free memory. Allocations
then came from the node with the next highest node ID
specified in nodemask and so forth, until none of the
specified nodes contained free memory.)
MPOL_INTERLEAVE(交错)
This mode specifies that page allocations be interleaved
across the set of nodes specified in nodemask. This
optimizes for bandwidth instead of latency by spreading
out pages and memory accesses to those pages across
multiple nodes. To be effective the memory area should be
fairly large, at least 1 MB or bigger with a fairly
uniform access pattern. Accesses to a single page of the
area will still be limited to the memory bandwidth of a
single node.
MPOL_PREFERRED(首选的；优先；更喜欢)
This mode sets the preferred node for allocation. The
kernel will try to allocate pages from this node first and
fall back to other nodes if the preferred nodes is low on
free memory. If nodemask specifies more than one node ID,
the first node in the mask will be selected as the
preferred node. If the nodemask and maxnode arguments
specify the empty set, then the memory is allocated on the
node of the CPU that triggered the allocation.
MPOL_LOCAL (since Linux 3.8)
This mode specifies "local allocation"; the memory is
allocated on the node of the CPU that triggered the
allocation (the "local node"). The nodemask and maxnode
arguments must specify the empty set. If the "local node"
is low on free memory, the kernel will try to allocate
memory from other nodes. The kernel will allocate memory
from the "local node" whenever memory for this node is
available. If the "local node" is not allowed by the
thread's current cpuset context, the kernel will try to
allocate memory from other nodes. The kernel will
allocate memory from the "local node" whenever it becomes
allowed by the thread's current cpuset context. By
contrast, MPOL_DEFAULT reverts to the memory policy of the
thread (which may be set via set_mempolicy(2)); that
policy may be something other than "local allocation".
If MPOL_MF_STRICT is passed in flags and mode is not
MPOL_DEFAULT, then the call fails with the error EIO if the
existing pages in the memory range don't follow the policy.
If MPOL_MF_MOVE is specified in flags, then the kernel will
attempt to move all the existing pages in the memory range so
that they follow the policy. Pages that are shared with other
processes will not be moved. If MPOL_MF_STRICT is also
specified, then the call fails with the error EIO if some pages
could not be moved.
If MPOL_MF_MOVE_ALL is passed in flags, then the kernel will
attempt to move all existing pages in the memory range regardless
of whether other processes use the pages. The calling thread
must be privileged (CAP_SYS_NICE) to use this flag. If
MPOL_MF_STRICT is also specified, then the call fails with the
error EIO if some pages could not be moved.
RETURN VALUE
On success, mbind() returns 0; on error, -1 is returned and errno is set to indicate the error.
ERRORS
EFAULT Part or all of the memory range specified by nodemask and
maxnode points outside your accessible address space. Or,
there was an unmapped hole in the specified memory range
specified by addr and len.
EINVAL An invalid value was specified for flags or mode; or addr
+ len was less than addr; or addr is not a multiple of the
system page size. Or, mode is MPOL_DEFAULT and nodemask
specified a nonempty set; or mode is MPOL_BIND or
MPOL_INTERLEAVE and nodemask is empty. Or, maxnode
exceeds a kernel-imposed limit. Or, nodemask specifies
one or more node IDs that are greater than the maximum
supported node ID. Or, none of the node IDs specified by
nodemask are on-line and allowed by the thread's current
cpuset context, or none of the specified nodes contain
memory. Or, the mode argument specified both
MPOL_F_STATIC_NODES and MPOL_F_RELATIVE_NODES.
EIO MPOL_MF_STRICT was specified and an existing page was
already on a node that does not follow the policy; or
MPOL_MF_MOVE or MPOL_MF_MOVE_ALL was specified and the
kernel was unable to move all existing pages in the range.
ENOMEM Insufficient kernel memory was available.
EPERM The flags argument included the MPOL_MF_MOVE_ALL flag and
the caller does not have the CAP_SYS_NICE privilege.
VERSIONS
The mbind() system call was added to the Linux kernel in version
2.6.7.
CONFORMING TO
This system call is Linux-specific.
NOTES
Glibc does not provide a wrapper for this system call. For
information on library support, see numa(7).
NUMA policy is not supported on a memory-mapped file range that
was mapped with the MAP_SHARED flag.
The MPOL_DEFAULT mode can have different effects for mbind() and
set_mempolicy(2). When MPOL_DEFAULT is specified for
set_mempolicy(2), the thread's memory policy reverts to the
system default policy or local allocation. When MPOL_DEFAULT is
specified for a range of memory using mbind(), any pages
subsequently allocated for that range will use the thread's
memory policy, as set by set_mempolicy(2). This effectively
removes the explicit policy from the specified range, "falling
back" to a possibly nondefault policy. To select explicit "local
allocation" for a memory range, specify a mode of MPOL_LOCAL or
MPOL_PREFERRED with an empty set of nodes. This method will work
for set_mempolicy(2), as well.
Support for huge page policy was added with 2.6.16. For
interleave policy to be effective on huge page mappings the
policied memory needs to be tens of megabytes or larger.
Before Linux 5.7. MPOL_MF_STRICT was ignored on huge page
mappings.
MPOL_MF_MOVE and MPOL_MF_MOVE_ALL are available only on Linux
2.6.16 and later.
SEE ALSO
get_mempolicy(2), getcpu(2), mmap(2), set_mempolicy(2), shmat(2), shmget(2), numa(3), cpuset(7), numa(7), numactl(8)
COLOPHON
This page is part of release 5.11 of the Linux man-pages project.
A description of the project, information about reporting bugs,
and the latest version of this page, can be found at
https://www.kernel.org/doc/man-pages/.
Linux 2021-03-22 MBIND(2)
Pages that refer to this page: getcpu(2), get_mempolicy(2), migrate_pages(2), move_pages(2), set_mempolicy(2), swapon(2), syscalls(2), numa(3), proc(5), capabilities(7), cpuset(7), numa(7), migratepages(8), numactl(8)
numa(3)
NUMA(3) Linux Programmer's Manual NUMA(3)
NAME
numa - NUMA policy library
SYNOPSIS
#include <numa.h>
cc ... -lnuma
int numa_available(void);
int numa_max_possible_node(void);
int numa_num_possible_nodes();
int numa_max_node(void);
int numa_num_configured_nodes();
struct bitmask *numa_get_mems_allowed(void);
int numa_num_configured_cpus(void);
struct bitmask *numa_all_nodes_ptr;
struct bitmask *numa_no_nodes_ptr;
struct bitmask *numa_all_cpus_ptr;
int numa_num_task_cpus();
int numa_num_task_nodes();
int numa_parse_bitmap(char *line , struct bitmask *mask);
struct bitmask *numa_parse_nodestring(const char *string);
struct bitmask *numa_parse_nodestring_all(const char *string);
struct bitmask *numa_parse_cpustring(const char *string);
struct bitmask *numa_parse_cpustring_all(const char *string);
long numa_node_size(int node, long *freep);
long long numa_node_size64(int node, long long *freep);
int numa_preferred(void);
void numa_set_preferred(int node);
int numa_get_interleave_node(void);
struct bitmask *numa_get_interleave_mask(void);
void numa_set_interleave_mask(struct bitmask *nodemask);
void numa_interleave_memory(void *start, size_t size, struct
bitmask *nodemask);
void numa_bind(struct bitmask *nodemask);
void numa_set_localalloc(void);
void numa_set_membind(struct bitmask *nodemask);
void numa_set_membind_balancing(struct bitmask *nodemask);
struct bitmask *numa_get_membind(void);
void *numa_alloc_onnode(size_t size, int node);
void *numa_alloc_local(size_t size);
void *numa_alloc_interleaved(size_t size);
void *numa_alloc_interleaved_subset(size_t size, struct bitmask
*nodemask); void *numa_alloc(size_t size);
void *numa_realloc(void *old_addr, size_t old_size, size_t
new_size);
void numa_free(void *start, size_t size);
int numa_run_on_node(int node);
int numa_run_on_node_mask(struct bitmask *nodemask);
int numa_run_on_node_mask_all(struct bitmask *nodemask);
struct bitmask *numa_get_run_node_mask(void);
void numa_tonode_memory(void *start, size_t size, int node);
void numa_tonodemask_memory(void *start, size_t size, struct
bitmask *nodemask);
void numa_setlocal_memory(void *start, size_t size);
void numa_police_memory(void *start, size_t size);
void numa_set_bind_policy(int strict);
void numa_set_strict(int strict);
int numa_distance(int node1, int node2);
int numa_sched_getaffinity(pid_t pid, struct bitmask *mask);
int numa_sched_setaffinity(pid_t pid, struct bitmask *mask);
int numa_node_to_cpus(int node, struct bitmask *mask);
void numa_node_to_cpu_update();
int numa_node_of_cpu(int cpu);
struct bitmask *numa_allocate_cpumask();
void numa_free_cpumask();
struct bitmask *numa_allocate_nodemask();
void numa_free_nodemask();
struct bitmask *numa_bitmask_alloc(unsigned int n);
struct bitmask *numa_bitmask_clearall(struct bitmask *bmp);
struct bitmask *numa_bitmask_clearbit(struct bitmask *bmp,
unsigned int n);
int numa_bitmask_equal(const struct bitmask *bmp1, const struct
bitmask *bmp2);
void numa_bitmask_free(struct bitmask *bmp);
int numa_bitmask_isbitset(const struct bitmask *bmp, unsigned int
n);
unsigned int numa_bitmask_nbytes(struct bitmask *bmp);
struct bitmask *numa_bitmask_setall(struct bitmask *bmp);
struct bitmask *numa_bitmask_setbit(struct bitmask *bmp, unsigned
int n);
void copy_bitmask_to_nodemask(struct bitmask *bmp, nodemask_t
*nodemask)
void copy_nodemask_to_bitmask(nodemask_t *nodemask, struct
bitmask *bmp)
void copy_bitmask_to_bitmask(struct bitmask *bmpfrom, struct
bitmask *bmpto)
unsigned int numa_bitmask_weight(const struct bitmask *bmp )
int numa_move_pages(int pid, unsigned long count, void **pages,
const int *nodes, int *status, int flags);
int numa_migrate_pages(int pid, struct bitmask *fromnodes, struct
bitmask *tonodes);
void numa_error(char *where);
extern int numa_exit_on_error;
extern int numa_exit_on_warn;
void numa_warn(int number, char *where, ...);DESCRIPTION
The libnuma library offers a simple programming interface to the
NUMA (Non Uniform Memory Access) policy supported by the Linux
kernel. On a NUMA architecture some memory areas have different
latency or bandwidth than others.
Available policies are page interleaving (i.e., allocate in a
round-robin fashion from all, or a subset, of the nodes on the
system), preferred node allocation (i.e., preferably allocate on
a particular node), local allocation (i.e., allocate on the node
on which the task is currently executing), or allocation only on
specific nodes (i.e., allocate on some subset of the available
nodes). It is also possible to bind tasks to specific nodes.
Numa memory allocation policy may be specified as a per-task
attribute, that is inherited by children tasks and processes, or
as an attribute of a range of process virtual address space.
Numa memory policies specified for a range of virtual address
space are shared by all tasks in the process. Furthermore,
memory policies specified for a range of a shared memory attached
using shmat(2) or mmap(2) from shmfs/hugetlbfs are shared by all
processes that attach to that region. Memory policies for shared
disk backed file mappings are currently ignored.
The default memory allocation policy for tasks and all memory
range is local allocation. This assumes that no ancestor has
installed a non-default policy.
For setting a specific policy globally for all memory allocations
in a process and its children it is easiest to start it with the
numactl(8) utility. For more finegrained policy inside an
application this library can be used.
All numa memory allocation policy only takes effect when a page
is actually faulted into the address space of a process by
accessing it. The numa_alloc_* functions take care of this
automatically.
A node is defined as an area where all memory has the same speed
as seen from a particular CPU. A node can contain multiple CPUs.
Caches are ignored for this definition.
Most functions in this library are only concerned about numa
nodes and their memory. The exceptions to this are:
numa_node_to_cpus(), numa_node_to_cpu_update(),
numa_node_of_cpu(), numa_bind(), numa_run_on_node(),
numa_run_on_node_mask(), numa_run_on_node_mask_all(), and
numa_get_run_node_mask(). These functions deal with the CPUs
associated with numa nodes. See the descriptions below for more
information.
Some of these functions accept or return a pointer to struct
bitmask. A struct bitmask controls a bit map of arbitrary length
containing a bit representation of nodes. The predefined
variable numa_all_nodes_ptr points to a bit mask that has all
available nodes set; numa_no_nodes_ptr points to the empty set.
Before any other calls in this library can be used
numa_available() must be called. If it returns -1, all other
functions in this library are undefined.
numa_max_possible_node() returns the number of the highest
possible node in a system. In other words, the size of a kernel
type nodemask_t (in bits) minus 1. This number can be gotten by
calling numa_num_possible_nodes() and subtracting 1.
numa_num_possible_nodes() returns the size of kernel's node mask
(kernel type nodemask_t). In other words, large enough to
represent the maximum number of nodes that the kernel can handle.
This will match the kernel's MAX_NUMNODES value. This count is
derived from /proc/self/status, field Mems_allowed.
numa_max_node() returns the highest node number available on the
current system. (See the node numbers in
/sys/devices/system/node/ ). Also see
numa_num_configured_nodes().
numa_num_configured_nodes() returns the number of memory nodes in
the system. This count includes any nodes that are currently
disabled. This count is derived from the node numbers in
/sys/devices/system/node. (Depends on the kernel being configured
with /sys (CONFIG_SYSFS)).
numa_get_mems_allowed() returns the mask of nodes from which the
process is allowed to allocate memory in it's current cpuset
context. Any nodes that are not included in the returned bitmask
will be ignored in any of the following libnuma memory policy
calls.
numa_num_configured_cpus() returns the number of cpus in the
system. This count includes any cpus that are currently
disabled. This count is derived from the cpu numbers in
/sys/devices/system/cpu. If the kernel is configured without /sys
(CONFIG_SYSFS=n) then it falls back to using the number of online
cpus.
numa_all_nodes_ptr points to a bitmask that is allocated by the
library with bits representing all nodes on which the calling
task may allocate memory. This set may be up to all nodes on the
system, or up to the nodes in the current cpuset. The bitmask is
allocated by a call to numa_allocate_nodemask() using size
numa_max_possible_node(). The set of nodes to record is derived
from /proc/self/status, field "Mems_allowed". The user should
not alter this bitmask.
numa_no_nodes_ptr points to a bitmask that is allocated by the
library and left all zeroes. The bitmask is allocated by a call
to numa_allocate_nodemask() using size numa_max_possible_node().
The user should not alter this bitmask.
numa_all_cpus_ptr points to a bitmask that is allocated by the
library with bits representing all cpus on which the calling task
may execute. This set may be up to all cpus on the system, or up
to the cpus in the current cpuset. The bitmask is allocated by a
call to numa_allocate_cpumask() using size
numa_num_possible_cpus(). The set of cpus to record is derived
from /proc/self/status, field "Cpus_allowed". The user should
not alter this bitmask.
numa_num_task_cpus() returns the number of cpus that the calling
task is allowed to use. This count is derived from the map
/proc/self/status, field "Cpus_allowed". Also see the bitmask
numa_all_cpus_ptr.
numa_num_task_nodes() returns the number of nodes on which the
calling task is allowed to allocate memory. This count is
derived from the map /proc/self/status, field "Mems_allowed".
Also see the bitmask numa_all_nodes_ptr.
numa_parse_bitmap() parses line , which is a character string
such as found in /sys/devices/system/node/nodeN/cpumap into a
bitmask structure. The string contains the hexadecimal
representation of a bit map. The bitmask may be allocated with
numa_allocate_cpumask(). Returns 0 on success. Returns -1 on
failure. This function is probably of little use to a user
application, but it is used by libnuma internally.
numa_parse_nodestring() parses a character string list of nodes
into a bit mask. The bit mask is allocated by
numa_allocate_nodemask(). The string is a comma-separated list
of node numbers or node ranges. A leading ! can be used to
indicate "not" this list (in other words, all nodes except this
list), and a leading + can be used to indicate that the node
numbers in the list are relative to the task's cpuset. The
string can be "all" to specify all ( numa_num_task_nodes() )
nodes. Node numbers are limited by the number in the system.
See numa_max_node() and numa_num_configured_nodes().
Examples: 1-5,7,10 !4-5 +0-3
If the string is of 0 length, bitmask numa_no_nodes_ptr is
returned. Returns 0 if the string is invalid.
numa_parse_nodestring_all() is similar to numa_parse_nodestring ,
but can parse all possible nodes, not only current nodeset.
numa_parse_cpustring() parses a character string list of cpus
into a bit mask. The bit mask is allocated by
numa_allocate_cpumask(). The string is a comma-separated list of
cpu numbers or cpu ranges. A leading ! can be used to indicate
"not" this list (in other words, all cpus except this list), and
a leading + can be used to indicate that the cpu numbers in the
list are relative to the task's cpuset. The string can be "all"
to specify all ( numa_num_task_cpus() ) cpus. Cpu numbers are
limited by the number in the system. See numa_num_task_cpus()
and numa_num_configured_cpus().
Examples: 1-5,7,10 !4-5 +0-3
Returns 0 if the string is invalid.
numa_parse_cpustring_all() is similar to numa_parse_cpustring ,
but can parse all possible cpus, not only current cpuset.
numa_node_size() returns the memory size of a node. If the
argument freep is not NULL, it used to return the amount of free
memory on the node. On error it returns -1.
numa_node_size64() works the same as numa_node_size() except that
it returns values as long long instead of long. This is useful
on 32-bit architectures with large nodes.
numa_preferred() returns the preferred node of the current task.
This is the node on which the kernel preferably allocates memory,
unless some other policy overrides this.
numa_set_preferred() sets the preferred node for the current task
to node. The system will attempt to allocate memory from the
preferred node, but will fall back to other nodes if no memory is
available on the the preferred node. Passing a node of -1
argument specifies local allocation and is equivalent to calling
numa_set_localalloc().
numa_get_interleave_mask() returns the current interleave mask if
the task's memory allocation policy is page interleaved.
Otherwise, this function returns an empty mask.
numa_set_interleave_mask() sets the memory interleave mask for
the current task to nodemask. All new memory allocations are
page interleaved over all nodes in the interleave mask.
Interleaving can be turned off again by passing an empty mask
(numa_no_nodes). The page interleaving only occurs on the actual
page fault that puts a new page into the current address space.
It is also only a hint: the kernel will fall back to other nodes
if no memory is available on the interleave target.
numa_interleave_memory() interleaves size bytes of memory page by
page from start on nodes specified in nodemask. The size
argument will be rounded up to a multiple of the system page
size. If nodemask contains nodes that are externally denied to
this process, this call will fail. This is a lower level
function to interleave allocated but not yet faulted in memory.
Not yet faulted in means the memory is allocated using mmap(2) or
shmat(2), but has not been accessed by the current process yet.
The memory is page interleaved to all nodes specified in
nodemask. Normally numa_alloc_interleaved() should be used for
private memory instead, but this function is useful to handle
shared memory areas. To be useful the memory area should be
several megabytes at least (or tens of megabytes of hugetlbfs
mappings) If the numa_set_strict() flag is true then the
operation will cause a numa_error if there were already pages in
the mapping that do not follow the policy.
numa_bind() binds the current task and its children to the nodes
specified in nodemask. They will only run on the CPUs of the
specified nodes and only be able to allocate memory from them.
This function is equivalent to calling
numa_run_on_node_mask(nodemask) followed by
numa_set_membind(nodemask). If tasks should be bound to
individual CPUs inside nodes consider using numa_node_to_cpus and
the sched_setaffinity(2) syscall.
numa_set_localalloc() sets the memory allocation policy for the
calling task to local allocation. In this mode, the preferred
node for memory allocation is effectively the node where the task
is executing at the time of a page allocation.
numa_set_membind() sets the memory allocation mask. The task
will only allocate memory from the nodes set in 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.
numa_set_membind_balancing() sets the memory allocation mask and
enable the Linux kernel NUMA balancing for the task if the
feature is supported by the kernel. The task will only allocate
memory from the nodes set in 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.
numa_get_membind() returns the mask of nodes from which memory
can currently be allocated. If the returned mask is equal to
numa_all_nodes, then memory allocation is allowed from all nodes.
numa_alloc_onnode() allocates memory on a specific node. The
size argument will be rounded up to a multiple of the system page
size. if the specified node is externally denied to this
process, this call will fail. This function is relatively slow
compared to the malloc(3), family of functions. The memory must
be freed with numa_free(). On errors NULL is returned.
numa_alloc_local() allocates size bytes of memory on the local
node. The size argument will be rounded up to a multiple of the
system page size. This function is relatively slow compared to
the malloc(3) family of functions. The memory must be freed with
numa_free(). On errors NULL is returned.
numa_alloc_interleaved() allocates size bytes of memory page
interleaved on all nodes. This function is relatively slow and
should only be used for large areas consisting of multiple pages.
The interleaving works at page level and will only show an effect
when the area is large. The allocated memory must be freed with
numa_free(). On error, NULL is returned.
numa_alloc_interleaved_subset() attempts to allocate size bytes
of memory page interleaved on all nodes. The size argument will
be rounded up to a multiple of the system page size. The nodes
on which a process is allowed to allocate memory may be
constrained externally. If this is the case, this function may
fail. This function is relatively slow compare to malloc(3),
family of functions and should only be used for large areas
consisting of multiple pages. The interleaving works at page
level and will only show an effect when the area is large. The
allocated memory must be freed with numa_free(). On error, NULL
is returned.
numa_alloc() allocates size bytes of memory with the current NUMA
policy. The size argument will be rounded up to a multiple of
the system page size. This function is relatively slow compare
to the malloc(3) family of functions. The memory must be freed
with numa_free(). On errors NULL is returned.
numa_realloc() changes the size of the memory area pointed to by
old_addr from old_size to new_size. The memory area pointed to
by old_addr must have been allocated with one of the numa_alloc*
functions. The new_size will be rounded up to a multiple of the
system page size. The contents of the memory area will be
unchanged to the minimum of the old and new sizes; newly
allocated memory will be uninitialized. The memory policy (and
node bindings) associated with the original memory area will be
preserved in the resized area. For example, if the initial area
was allocated with a call to numa_alloc_onnode(), then the new
pages (if the area is enlarged) will be allocated on the same
node. However, if no memory policy was set for the original
area, then numa_realloc() cannot guarantee that the new pages
will be allocated on the same node. On success, the address of
the resized area is returned (which might be different from that
of the initial area), otherwise NULL is returned and errno is set
to indicate the error. The pointer returned by numa_realloc() is
suitable for passing to numa_free().
numa_free() frees size bytes of memory starting at start,
allocated by the numa_alloc_* functions above. The size argument
will be rounded up to a multiple of the system page size.
numa_run_on_node() runs the current task and its children on a
specific node. They will not migrate to CPUs of other nodes until
the node affinity is reset with a new call to
numa_run_on_node_mask(). Passing -1 permits the kernel to
schedule on all nodes again. On success, 0 is returned; on error
-1 is returned, and errno is set to indicate the error.
numa_run_on_node_mask() runs the current task and its children
only on nodes specified in nodemask. They will not migrate to
CPUs of other nodes until the node affinity is reset with a new
call to numa_run_on_node_mask() or numa_run_on_node(). Passing
numa_all_nodes permits the kernel to schedule on all nodes again.
On success, 0 is returned; on error -1 is returned, and errno is
set to indicate the error.
numa_run_on_node_mask_all() runs the current task and its
children only on nodes specified in nodemask like
numa_run_on_node_mask but without any cpuset awareness.
numa_get_run_node_mask() returns a mask of CPUs on which the
current task is allowed to run.
numa_tonode_memory() put memory on a specific node. The
constraints described for numa_interleave_memory() apply here
too.
numa_tonodemask_memory() put memory on a specific set of nodes.
The constraints described for numa_interleave_memory() apply here
too.
numa_setlocal_memory() locates memory on the current node. The
constraints described for numa_interleave_memory() apply here
too.
numa_police_memory() locates memory with the current NUMA policy.
The constraints described for numa_interleave_memory() apply here
too.
numa_distance() reports the distance in the machine topology
between two nodes. The factors are a multiple of 10. It returns
0 when the distance cannot be determined. A node has distance 10
to itself. Reporting the distance requires a Linux kernel
version of 2.6.10 or newer.
numa_set_bind_policy() specifies whether calls that bind memory
to a specific node should use the preferred policy or a strict
policy. The preferred policy allows the kernel to allocate
memory on other nodes when there isn't enough free on the target
node. strict will fail the allocation in that case. Setting the
argument to specifies strict, 0 preferred. Note that specifying
more than one node non strict may only use the first node in some
kernel versions.
numa_set_strict() sets a flag that says whether the functions
allocating on specific nodes should use use a strict policy.
Strict means the allocation will fail if the memory cannot be
allocated on the target node. Default operation is to fall back
to other nodes. This doesn't apply to interleave and default.
numa_get_interleave_node() is used by libnuma internally. It is
probably not useful for user applications. It uses the
MPOL_F_NODE flag of the get_mempolicy system call, which is not
intended for application use (its operation may change or be
removed altogether in future kernel versions). See
get_mempolicy(2).
numa_pagesize() returns the number of bytes in page. This
function is simply a fast alternative to repeated calls to the
getpagesize system call. See getpagesize(2).
numa_sched_getaffinity() retrieves a bitmask of the cpus on which
a task may run. The task is specified by pid. Returns the
return value of the sched_getaffinity system call. See
sched_getaffinity(2). The bitmask must be at least the size of
the kernel's cpu mask structure. Use numa_allocate_cpumask() to
allocate it. Test the bits in the mask by calling
numa_bitmask_isbitset().
numa_sched_setaffinity() sets a task's allowed cpu's to those
cpu's specified in mask. The task is specified by pid. Returns
the return value of the sched_setaffinity system call. See
sched_setaffinity(2). You may allocate the bitmask with
numa_allocate_cpumask(). Or the bitmask may be smaller than the
kernel's cpu mask structure. For example, call
numa_bitmask_alloc() using a maximum number of cpus from
numa_num_configured_cpus(). Set the bits in the mask by calling
numa_bitmask_setbit().
numa_node_to_cpus() converts a node number to a bitmask of CPUs.
The user must pass a bitmask structure with a mask buffer long
enough to represent all possible cpu's. Use
numa_allocate_cpumask() to create it. If the bitmask is not long
enough errno will be set to ERANGE and -1 returned. On success 0
is returned.
numa_node_to_cpu_update() Mark cpus bitmask of all nodes stale,
then get the latest bitmask by calling numa_node_to_cpus() This
allows to update the libnuma state after a CPU hotplug event. The
application is in charge of detecting CPU hotplug events.
numa_node_of_cpu() returns the node that a cpu belongs to. If the
user supplies an invalid cpu errno will be set to EINVAL and -1
will be returned.
numa_allocate_cpumask () returns a bitmask of a size equal to the
kernel's cpu mask (kernel type cpumask_t). In other words, large
enough to represent NR_CPUS cpus. This number of cpus can be
gotten by calling numa_num_possible_cpus(). The bitmask is zero-
filled.
numa_free_cpumask frees a cpumask previously allocate by
numa_allocate_cpumask.
numa_allocate_nodemask() returns a bitmask of a size equal to the
kernel's node mask (kernel type nodemask_t). In other words,
large enough to represent MAX_NUMNODES nodes. This number of
nodes can be gotten by calling numa_num_possible_nodes(). The
bitmask is zero-filled.
numa_free_nodemask() frees a nodemask previous allocated by
numa_allocate_nodemask().
numa_bitmask_alloc() allocates a bitmask structure and its
associated bit mask. The memory allocated for the bit mask
contains enough words (type unsigned long) to contain n bits.
The bit mask is zero-filled. The bitmask structure points to the
bit mask and contains the n value.
numa_bitmask_clearall() sets all bits in the bit mask to 0. The
bitmask structure points to the bit mask and contains its size (
bmp ->size). The value of bmp is always returned. Note that
numa_bitmask_alloc() creates a zero-filled bit mask.
numa_bitmask_clearbit() sets a specified bit in a bit mask to 0.
Nothing is done if the n value is greater than the size of the
bitmask (and no error is returned). The value of bmp is always
returned.
numa_bitmask_equal() returns 1 if two bitmasks are equal. It
returns 0 if they are not equal. If the bitmask structures
control bit masks of different sizes, the "missing" trailing bits
of the smaller bit mask are considered to be 0.
numa_bitmask_free() deallocates the memory of both the bitmask
structure pointed to by bmp and the bit mask. It is an error to
attempt to free this bitmask twice.
numa_bitmask_isbitset() returns the value of a specified bit in a
bit mask. If the n value is greater than the size of the bit
map, 0 is returned.
numa_bitmask_nbytes() returns the size (in bytes) of the bit mask
controlled by bmp. The bit masks are always full words (type
unsigned long), and the returned size is the actual size of all
those words.
numa_bitmask_setall() sets all bits in the bit mask to 1. The
bitmask structure points to the bit mask and contains its size (
bmp ->size). The value of bmp is always returned.
numa_bitmask_setbit() sets a specified bit in a bit mask to 1.
Nothing is done if n is greater than the size of the bitmask (and
no error is returned). The value of bmp is always returned.
copy_bitmask_to_nodemask() copies the body (the bit map itself)
of the bitmask structure pointed to by bmp to the nodemask_t
structure pointed to by the nodemask pointer. If the two areas
differ in size, the copy is truncated to the size of the
receiving field or zero-filled.
copy_nodemask_to_bitmask() copies the nodemask_t structure
pointed to by the nodemask pointer to the body (the bit map
itself) of the bitmask structure pointed to by the bmp pointer.
If the two areas differ in size, the copy is truncated to the
size of the receiving field or zero-filled.
copy_bitmask_to_bitmask() copies the body (the bit map itself) of
the bitmask structure pointed to by the bmpfrom pointer to the
body of the bitmask structure pointed to by the bmpto pointer. If
the two areas differ in size, the copy is truncated to the size
of the receiving field or zero-filled.
numa_bitmask_weight() returns a count of the bits that are set in
the body of the bitmask pointed to by the bmp argument.
numa_move_pages() moves a list of pages in the address space of
the currently executing or current process. It simply uses the
move_pages system call.
pid - ID of task. If not valid, use the current task.
count - Number of pages.
pages - List of pages to move.
nodes - List of nodes to which pages can be moved.
status - Field to which status is to be returned.
flags - MPOL_MF_MOVE or MPOL_MF_MOVE_ALL
See move_pages(2).
numa_migrate_pages() simply uses the migrate_pages system call to
cause the pages of the calling task, or a specified task, to be
migated from one set of nodes to another. See migrate_pages(2).
The bit masks representing the nodes should be allocated with
numa_allocate_nodemask() , or with numa_bitmask_alloc() using an
n value returned from numa_num_possible_nodes(). A task's
current node set can be gotten by calling numa_get_membind().
Bits in the tonodes mask can be set by calls to
numa_bitmask_setbit().
numa_error() is a libnuma internal function that can be
overridden by the user program. This function is called with a
char * argument when a libnuma function fails. Overriding the
library internal definition makes it possible to specify a
different error handling strategy when a libnuma function fails.
It does not affect numa_available(). The numa_error() function
defined in libnuma prints an error on stderr and terminates the
program if numa_exit_on_error is set to a non-zero value. The
default value of numa_exit_on_error is zero.
numa_warn() is a libnuma internal function that can be also
overridden by the user program. It is called to warn the user
when a libnuma function encounters a non-fatal error. The
default implementation prints a warning to stderr. The first
argument is a unique number identifying each warning. After that
there is a printf(3)-style format string and a variable number of
arguments. numa_warn exits the program when numa_exit_on_warn is
set to a non-zero value. The default value of numa_exit_on_warn
is zero.
Compatibility with libnuma version 1
Binaries that were compiled for libnuma version 1 need not be re-
compiled to run with libnuma version 2.
Source codes written for libnuma version 1 may be re-compiled
without change with version 2 installed. To do so, in the code's
Makefile add this option to CFLAGS:
-DNUMA_VERSION1_COMPATIBILITY
THREAD SAFETY
numa_set_bind_policy and numa_exit_on_error are process global.
The other calls are thread safe.
COPYRIGHT
Copyright 2002, 2004, 2007, 2008 Andi Kleen, SuSE Labs. libnuma
is under the GNU Lesser General Public License, v2.1.
SEE ALSO
get_mempolicy(2), set_mempolicy(2), getpagesize(2), mbind(2), mmap(2), shmat(2), numactl(8), sched_getaffinity(2) sched_setaffinity(2) move_pages(2) migrate_pages(2)
COLOPHON
This page is part of the numactl (NUMA commands) project.
Information about the project can be found at
〈http://oss.sgi.com/projects/libnuma/〉. If you have a bug report
for this manual page, send it to linux-numa@vger.kernel.org.
This page was obtained from the project's upstream Git repository
〈https://github.com/numactl/numactl.git〉 on 2021-04-01. (At that
time, the date of the most recent commit that was found in the
repository was 2021-03-31.) If you discover any rendering
problems in this HTML version of the page, or you believe there
is a better or more up-to-date source for the page, or you have
corrections or improvements to the information in this COLOPHON
(which is not part of the original manual page), send a mail to
man-pages@man7.org
SuSE Labs December 2007 NUMA(3)
Pages that refer to this page: get_mempolicy(2), mbind(2), migrate_pages(2), move_pages(2), set_mempolicy(2), numa(7), numastat(8)
扫一扫
2215
到【灌水乐园】发言
