openYuanrong：多语言运行时独立部署以库集成简化 Serverless 架构 & 拓扑感知调度：提升函数运行时性能

黑臂麒麟2026-03-19 23:35

一、传统 Serverless 的痛点

在传统的 Serverless 架构中，运行时通常采用独立进程或容器化的部署方式。这种模式存在以下问题：

1. 架构复杂
2. 通信开销大
3. 运维门槛高

二、openYuanrong 的设计理念

2. 核心优势
零通信开销：
  • 函数调用直接在进程内完成
  • 无需序列化/反序列化
  • 无进程间通信（IPC）
简化运维：
  • 无需管理独立的运行时进程
  • SDK 随用户程序一起启动和停止
  • 资源由用户进程统一管理
部署简单：
Python 部署步骤

我的系统是Ubuntu 24.04 的 Python 是系统管理的，安装了

py 复制代码 
# 1. 激活 conda 环境
source ~/miniconda/etc/profile.d/conda.sh
conda activate yr

查看 Python 版本

python 复制代码 
python3 --version

安装 openYuanrong

py 复制代码 
pip install https://openyuanrong.obs.cn-southwest-2.myhuaweicloud.com/release/0.7.0/linux/x86_64/openyuanrong-0.7.0-cp311-cp311-manylinux_2_34_x86_64.whl
py 复制代码 
验证 yr 命令
yr version
查看 Python SDK 路径
python -c "import yr; import os; print(os.path.dirname(yr.__file__))"
C++ 部署步骤
查看 C++ SDK 结构
bash 复制代码 
ls -la /home/test/miniconda/envs/yr/lib/python3.11/site-packages/yr/inner/runtime/sdk/cpp/
创建项目目录
bash 复制代码 
mkdir -p ~/cpp_demo
cd ~/cpp_demo
创建 CMakeLists.txt和创建 main.cpp
bash 复制代码 
cat > CMakeLists.txt << 'EOF'
cmake_minimum_required(VERSION 3.10)
project(cpp_demo)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# openYuanrong SDK 路径
set(YR_INSTALL_PATH "/home/test/miniconda/envs/yr/lib/python3.11/site-packages/yr/inner/runtime/sdk/cpp")

include_directories(${YR_INSTALL_PATH}/include)
link_directories(${YR_INSTALL_PATH}/lib)
set(CMAKE_INSTALL_RPATH "${YR_INSTALL_PATH}/lib")
set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)

add_executable(demo main.cpp)
target_link_libraries(demo yr-api functionsdk datasystem litebus)
EOF


cat > main.cpp << 'EOF'
#include <iostream>
#include <yr/yr.h>

int main() {
    std::cout << "openYuanrong C++ Demo" << std::endl;
    
    YR::Config conf;
    conf.mode = YR::Config::LOCAL_MODE;
    YR::Init(conf);
    
    std::cout << "openYuanrong initialized successfully!" << std::endl;
    
    YR::Finalize();
    std::cout << "Demo completed!" << std::endl;
    return 0;
}
EOF
bash 复制代码 
# 编译
mkdir -p build && cd build
cmake ..
make

# 运行
export LD_LIBRARY_PATH=/home/test/miniconda/envs/yr/lib/python3.11/site-packages/yr/inner/runtime/sdk/cpp/lib:$LD_LIBRARY_PATH
./demo


运行成功输出
Java SDK 部署教程
bash 复制代码 
# 查看 Java SDK 文件
ls -la /home/test/miniconda/envs/yr/lib/python3.11/site-packages/yr/inner/runtime/sdk/java/
bash 复制代码 
# 创建 Java 项目
mkdir -p ~/java_demo
cd ~/java_demo
bash 复制代码 
# 创建 Java 源文件
mkdir -p src/main/java/demo

cat > src/main/java/demo/Demo.java << 'EOF'
package demo;

import org.yuanrong.YR;
import org.yuanrong.Config;

public class Demo {
    public static void main(String[] args) {
        System.out.println("openYuanrong Java Demo");
        
        // 配置本地模式
        Config config = new Config();
        config.setMode(Config.Mode.LOCAL_MODE);
        
        // 初始化
        YR.init(config);
        
        System.out.println("openYuanrong initialized successfully!");
        
        // 清理
        YR.finalize();
        
        System.out.println("Demo completed!");
    }
}
EOF

