NUMA感知内存分配：libnuma在PHP扩展中实现跨节点内存访问优化

NUMA 感知内存分配：libnuma 在 PHP 扩展中实现跨节点内存访问优化

大家好，今天我们来深入探讨一个提升 PHP 应用性能的利器：NUMA（Non-Uniform Memory Access）感知内存分配。 尤其是在高并发、大数据处理等场景下，合理利用 NUMA 架构的优势，可以显著降低内存访问延迟，从而提高整体性能。

1. NUMA 架构简介：理解内存访问延迟的根源

传统的 SMP（Symmetric Multi-Processing）架构中，所有处理器共享同一块物理内存，所有 CPU 访问内存的速度是相同的。 然而，随着 CPU 核心数量的增加，这种共享内存架构逐渐暴露出瓶颈，主要体现在内存访问延迟上。

NUMA 架构应运而生，它将物理内存划分为多个节点（Node），每个节点包含一部分内存和一组处理器。 每个处理器可以直接访问其本地节点上的内存，速度最快。 访问其他节点上的内存则需要通过节点间的互连总线，速度较慢。 这就是“Non-Uniform Memory Access”的由来。

特性	SMP	NUMA
内存访问速度	统一	非统一
内存分配	集中式	分布式
适用场景	CPU核心数较少	CPU核心数较多
优势	简单易用	降低内存访问延迟，提高并行处理能力
劣势	内存访问延迟可能较高	编程复杂度较高

2. NUMA 对 PHP 应用的影响：性能瓶颈分析

PHP 作为一种解释型语言，其内存管理主要依赖 Zend 引擎。 在多核服务器上，PHP 应用通常会创建多个进程或线程来处理并发请求。 如果 PHP 应用没有针对 NUMA 架构进行优化，那么可能会出现以下问题：

• 跨节点内存访问频繁： 不同进程/线程可能运行在不同的 NUMA 节点上，如果它们频繁访问共享数据，就可能导致大量的跨节点内存访问，增加延迟。
• 内存分配不均匀： Zend 引擎默认的内存分配策略可能不会考虑 NUMA 架构，导致内存分配不均匀，某些节点上的内存压力过大。
• 缓存一致性问题： NUMA 架构下，不同节点上的处理器拥有各自的缓存。 如果多个处理器同时访问同一块内存，就需要保证缓存的一致性，这会增加额外的开销。

3. libnuma：NUMA 感知编程的利器

libnuma 是一个 Linux 平台上的库，它提供了一组 API，用于查询和控制 NUMA 架构下的内存分配和处理器亲和性。 通过 libnuma，我们可以编写 NUMA 感知的应用程序，从而优化内存访问性能。

libnuma 主要提供以下功能：

• 查询 NUMA 架构信息： 例如，查询系统中有多少个 NUMA 节点，每个节点包含多少内存。
• 控制内存分配： 例如，在指定的 NUMA 节点上分配内存，或者在所有节点上均匀分配内存。
• 控制处理器亲和性： 例如，将某个进程/线程绑定到指定的 NUMA 节点上运行。

4. PHP 扩展开发：集成 libnuma 实现 NUMA 感知内存分配

为了让 PHP 应用能够利用 libnuma 的优势，我们需要开发一个 PHP 扩展。 下面是一个简单的示例，演示如何在 PHP 扩展中使用 libnuma 分配内存：

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_numa.h"
#include <numa.h>

ZEND_DECLARE_MODULE_GLOBALS(numa)

PHP_INI_BEGIN()
    STD_PHP_INI_ENTRY("numa.default_node", "-1", PHP_INI_ALL, OnUpdateLong, default_node, zend_numa_globals, numa_globals)
PHP_INI_END()

static PHP_MINIT_FUNCTION(numa)
{
    ZEND_INIT_MODULE_GLOBALS(numa, zend_numa_globals, NULL, NULL);
    REGISTER_INI_ENTRIES();

    if (numa_available() < 0) {
        php_printf("NUMA is not available on this system.n");
        return FAILURE;
    }

    return SUCCESS;
}

