Chapel与Python互操作：如何实现自定义结构体跨语言调用？

方案1：以C头文件为桥梁共享类型定义 #

Chapel和Python都能很好地与C交互，通过在C头文件中统一结构体定义，可避免两端重复编写类型：

1. 编写C头文件point.h：

typedef struct {
    double x;
    double y;
} Point;

void add_one(Point* p);

2. Chapel代码实现逻辑并引用头文件：

extern require "point.h";

proc add_one(p: c_ptr(Point)) {
    p.x += 1.0;
    p.y += 1.0;
}

// 编译为共享库：chpl --shared point.chpl -o libpoint.so

3. Python端通过ctypes复用C结构体定义：

from dataclasses import dataclass
import ctypes

# 加载Chapel编译的共享库
lib = ctypes.CDLL("./libpoint.so")

# 映射C结构体到Python
class PointCTypes(ctypes.Structure):
    _fields_ = [("x", ctypes.c_double), ("y", ctypes.c_double)]

# 包装为dataclass方便业务代码使用
@dataclass
class Point:
    x: float
    y: float

    def to_ctypes(self):
        return PointCTypes(self.x, self.y)

    @classmethod
    def from_ctypes(cls, p):
        return cls(p.x, p.y)

# 声明函数参数类型
lib.add_one.argtypes = [ctypes.POINTER(PointCTypes)]
lib.add_one.restype = None

# 使用示例
p = Point(1.0, 2.0)
ctypes_p = p.to_ctypes()
lib.add_one(ctypes.byref(ctypes_p))
result = Point.from_ctypes(ctypes_p)
print(result)  # 输出 Point(x=2.0, y=3.0)

嵌套结构体可按同样方式在C头文件中定义，两端直接复用，无需重复编写。

方案2：用Chapel自动生成Python类型绑定 #

利用Chapel的反射能力，编写脚本自动生成对应Python dataclass和ctypes绑定代码，避免手动映射：

1. 编写Chapel脚本生成绑定代码：

record Point {
    var x: real;
    var y: real;
}

proc generatePythonBindings(r: type) {
    var code = "@dataclass\nclass " + r.name + ":\n";
    for field in r.fields {
        code += "    " + field.name + ": float\n";
    }
    code += "\nimport ctypes\n";
    code += "class " + r.name + "CTypes(ctypes.Structure):\n";
    code += "    _fields_ = [";
    var fieldsList = [];
    for field in r.fields {
        fieldsList.add('("' + field.name + '", ctypes.c_double)');
    }
    code += ", ".join(fieldsList) + "]\n";
    code += "\n    def to_dataclass(self):\n";
    code += "        return " + r.name + "(";
    var argsList = [];
    for field in r.fields {
        argsList.add(field.name + "=self." + field.name);
    }
    code += ", ".join(argsList) + ")\n";
    code += "\n@classmethod\n";
    code += "def from_dataclass(cls, dc):\n";
    code += "    return cls(";
    var dcArgs = [];
    for field in r.fields {
        dcArgs.add("dc." + field.name);
    }
    code += ", ".join(dcArgs) + ")\n";
    code += r.name + "CTypes.from_dataclass = from_dataclass\n";
    return code;
}

writeln(generatePythonBindings(Point));

运行脚本会输出完整的Python绑定代码，直接复制到项目中即可。

2. Chapel主代码导出C兼容函数：

extern proc add_one(p: c_ptr(Point)) {
    p.x += 1.0;
    p.y += 1.0;
}

// 编译为共享库：chpl --shared add_point.chpl -o libaddpoint.so

3. Python端使用生成的绑定代码调用：

# 粘贴生成的绑定代码
@dataclass
class Point:
    x: float
    y: float

import ctypes
class PointCTypes(ctypes.Structure):
    _fields_ = [("x", ctypes.c_double), ("y", ctypes.c_double)]

    def to_dataclass(self):
        return Point(x=self.x, y=self.y)

@classmethod
def from_dataclass(cls, dc):
    return cls(dc.x, dc.y)

PointCTypes.from_dataclass = from_dataclass

# 加载共享库并调用
lib = ctypes.CDLL("./libaddpoint.so")
lib.add_one.argtypes = [ctypes.POINTER(PointCTypes)]
lib.add_one.restype = None

p = Point(1.0, 2.0)
ctypes_p = PointCTypes.from_dataclass(p)
lib.add_one(ctypes.byref(ctypes_p))
result = ctypes_p.to_dataclass()
print(result)

方案3：用numpy数组批量处理结构体（适合大数据场景） #

如果是批量处理结构体数组，可将结构体字段拆分为numpy数组传递给Chapel，性能更优：

1. Chapel代码处理数组：

proc add_one_to_points(xs: []real, ys: []real) {
    for i in xs.domain {
        xs[i] += 1.0;
        ys[i] += 1.0;
    }
}

// 编译为共享库：chpl --shared batch_points.chpl -o libbatch.so

2. Python端用numpy传递数据：

from dataclasses import dataclass
import numpy as np
import ctypes

@dataclass
class Point:
    x: float
    y: float

# 加载共享库
lib = ctypes.CDLL("./libbatch.so")

# 声明函数参数类型
lib.add_one_to_points.argtypes = [
    np.ctypeslib.ndpointer(dtype=np.float64, ndim=1, flags='C_CONTIGUOUS'),
    np.ctypeslib.ndpointer(dtype=np.float64, ndim=1, flags='C_CONTIGUOUS')
]
lib.add_one_to_points.restype = None

# 批量处理示例
points = [Point(1.0,2.0), Point(3.0,4.0)]
xs = np.array([p.x for p in points], dtype=np.float64)
ys = np.array([p.y for p in points], dtype=np.float64)

lib.add_one_to_points(xs, ys)

# 转换回dataclass
result_points = [Point(xs[i], ys[i]) for i in range(len(xs))]
print(result_points)

内容的提问来源于stack exchange，提问作者ninivert