我这里用的nano，你们用linux也可以

bash 复制代码 
# 设置 SDK 路径
SDK_PATH=/home/test/miniconda/envs/yr/lib/python3.11/site-packages/yr/inner/runtime/sdk/java

# 编译
javac -cp $SDK_PATH/yr-api-sdk-0.7.0.jar:$SDK_PATH/faas-function-sdk-0.7.0.jar \
    src/main/java/demo/Demo.java

# 运行
java -cp $SDK_PATH/yr-api-sdk-0.7.0.jar:$SDK_PATH/faas-function-sdk-0.7.0.jar:src/main/java demo.Demo
三种语言 SDK 对比
特性 Python SDK C++ SDK Java SDK
形式 Python 模块 + .so 库 头文件 + 动态库 JAR 包
大小 约 100MB 97MB 15MB
安装方式 pip install CMake 链接 Maven 依赖
初始化 yr.init() YR::Init() YR.init()

openYuanrong 拓扑感知调度：提升函数运行时性能

一、什么是拓扑感知调度

1. NUMA 架构基础

现代多核服务器通常采用 NUMA（Non-Uniform Memory Access） 架构，即"非统一内存访问"架构。

核心特点：
  • 每个 NUMA 节点有自己的本地内存
  • 访问本地内存速度快
  • 跨 NUMA 访问内存速度慢（延迟高 2-3 倍）
2. 拓扑层级

openYuanrong 支持多级拓扑感知：

3. 为什么需要拓扑感知调度

问题场景：

二、openYuanrong 的拓扑感知调度

层级 说明 示例
Node NUMA 节点 node0, node1
Socket CPU 插槽 socket0, socket1
Core 物理核心 core0 - core19
L1/L2/L3 Cache 缓存层级 共享或独立
1. 调度亲和性 API

openYuanrong 提供了丰富的调度亲和性 API：

bash 复制代码 
from yr.affinity import (
    Affinity, 
    AffinityKind, 
    AffinityType, 
    AffinityScope,
    LabelOperator, 
    OperatorType
)
亲和性类型：
类型 说明 使用场景
PREFERRED 优先满足 尽量调度到指定节点
REQUIRED 必须满足 必须调度到指定节点
PREFERRED_ANTI 优先避开 尽量避开指定节点
REQUIRED_ANTI 必须避开 必须避开指定节点
亲和性作用域：
作用域 说明
POD POD 级别实例亲和
NODE NODE 级别实例亲和
2. 使用示例

示例 1：优先调度到特定 NUMA 节点

bash 复制代码 
import yr
from yr.affinity import (
    Affinity, AffinityKind, AffinityType,
    LabelOperator, OperatorType
)

# 初始化
yr.init()

# 创建拓扑亲和性
affinity = Affinity(
    affinity_kind=AffinityKind.RESOURCE,
    affinity_type=AffinityType.PREFERRED,
    label_operators=[
        LabelOperator(OperatorType.LABEL_IN, "numa_node", ["node0"])
    ]
)

# 定义分布式函数
@yr.invoke(affinities=[affinity])
def compute(data):
    return data * 2

# 调用
result = compute.invoke(10)
value = yr.get(result)
print(f"Result: {value}")

# 清理
yr.finalize()

结果：

示例 2：必须调度到有 GPU 的节点

bash 复制代码 
import yr
from yr.affinity import (
    Affinity, AffinityKind, AffinityType,
    LabelOperator, OperatorType
)

yr.init()

# 标签存在：gpu
gpu_affinity = Affinity(
    affinity_kind=AffinityKind.RESOURCE,
    affinity_type=AffinityType.REQUIRED,
    label_operators=[
        LabelOperator(OperatorType.LABEL_EXISTS, "gpu", [])
    ]
)

@yr.invoke(affinities=[gpu_affinity])
def gpu_compute(data):
    # GPU 计算任务
    return process_on_gpu(data)

运行结果：

示例 3：实例亲和（函数间通信优化）

bash 复制代码 
import yr
from yr.affinity import (
    Affinity, AffinityKind, AffinityType,
    LabelOperator, OperatorType, AffinityScope
)

yr.init()

# 让多个函数实例运行在同一节点，减少网络通信
instance_affinity = Affinity(
    affinity_kind=AffinityKind.INSTANCE,
    affinity_type=AffinityType.PREFERRED,
    label_operators=[
        LabelOperator(OperatorType.LABEL_EXISTS, "same_node", [])
    ],
    affinity_scope=AffinityScope.NODE
)