static PHP_MSHUTDOWN_FUNCTION(numa)
{
    UNREGISTER_INI_ENTRIES();
    return SUCCESS;
}

static PHP_MINFO_FUNCTION(numa)
{
    php_info_print_table_start();
    php_info_print_table_header(2, "numa support", "enabled");
    php_info_print_table_end();

    DISPLAY_INI_ENTRIES();
}

PHP_FUNCTION(numa_allocate)
{
    long size;
    long node = NUMA_G(default_node);
    void *ptr;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &size, &node) == FAILURE) {
        RETURN_NULL();
    }

    if (node < -1 || node >= numa_num_configured_nodes()) {
        php_error_docref(NULL, E_WARNING, "Invalid NUMA node ID: %ld", node);
        RETURN_NULL();
    }

    if (node == -1) { // Allocate on all nodes
        ptr = numa_alloc(size);
    } else {
        ptr = numa_alloc_onnode(size, node);
    }

    if (ptr == NULL) {
        RETURN_NULL();
    }

    RETURN_RES(zend_resource_create(ptr, le_numa_memory));
}

PHP_FUNCTION(numa_free)
{
    zval *res;
    void *ptr;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &res) == FAILURE) {
        RETURN_FALSE;
    }

    ptr = zend_fetch_resource2(Z_RES_P(res), PHP_NUMA_RESOURCE_NAME, le_numa_memory, le_numa_memory);

    if (ptr == NULL) {
        RETURN_FALSE;
    }

    numa_free(ptr, numa_alloc_size(ptr));
    zend_resource_destroy(Z_RES_P(res));

    RETURN_TRUE;
}

PHP_FUNCTION(numa_node_of_address) {
    void *addr;
    zval *res;

    if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &res) == FAILURE) {
        RETURN_LONG(-1);
    }

    addr = zend_fetch_resource2(Z_RES_P(res), PHP_NUMA_RESOURCE_NAME, le_numa_memory, le_numa_memory);

    if (addr == NULL) {
        RETURN_LONG(-1);
    }
    int node = numa_node_of_ptr(addr);
    RETURN_LONG(node);
}

PHP_FUNCTION(numa_get_number_of_nodes)
{
    RETURN_LONG(numa_num_configured_nodes());
}

static void php_numa_memory_dtor(zend_resource *rsrc) {
    void *ptr = Z_RES_PTR(rsrc);
    if(ptr) {
        numa_free(ptr, numa_alloc_size(ptr));
    }
}

static const zend_function_entry numa_functions[] = {
    PHP_FE(numa_allocate,  NULL)
    PHP_FE(numa_free,      NULL)
    PHP_FE(numa_node_of_address, NULL)
    PHP_FE(numa_get_number_of_nodes, NULL)
    PHP_FE_END
};

static ZEND_RSRC_DTOR_FUNC(php_numa_memory_dtor);

static int le_numa_memory;