@yr.invoke(affinities=[instance_affinity])
def process(data):
    return data

这个是三个示例的全部结果。

复制代码 
python affinity_demo.py          → Result: 20
python gpu_affinity_demo.py      → Result: 20
python instance_affinity_demo.py → Result: 20

总结

多语言运行时独立部署

openYuanrong 的多语言运行时独立部署方案，通过库集成的设计理念，有效解决了传统 Serverless 架构的痛点：

对比项 传统 Serverless openYuanrong
架构复杂度 多进程协作 单进程集成
通信开销 IPC + 序列化 零开销
运维门槛 高（需管理运行时） 低（SDK 随程序启动）
冷启动延迟 毫秒~秒级 微秒级
部署方式 容器/VM 库依赖
核心优势：
  1. 零通信开销 - 函数调用直接在进程内完成，无需序列化/反序列化
  2. 简化运维 - SDK 随用户程序一起启动和停止，无需管理独立进程
  3. 多语言支持 - Python、C++、Java 三种 SDK，满足不同开发需求
  4. 轻量部署 - Python 约 100MB、C++ 97MB、Java 仅 15MB

这种设计特别适合：

  • 高性能计算（HPC）：需要低延迟的函数调用
  • 边缘计算：资源受限，需要轻量级部署
  • 企业应用：希望简化运维复杂度的场景
拓扑感知调度

openYuanrong 的拓扑感知调度功能，通过感知底层硬件拓扑结构，智能地将函数调度到最优的计算节点：

优化点 效果
减少跨 NUMA 内存访问 降低内存延迟
提升缓存命中率 提高计算效率
减少网络通信 降低函数间调用延迟
核心特性：
  1. 多级拓扑感知 - 支持 Node、Socket、NUMA node 等层级
  2. 灵活的亲和性配置 - PREFERRED/REQUIRED/PREFERRED_ANTI/REQUIRED_ANTI 四种类型
  3. 多种作用域 - 支持 POD 级别和 NODE 级别实例亲和
  4. 多语言 API - Python 和 C++ 均提供完整的调度亲和性 API
适用场景：
场景 推荐配置
HPC 高性能计算 绑定到特定 NUMA 节点（REQUIRED）
AI 推理 调度到有 GPU 的节点（REQUIRED + LABEL_EXISTS）
大数据处理 函数和数据在同一节点（INSTANCE + NODE 作用域）
微服务 服务间频繁通信，部署在同一节点（INSTANCE + PREFERRED）

这对于 HPC 高性能计算、AI 推理、大数据处理 等场景尤为重要，可以显著提升函数运行时性能

相关推荐
XiaoLeisj2 小时前
Android Jetpack 页面架构实战：从 LiveData、ViewModel 到 DataBinding 的生命周期管理与数据绑定
android·java·架构·android jetpack·livedata·viewmodel·databinding
⑩-2 小时前
为什么要用消息队列？使用场景？
java·rabbitmq
似水明俊德2 小时前
01-C#.Net-泛型-面试题
java·开发语言·面试·c#·.net
leonkay2 小时前
Golang语言闭包完全指南
开发语言·数据结构·后端·算法·架构·golang
Allnadyy2 小时前
【C++项目】从零实现高并发内存池（一）：核心原理与设计思路
java·开发语言·jvm
浑水摸鱼仙君2 小时前
SpringSecurity和Flux同时使用报未认证问题
java·ai·flux·springsecurity·springai
一叶飘零_sweeeet3 小时前
Java 线程模型底层解密：从内核原理到生产级架构选型，全链路实战指南
java· java线程模型
am心3 小时前
企业开发项目流程记录
java
独自破碎E4 小时前
前后端分离+微服务架构下的用户认证
java·面试·架构
热门推荐
01GitHub 镜像站点02Qwen3.5 开源全解析：从 0.8B 到 397B，代际升级 + 全场景选型指南03OpenClaw 使用和管理 MCP 完全指南04UV安装并设置国内源05AI 编程三剑客：Spec-Kit、OpenSpec、Superpowers 深度对比与实战指南06Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services07OpenClaw Control UI安全上下文访问配置08小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）09OpenClaw macOS 完整安装与本地模型配置教程（实战版）10让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南