zend_module_entry numa_module_entry = {
    STANDARD_MODULE_HEADER,
    "numa",
    numa_functions,
    PHP_MINIT(numa),
    PHP_MSHUTDOWN(numa),
    NULL,
    NULL,
    PHP_MINFO(numa),
    PHP_NUMA_VERSION,
    STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_NUMA
#ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
#endif
ZEND_GET_MODULE(numa)
#endif

static ZEND_RSRC_DTOR_FUNC(php_numa_memory_dtor)
{
    void *ptr = Z_RES_PTR(rsrc);
    if (ptr) {
        numa_free(ptr, numa_alloc_size(ptr));
    }
}

static PHP_MINIT_FUNCTION(numa)
{
    le_numa_memory = zend_register_resource_ex(PHP_NUMA_RESOURCE_NAME, &php_numa_memory_dtor, module_number);

    ZEND_INIT_MODULE_GLOBALS(numa, zend_numa_globals, NULL, NULL);
    REGISTER_INI_ENTRIES();

    if (numa_available() < 0) {
        php_printf("NUMA is not available on this system.n");
        return FAILURE;
    }

    return SUCCESS;
}

numa.h:

#ifndef PHP_NUMA_H
#define PHP_NUMA_H

#define PHP_NUMA_VERSION "0.1.0"
#define PHP_NUMA_EXTNAME "numa"
#define PHP_NUMA_RESOURCE_NAME "numa_memory"

extern zend_module_entry numa_module_entry;
#define phpext_numa_ptr &numa_module_entry

#ifdef PHP_WIN32
#define PHP_NUMA_API __declspec(dllexport)
#else
#define PHP_NUMA_API
#endif

#ifdef ZTS
#include "TSRM.h"
#endif

/* Always refer to the globals in your function as NUMA_G(variable).
   You are encouraged to rename these macros something shorter, see
   examples in any other php extension source. */
#define NUMA_G(v) TSRMG(numa_globals_id, zend_numa_globals *, v)

typedef struct _zend_numa_globals {
    zend_long default_node;
} zend_numa_globals;

ZEND_EXTERN_MODULE_GLOBALS(numa)

#endif  /* PHP_NUMA_H */

步骤说明:

1. 包含头文件： 首先，我们需要包含 php.h 和 numa.h 头文件。
2. 检查 NUMA 支持： 在 PHP_MINIT_FUNCTION 中，我们使用 numa_available() 函数检查系统是否支持 NUMA。
3. 注册资源类型： 使用 zend_register_resource_ex 注册一个资源类型，用于管理 NUMA 分配的内存。
4. 实现 numa_allocate 函数： 这个函数接收两个参数：size (要分配的内存大小) 和 node (NUMA 节点 ID)。 如果 node 为 -1，则在所有节点上分配内存；否则，在指定的节点上分配内存。
   • 使用 numa_alloc_onnode() 或 numa_alloc() 分配内存。
   • 使用 zend_resource_create() 创建一个资源，并将分配的内存地址存储在资源中。
   • 返回资源 ID。
5. 实现 numa_free 函数： 这个函数接收一个资源 ID 作为参数，释放该资源对应的 NUMA 内存。
   • 使用 zend_fetch_resource2() 获取资源对应的内存地址。
   • 使用 numa_free() 释放内存。
   • 使用 zend_resource_destroy() 销毁资源。
6. 实现 numa_node_of_address 函数： 这个函数接收一个资源ID作为参数，返回该资源对应的内存地址所在的NUMA节点ID
   • 使用 zend_fetch_resource2() 获取资源对应的内存地址。
   • 使用 numa_node_of_ptr() 获取内存地址所在的NUMA节点ID。
   • 返回节点ID。
7. 实现 numa_get_number_of_nodes 函数： 这个函数返回系统中配置的NUMA节点数量。
   • 使用 numa_num_configured_nodes() 获取节点数量。
   • 返回节点数量。
8. 配置 INI 选项： 使用 PHP_INI_BEGIN 和 PHP_INI_END 定义一个 INI 选项 numa.default_node，用于设置默认的 NUMA 节点 ID。 这个选项允许用户在 php.ini 文件中指定默认的 NUMA 节点，以便在调用 numa_allocate 函数时，如果不指定节点 ID，则使用默认节点。
9. 资源析构函数： 实现 php_numa_memory_dtor 函数，在资源被销毁时释放 NUMA 内存。

5. 使用示例：在 PHP 代码中调用 NUMA 扩展

编译并安装扩展后，就可以在 PHP 代码中使用 numa_allocate 和 numa_free 函数了：

<?php

// 获取 NUMA 节点数量
$num_nodes = numa_get_number_of_nodes();
echo "Number of NUMA nodes: " . $num_nodes . "n";

// 在 NUMA 节点 0 上分配 1MB 内存
$memory = numa_allocate(1024 * 1024, 0);

if ($memory) {
    echo "Memory allocated on NUMA node 0.n";
    //获取内存所在的NUMA节点
    $node = numa_node_of_address($memory);
    echo "Memory is located on NUMA node: " . $node . "n";

    // 释放内存
    numa_free($memory);
    echo "Memory freed.n";
} else {
    echo "Failed to allocate memory.n";
}

// 使用默认节点分配内存 (需要在 php.ini 中设置 numa.default_node)
$memory2 = numa_allocate(512 * 1024);

if($memory2) {
    echo "Memory allocated using default NUMA node.n";
    //释放内存
    numa_free($memory2);
    echo "Memory freed.n";

} else {
    echo "Failed to allocate memory using default node.n";
}
?>

6. 优化策略：提升 NUMA 感知 PHP 应用的性能

除了使用 libnuma 分配内存之外，还可以采取其他策略来优化 NUMA 感知 PHP 应用的性能：

• 进程/线程绑定： 将 PHP 进程/线程绑定到特定的 NUMA 节点上运行，可以减少跨节点内存访问的频率。可以使用 numa_run_on_node() 或 numa_set_localalloc() 函数来实现进程/线程绑定。
• 数据本地化： 尽量将数据存储在与访问它的进程/线程相同的 NUMA 节点上，可以提高内存访问速度。 可以通过在创建对象或数组时，使用 numa_allocate 函数在指定的节点上分配内存来实现数据本地化。
• 共享内存： 对于需要在多个进程/线程之间共享的数据，可以使用共享内存技术。 在 NUMA 架构下，可以将共享内存分配在多个节点上，以减少单个节点的内存压力。
• 负载均衡： 将请求均匀地分配到不同的 NUMA 节点上，可以避免某些节点的负载过高。可以使用负载均衡器来实现请求的均匀分配。

7. 性能测试：验证 NUMA 优化的效果

在实施 NUMA 优化之后，需要进行性能测试来验证优化效果。 可以使用各种性能测试工具，例如 ApacheBench、Siege 等，来模拟高并发场景，并测量应用的响应时间、吞吐量等指标。

通过对比优化前后的性能数据，可以评估 NUMA 优化带来的收益。

8. 注意事项与潜在问题

• 平台兼容性： libnuma 是 Linux 平台上的库，因此该扩展只能在 Linux 系统上运行。
• NUMA 架构依赖： 只有在 NUMA 架构的服务器上，NUMA 优化才能发挥作用。
• 代码复杂度： NUMA 感知编程会增加代码的复杂度，需要仔细设计和测试。
• 错误处理： 在使用 libnuma API 时，需要注意错误处理，例如检查内存分配是否成功。
• 资源管理： 确保及时释放 NUMA 分配的内存，避免内存泄漏。
• 配置正确性： 确保 numa.default_node 等 INI 选项配置正确，否则可能导致程序行为异常。

9. 总结: 充分利用NUMA架构，编写高性能PHP应用

通过开发 PHP 扩展，并集成 libnuma 库，我们可以实现 NUMA 感知的内存分配，从而优化 PHP 应用的性能。结合进程/线程绑定、数据本地化等策略，可以进一步提升 NUMA 感知 PHP 应用的性能。

10. 未来方向：持续优化，提升PHP在高并发场景下的表现

NUMA 感知内存分配只是提升 PHP 应用性能的一种手段。 未来，我们可以继续探索其他的优化方向，例如：

• 更智能的内存分配策略： 可以根据应用的实际运行情况，动态调整内存分配策略，以适应不同的负载。
• 自动 NUMA 感知： 可以开发更高级的工具，自动检测 NUMA 架构，并自动进行优化，从而降低开发人员的负担。
• 与其他技术的结合： 可以将 NUMA 优化与其他性能优化技术结合起来，例如 OPcache、JIT 编译器等，以获得更好的性能。

希望今天的分享能帮助大家更好地理解 NUMA 架构，并在 PHP 应用开发中充分利用 NUMA 的优势，编写出更高性能的应用。 谢谢大家！