l0n0lacl 0.0.1__tar.gz

l0n0lacl-0.0.1/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.1
+Name: l0n0lacl
+Version: 0.0.1
+Summary: 用于调用ascendc编写的算子
+Author: l0n0l
+Author-email: 1038352856@qq.com
+Keywords: acl,ascendc,算子,算子开发
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7, <4
+Description-Content-Type: text/markdown
+Requires-Dist: colorama
+Requires-Dist: numpy
+
+# 1 功能描述
+由于在ascendc算子开发过程中运行算子比较复杂，为了简化算子的运行，将运行算子变成可以用python直接调用的函数。所以编写了此代码。
+
+# 2 安装
+```
+pip install l0n0lacl
+```
+
+# 3 运行算子实例
+## 3.1 先切换到cann环境,比如我的环境是:
+```
+source /home/HwHiAiUser/Ascend/ascend-toolkit/set_env.sh
+```
+## 3.2 先安装我们编写的算子
+```
+bash custom_opp_xxx_aarch64.run
+```
+## 3.3 创建算子运行器
+```python
+from l0n0lacl import *
+ascendc_gelu = OpRunner("Gelu", op_path_prefix='customize')
+```
+
+## 3.4 调用算子
+### 3.4.1 先看调用传参顺序
+在算子工程编译后，会有代码生成，在算子工程目录:
+`${算子目录}/build_out/autogen/aclnn_xxx.h`中可以找到`aclnnXXXGetWorkspaceSize`函数。以Gelu为例：
+```c++
+__attribute__((visibility("default")))
+aclnnStatus aclnnGeluGetWorkspaceSize(
+    const aclTensor *x,
+    const aclTensor *out,
+    uint64_t *workspaceSize,
+    aclOpExecutor **executor);
+```
+可以看到参数为 `x`, `out`, `workspaceSize`, `executor`。其中 `workspaceSize`, `executor`不需要管。
+* `aclTensor*`对应`numpy.ndarray`
+* 其他参考: <a href = "https://docs.python.org/zh-cn/3/library/ctypes.html#fundamental-data-types">ctypes类型</a>
+### 3.4.2 调用算子
+```python
+import torch
+from l0n0lacl import *
+ascendc_gelu = OpRunner("Gelu", op_path_prefix='customize')
+target_dtype = torch.float
+x = torch.empty(shape, dtype=target_dtype).uniform_(-1, 1)
+y = torch.empty(shape, dtype=target_dtype).zero_()
+out = ascendc_gelu(x.numpy(), y.numpy()).to_cpu()
+print(out)
+```
+
+# 4. api参考
+## 4.1 AclNDTensor
+```python
+class AclNDTensor:
+    def __init__(self, np_array: np.ndarray):
+        pass
+    def to_cpu(self):
+        pass
+```
+numpy ndarray与ascend nd tensor间的桥梁
+### 4.1.1 `__init__`
+* `np_array`: numpy的tensor
+### 4.1.2 `to_cpu`
+将运算结果从npu拷贝到cpu
+## 4.2 OpRunner
+```python
+class OpRunner:
+    def __init__(self, name, op_path_prefix='customize', op_path=None, device_id=0) -> None:
+        pass
+    def __call__(self, *args, outCout=1, argtypes=None, stream=None) -> Union[AclNDTensor, List[AclNDTensor]]:
+        pass
+    def sync_stream(self)->None:
+        pass
+```
+### 4.2.1 `__init__`
+* `name`:算子名称，
+* `op_path_prefix`: 算子工程中**CMakePresets.json**文件中**vender_name**的值。默认是`customize`,可以不传
+```json
+"vendor_name": {
+    "type": "STRING",
+    "value": "customize"
+},
+```
+* `op_path`: 算子`libcust_opapi.so`库的绝对位置。不传。
+* `device_id`: 设备ID。默认`0`
+
+### 4.2.2 `__call__`
+* `args`: 表示传给`aclnnXXXGetWorkspaceSize`除了`workspaceSize`, `executor`的参数
+* `outCout` : 表示算子的输出个数。如果出处个数为`1`,返回一个`AclNDTensor`。如果输出个数大于1,返回`List[AclNDTensor]`
+* `argtypes`: 表示`aclnnXXXGetWorkspaceSize`的参数`ctypes`参数类型，对于特别复杂的算子，如果发现调用异常，可以手动指定类型。
+比如(**仅用于举例，其实可以不传，自动推导就可运行。但是当发现运行异常的情况下，可以自己指定**)，对于:
+```c++
+__attribute__((visibility("default")))
+aclnnStatus aclnnCumsumGetWorkspaceSize(
+    const aclTensor *x,
+    const aclTensor *axis,
+    bool exclusiveOptional,
+    bool reverseOptional,
+    const aclTensor *out,
+    uint64_t *workspaceSize,
+    aclOpExecutor **executor);
+```
+
+```python
+import ctypes
+from l0n0lacl import *
+ascendc_cumsum = OpRunner("Cumsum")
+target_dtype = np.float32
+data_range = (-10, 10)
+shape = [100, 3, 2304]
+axis_py = 1
+exclusive = True
+reverse = False
+x = np.random.uniform(*data_range, shape).astype(target_dtype)
+axis = np.array([axis_py]).astype(np.int32)
+golden: np.ndarray = tf.cumsum(x, axis_py, exclusive, reverse, argtypes=[
+    ctypes.c_void_p, # x
+    ctypes.c_void_p, # axis
+    ctypes.c_bool,   # exclusiveOptional
+    ctypes.c_bool,   # reverseOptional
+    ctypes.c_void_p, # out
+    ctypes.c_void_p, # workspaceSize
+    ctypes.c_void_p, # executor
+]).numpy()
+y = np.ones_like(golden, golden.dtype) * 123
+ascendc_cumsum(x, axis, exclusive, reverse,  y).to_cpu()
+print(y)
+```
+* `stream` 如果是多stream的情况下，可以自己指定stream:
+例如:
+```python
+import ctypes
+import tensorflow as tf
+from l0n0lacl import *
+ascendc_cumsum = OpRunner("Cumsum")
+target_dtype = np.float32
+data_range = (-10, 10)
+shape = [100, 3, 2304]
+axis_py = 1
+exclusive = True
+reverse = False
+x = np.random.uniform(*data_range, shape).astype(target_dtype)
+axis = np.array([axis_py]).astype(np.int32)
+golden: np.ndarray = tf.cumsum(x, axis_py, exclusive, reverse).numpy()
+y = np.ones_like(golden, golden.dtype) * 123
+ascendc_cumsum(x, axis, exclusive, reverse,  y, argtypes=[
+    ctypes.c_void_p, # x
+    ctypes.c_void_p, # axis
+    ctypes.c_bool,   # exclusiveOptional
+    ctypes.c_bool,   # reverseOptional
+    ctypes.c_void_p, # out
+    ctypes.c_void_p, # workspaceSize
+    ctypes.c_void_p, # executor
+]).to_cpu()
+verify_result(y, golden)
+print(y)
+```
+
+### 4.2.3 `sync_stream`
+用于同步stream
+
+## 4.3 verify_result
+参考自：https://gitee.com/ascend/samples/blob/master/operator/AddCustomSample/KernelLaunch/AddKernelInvocationNeo/scripts/verify_result.py
+```python
+def verify_result(real_result:numpy.ndarray, golden:numpy.ndarray):
+    pass
+```
+判断精度是否符合
+float16: 千分之一
+float32: 万分之一
+int16,int32,int8: 0

l0n0lacl-0.0.1/README.md

@@ -0,0 +1,171 @@
+# 1 功能描述
+由于在ascendc算子开发过程中运行算子比较复杂，为了简化算子的运行，将运行算子变成可以用python直接调用的函数。所以编写了此代码。
+
+# 2 安装
+```
+pip install l0n0lacl
+```
+
+# 3 运行算子实例
+## 3.1 先切换到cann环境,比如我的环境是:
+```
+source /home/HwHiAiUser/Ascend/ascend-toolkit/set_env.sh
+```
+## 3.2 先安装我们编写的算子
+```
+bash custom_opp_xxx_aarch64.run
+```
+## 3.3 创建算子运行器
+```python
+from l0n0lacl import *
+ascendc_gelu = OpRunner("Gelu", op_path_prefix='customize')
+```
+
+## 3.4 调用算子
+### 3.4.1 先看调用传参顺序
+在算子工程编译后，会有代码生成，在算子工程目录:
+`${算子目录}/build_out/autogen/aclnn_xxx.h`中可以找到`aclnnXXXGetWorkspaceSize`函数。以Gelu为例：
+```c++
+__attribute__((visibility("default")))
+aclnnStatus aclnnGeluGetWorkspaceSize(
+    const aclTensor *x,
+    const aclTensor *out,
+    uint64_t *workspaceSize,
+    aclOpExecutor **executor);
+```
+可以看到参数为 `x`, `out`, `workspaceSize`, `executor`。其中 `workspaceSize`, `executor`不需要管。
+* `aclTensor*`对应`numpy.ndarray`
+* 其他参考: <a href = "https://docs.python.org/zh-cn/3/library/ctypes.html#fundamental-data-types">ctypes类型</a>
+### 3.4.2 调用算子
+```python
+import torch
+from l0n0lacl import *
+ascendc_gelu = OpRunner("Gelu", op_path_prefix='customize')
+target_dtype = torch.float
+x = torch.empty(shape, dtype=target_dtype).uniform_(-1, 1)
+y = torch.empty(shape, dtype=target_dtype).zero_()
+out = ascendc_gelu(x.numpy(), y.numpy()).to_cpu()
+print(out)
+```
+
+# 4. api参考
+## 4.1 AclNDTensor
+```python
+class AclNDTensor:
+    def __init__(self, np_array: np.ndarray):
+        pass
+    def to_cpu(self):
+        pass
+```
+numpy ndarray与ascend nd tensor间的桥梁
+### 4.1.1 `__init__`
+* `np_array`: numpy的tensor
+### 4.1.2 `to_cpu`
+将运算结果从npu拷贝到cpu
+## 4.2 OpRunner
+```python
+class OpRunner:
+    def __init__(self, name, op_path_prefix='customize', op_path=None, device_id=0) -> None:
+        pass
+    def __call__(self, *args, outCout=1, argtypes=None, stream=None) -> Union[AclNDTensor, List[AclNDTensor]]:
+        pass
+    def sync_stream(self)->None:
+        pass
+```
+### 4.2.1 `__init__`
+* `name`:算子名称，
+* `op_path_prefix`: 算子工程中**CMakePresets.json**文件中**vender_name**的值。默认是`customize`,可以不传
+```json
+"vendor_name": {
+    "type": "STRING",
+    "value": "customize"
+},
+```
+* `op_path`: 算子`libcust_opapi.so`库的绝对位置。不传。
+* `device_id`: 设备ID。默认`0`
+
+### 4.2.2 `__call__`
+* `args`: 表示传给`aclnnXXXGetWorkspaceSize`除了`workspaceSize`, `executor`的参数
+* `outCout` : 表示算子的输出个数。如果出处个数为`1`,返回一个`AclNDTensor`。如果输出个数大于1,返回`List[AclNDTensor]`
+* `argtypes`: 表示`aclnnXXXGetWorkspaceSize`的参数`ctypes`参数类型，对于特别复杂的算子，如果发现调用异常，可以手动指定类型。
+比如(**仅用于举例，其实可以不传，自动推导就可运行。但是当发现运行异常的情况下，可以自己指定**)，对于:
+```c++
+__attribute__((visibility("default")))
+aclnnStatus aclnnCumsumGetWorkspaceSize(
+    const aclTensor *x,
+    const aclTensor *axis,
+    bool exclusiveOptional,
+    bool reverseOptional,
+    const aclTensor *out,
+    uint64_t *workspaceSize,
+    aclOpExecutor **executor);
+```
+
+```python
+import ctypes
+from l0n0lacl import *
+ascendc_cumsum = OpRunner("Cumsum")
+target_dtype = np.float32
+data_range = (-10, 10)
+shape = [100, 3, 2304]
+axis_py = 1
+exclusive = True
+reverse = False
+x = np.random.uniform(*data_range, shape).astype(target_dtype)
+axis = np.array([axis_py]).astype(np.int32)
+golden: np.ndarray = tf.cumsum(x, axis_py, exclusive, reverse, argtypes=[
+    ctypes.c_void_p, # x
+    ctypes.c_void_p, # axis
+    ctypes.c_bool,   # exclusiveOptional
+    ctypes.c_bool,   # reverseOptional
+    ctypes.c_void_p, # out
+    ctypes.c_void_p, # workspaceSize
+    ctypes.c_void_p, # executor
+]).numpy()
+y = np.ones_like(golden, golden.dtype) * 123
+ascendc_cumsum(x, axis, exclusive, reverse,  y).to_cpu()
+print(y)
+```
+* `stream` 如果是多stream的情况下，可以自己指定stream:
+例如:
+```python
+import ctypes
+import tensorflow as tf
+from l0n0lacl import *
+ascendc_cumsum = OpRunner("Cumsum")
+target_dtype = np.float32
+data_range = (-10, 10)
+shape = [100, 3, 2304]
+axis_py = 1
+exclusive = True
+reverse = False
+x = np.random.uniform(*data_range, shape).astype(target_dtype)
+axis = np.array([axis_py]).astype(np.int32)
+golden: np.ndarray = tf.cumsum(x, axis_py, exclusive, reverse).numpy()
+y = np.ones_like(golden, golden.dtype) * 123
+ascendc_cumsum(x, axis, exclusive, reverse,  y, argtypes=[
+    ctypes.c_void_p, # x
+    ctypes.c_void_p, # axis
+    ctypes.c_bool,   # exclusiveOptional
+    ctypes.c_bool,   # reverseOptional
+    ctypes.c_void_p, # out
+    ctypes.c_void_p, # workspaceSize
+    ctypes.c_void_p, # executor
+]).to_cpu()
+verify_result(y, golden)
+print(y)
+```
+
+### 4.2.3 `sync_stream`
+用于同步stream
+
+## 4.3 verify_result
+参考自：https://gitee.com/ascend/samples/blob/master/operator/AddCustomSample/KernelLaunch/AddKernelInvocationNeo/scripts/verify_result.py
+```python
+def verify_result(real_result:numpy.ndarray, golden:numpy.ndarray):
+    pass
+```
+判断精度是否符合
+float16: 千分之一
+float32: 万分之一
+int16,int32,int8: 0

l0n0lacl-0.0.1/l0n0lacl/AclNDTensor.py

@@ -0,0 +1,93 @@
+from .utils import *
+
+
+def build_acl_libnnopbase_path():
+    ascend_home_path = os.environ["ASCEND_HOME_PATH"]
+    lib_path = f"{ascend_home_path}/aarch64-linux/lib64/libnnopbase.so"
+    return lib_path
+
+
+libnnopbase = ctypes.CDLL(build_acl_libnnopbase_path())
+# ACL_FUNC_VISIBILITY aclTensor * aclCreateTensor(
+#     const int64_t * viewDims,
+#     uint64_t viewDimsNum,
+#     aclDataType dataType,
+#     const int64_t * stride,
+#     int64_t offset,
+#     aclFormat format,
+#     const int64_t * storageDims,
+#     uint64_t storageDimsNum,
+#     void * tensorData)
+libnnopbase.aclCreateTensor.argtypes = [
+    ctypes.c_void_p,  # viewDims
+    ctypes.c_uint64,  # viewDimsNum
+    ctypes.c_int,    # dataType
+    ctypes.c_void_p,  # stride
+    ctypes.c_int64,  # offset
+    ctypes.c_int,    # format
+    ctypes.c_void_p,  # storageDims
+    ctypes.c_uint64,  # storageDimsNum
+    ctypes.c_void_p,  # tensorData
+]
+libnnopbase.aclCreateTensor.restype = ctypes.c_void_p
+libnnopbase.aclDestroyTensor.argtypes = [ctypes.c_void_p]
+
+
+class AclNDTensor:
+    def __init__(self, np_array: np.ndarray):
+        self.np_array = np_array
+        self.op_runner = None
+        self.data_bytes_size = np_array.size * np_array.itemsize
+        self.mem_size = int(
+            math.ceil(np_array.size * np_array.itemsize / 256) * 256)
+        if self.mem_size > 0:
+            self.device_ptr, ret = acl.rt.malloc(self.mem_size, 0)
+            assert ret == 0
+            ret = acl.rt.memcpy(
+                self.device_ptr,
+                self.mem_size,
+                np_array.ctypes.data,
+                self.data_bytes_size,
+                1,
+            )
+            assert ret == 0
+        else:
+            self.device_ptr = 0
+        self.shape = np.array(np_array.shape, dtype=np.int64)
+        self.shape_size = len(np_array.shape)
+        self.acl_dtype = numpy_dtype_2_acl_dtype(np_array.dtype)
+        self.ptr = libnnopbase.aclCreateTensor(
+            self.shape.ctypes.data,
+            self.shape_size,
+            self.acl_dtype,
+            0,
+            0,
+            2,
+            self.shape.ctypes.data,
+            self.shape_size,
+            self.device_ptr
+        )
+        assert (self.ptr != 0)
+        self.need_copy_to_cpu = False
+
+    def __str__(self) -> str:
+        return str(self.to_cpu())
+
+    def __del__(self):
+        assert (self.ptr != 0)
+        libnnopbase.aclDestroyTensor(self.ptr)
+
+    def to_cpu(self):
+        if self.op_runner is not None:
+            self.op_runner.sync_stream()
+        if self.need_copy_to_cpu:
+            ret = acl.rt.memcpy(
+                self.np_array.ctypes.data,
+                self.data_bytes_size,
+                self.device_ptr,
+                self.data_bytes_size,
+                2,
+            )
+            assert ret == 0
+            self.need_copy_to_cpu = False
+        return self.np_array

l0n0lacl-0.0.1/l0n0lacl/AclStream.py

@@ -0,0 +1,24 @@
+from .utils import *
+
+class AclStream:
+    def __init__(self, device_id=0):
+        self.stream = None
+        self.device_id = device_id
+        self.set_device(device_id)
+
+    def set_device(self, device_id):
+        acl.rt.set_device(device_id)
+
+    def __enter__(self):
+        stream, ret = acl.rt.create_stream()
+        print_ret("创建stream失败", ret)
+        self.stream = stream
+        return stream
+
+    def __exit__(self, *args, **kwargs):
+        if self.stream is None or self.stream == 0:
+            return
+        try_sync_stream(self.stream)
+        ret = acl.rt.destroy_stream(self.stream)
+        print_ret("销毁stream错误!", ret)
+

l0n0lacl-0.0.1/l0n0lacl/OpRunner.py

@@ -0,0 +1,97 @@
+from .AclNDTensor import *
+
+def build_op_api_lib_path(prefix='customize'):
+    ascend_home_path = os.environ["ASCEND_HOME_PATH"]
+    op_path = f"{ascend_home_path}/opp/vendors/{prefix}/op_api/lib/libcust_opapi.so"
+    return op_path
+
+class OpRunner:
+    default_stream = None
+    def __init__(self, name, op_path_prefix='customize', op_path=None, device_id=0) -> None:
+        op_path = op_path or build_op_api_lib_path(op_path_prefix)
+        self.op_lib = ctypes.CDLL(op_path)
+        self.get_workspace_size = getattr(
+            self.op_lib, f"aclnn{name}GetWorkspaceSize")
+        self.run = getattr(self.op_lib, f"aclnn{name}")
+        self.run.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_uint64,
+            ctypes.c_void_p,
+            ctypes.c_void_p,
+        ]
+        self.executor = np.array([0], dtype=np.uint64)
+
+    def __call__(self, *args, outCout=1, argtypes=None, stream=None) -> Union[AclNDTensor, List[AclNDTensor]]:
+        stream = stream or OpRunner.default_stream
+        self.stream = stream
+        temp_args = []
+        for arg in args:
+            if isinstance(arg, np.ndarray):
+                acl_tensor = AclNDTensor(arg)
+                acl_tensor.op_runner = self
+                acl_tensor.need_copy_to_cpu = True
+                temp_args.append(acl_tensor)
+            elif isinstance(arg, AclNDTensor):
+                arg.op_runner = self
+                arg.need_copy_to_cpu = True
+                temp_args.append(arg)
+            else:
+                temp_args.append(arg)
+        workspace = np.zeros([1], dtype=np.uint64)
+        temp_args.append(workspace.ctypes.data)
+        temp_args.append(self.executor.ctypes.data)
+        real_args = []
+        run_argtypes = argtypes or []
+        for arg in temp_args:
+            if isinstance(arg, AclNDTensor):
+                real_args.append(arg.ptr)
+                if argtypes is None:
+                    run_argtypes.append(ctypes.c_void_p)
+            elif isinstance(arg, bool):
+                real_args.append(arg)
+                if argtypes is None:
+                    run_argtypes.append(ctypes.c_bool)
+            elif isinstance(arg, int):
+                real_args.append(arg)
+                if argtypes is None:
+                    int32_info = np.iinfo(np.int32)
+                    if arg > int32_info.max or arg < int32_info.min:
+                        run_argtypes.append(ctypes.c_int64)
+                    else:
+                        run_argtypes.append(ctypes.c_int32)
+            elif isinstance(arg, float):
+                real_args.append(arg)
+                if argtypes is None:
+                    float32_info = np.finfo(np.float32)
+                    if arg > float32_info.max or arg < float32_info.min:
+                        run_argtypes.append(ctypes.c_double)
+                    else:
+                        run_argtypes.append(ctypes.c_float)
+            elif isinstance(arg, bytes):
+                real_args.append(arg)
+                if argtypes is None:
+                    run_argtypes.append(ctypes.c_char_p)
+        self.get_workspace_size.argtypes = run_argtypes
+        self.get_workspace_size(*real_args)
+        workspace_ptr = 0
+        workspace_size = int(workspace[0])
+        if workspace_size > 0:
+            print("需要workspace大小为:", workspace_size, flush=True)
+        if workspace_size > 0:
+            workspace_ptr, ret = acl.rt.malloc(workspace_size, 0)
+            print_ret("分配workspace失败", ret)
+        self.workspace_ptr = workspace_ptr
+        self.workspace_size = workspace_size
+        self.run(workspace_ptr, workspace_size,
+                 int(self.executor[0]), stream)
+        if outCout == 1:
+            return temp_args[-3]
+        return temp_args[-(outCout + 2):-2]
+
+    def sync_stream(self):
+        if self.stream is None or not stream_need_sync(self.stream):
+            return
+        try_sync_stream(self.stream)
+        if self.workspace_size > 0:
+            acl.rt.free(self.workspace_ptr)
+            self.workspace_size = 0

l0n0lacl-0.0.1/l0n0lacl/__init__.py

@@ -0,0 +1,20 @@
+from .utils import *
+from .AclNDTensor import AclNDTensor
+from .OpRunner import OpRunner
+from .AclStream import AclStream
+
+# 初始化acl
+acl.init()
+acl.rt.set_device(0)
+OpRunner.default_stream, ret = acl.rt.create_stream()
+print_ret("创建_defualt_stream失败", ret)
+
+@atexit.register
+def finalize():
+    global default_stream
+    if OpRunner.default_stream is not None and OpRunner.default_stream != 0:
+        try_sync_stream(OpRunner.default_stream)
+        acl.rt.destroy_stream(OpRunner.default_stream)
+        OpRunner.default_stream = None
+    print_ret("销毁stream错误!", ret)
+    acl.finalize()

l0n0lacl-0.0.1/l0n0lacl/utils.py

@@ -0,0 +1,222 @@
+import os
+import acl
+import time
+import math
+import ctypes
+import colorama
+import numpy as np
+import colorama
+import atexit
+from typing import List, Union
+
+
+def print_ret(msg, ret):
+    if ret == 0:
+        return
+    print(colorama.Fore.RED, "[错误]", msg, ret, flush=True)
+    print(colorama.Style.RESET_ALL, flush=True)
+
+
+class AclStreamStatus:
+    # Stream上的所有任务已完成。
+    ACL_STREAM_STATUS_COMPLETE = 0
+    # Stream上至少有一个任务未完成。
+    ACL_STREAM_STATUS_NOT_READY = 1
+    # 预留。
+    ACL_STREAM_STATUS_RESERVED = 0xFFFF
+
+
+def stream_need_sync(stream: int):
+    status, ret = acl.rt.stream_query(stream)
+    if ret != 0:
+        print_ret("获取stream状态错误", ret)
+        return False
+    return status == AclStreamStatus.ACL_STREAM_STATUS_NOT_READY
+
+
+def try_sync_stream(stream: int):
+    ret = acl.rt.synchronize_stream(stream)
+    if ret != 0:
+        print_ret("同步stream错误", ret)
+        return False
+    return True
+
+
+def get_loss_by_type(dtype):
+    loss = 0
+    if dtype == np.float16:
+        loss = 1 / 1000
+    elif dtype == np.float32:
+        loss = 1 / 10000
+    return loss
+
+
+def _compare(v1: np.ndarray, v2: np.ndarray):
+    loss = get_loss_by_type(v1.dtype)
+    return np.abs(v1 - v2) <= loss
+
+
+def compare(v1: np.ndarray, v2: np.ndarray):
+    return _compare(v1, v2).all()
+
+
+def right_rate(v1: np.ndarray, v2: np.ndarray):
+    ret = _compare(v1, v2)
+    return ret.astype(np.int32).sum() / v1.size
+
+# 参考自：https://gitee.com/ascend/samples/blob/master/operator/AddCustomSample/KernelLaunch/AddKernelInvocationNeo/scripts/verify_result.py
+def verify_result(real_result, golden):
+    loss = get_loss_by_type(real_result.dtype)
+    minimum = 10e-10
+    result = np.abs(real_result - golden)  # 计算运算结果和预期结果偏差
+    deno = np.maximum(np.abs(real_result), np.abs(golden))  # 获取最大值并组成新数组
+    result_atol = np.less_equal(result, loss)  # 计算绝对误差
+    result_rtol = np.less_equal(result / np.add(deno, minimum), loss)  # 计算相对误差
+    if not result_rtol.all() and not result_atol.all():
+        if (
+            np.sum(result_rtol == False) > real_result.size * loss
+            and np.sum(result_atol == False) > real_result.size * loss
+        ):  # 误差超出预期时返回打印错误，返回对比失败
+            print(
+                colorama.Fore.RED, real_result.dtype, "[ERROR] result error", flush=True
+            )
+            print(colorama.Style.RESET_ALL, flush=True)
+            return False
+    print(colorama.Fore.GREEN, real_result.dtype, "test pass", flush=True)
+    print(colorama.Style.RESET_ALL, flush=True)
+    return True
+
+
+class AclDtype:
+    ACL_FLOAT = 0
+    ACL_FLOAT16 = 1
+    ACL_INT8 = 2
+    ACL_INT32 = 3
+    ACL_UINT8 = 4
+    ACL_INT16 = 6
+    ACL_UINT16 = 7
+    ACL_UINT32 = 8
+    ACL_INT64 = 9
+    ACL_UINT64 = 10
+    ACL_DOUBLE = 11
+    ACL_BOOL = 12
+    ACL_STRING = 13
+    ACL_COMPLEX64 = 16
+    ACL_COMPLEX128 = 17
+    ACL_BF16 = 27
+    ACL_INT4 = 29
+    ACL_UINT1 = 30
+    ACL_COMPLEX32 = 33
+
+
+class AclRunMode:
+    ACL_DEVICE = 0
+    ACL_HOST = 1
+
+
+class AclAllocPolicy:
+    """
+    0：ACL_MEM_MALLOC_HUGE_FIRST，当申请的内存小于等于1M时，即使使用该内存分配规则，也是申请普通页的内存。当申请的内存大于1M时，优先申请大页内存，如果大页内存不够，则使用普通页的内存。
+    1：ACL_MEM_MALLOC_HUGE_ONLY，仅申请大页，如果大页内存不够，则返回错误。
+    2：ACL_MEM_MALLOC_NORMAL_ONLY，仅申请普通页。
+    3：ACL_MEM_MALLOC_HUGE_FIRST_P2P，仅Device之间内存复制场景下申请内存时使用该选项，表示优先申请大页内存，如果大页内存不够，则使用普通页的内存。预留选项。
+    4：ACL_MEM_MALLOC_HUGE_ONLY_P2P，仅Device之间内存复制场景下申请内存时使用该选项，仅申请大页内存，如果大页内存不够，则返回错误。预留选项。
+    5：ACL_MEM_MALLOC_NORMAL_ONLY_P2P，仅Device之间内存复制场景下申请内存时使用该选项，仅申请普通页的内存。预留选项。
+    """
+
+    ACL_MEM_MALLOC_HUGE_FIRST = 0
+    ACL_MEM_MALLOC_HUGE_ONLY = 1
+    ACL_MEM_MALLOC_NORMAL_ONLY = 2
+    ACL_MEM_MALLOC_HUGE_FIRST_P2P = 3
+    ACL_MEM_MALLOC_HUGE_ONLY_P2P = 4
+    ACL_MEM_MALLOC_NORMAL_ONLY_P2P = 5
+
+
+class AclMemcopyKind:
+    """
+    0：ACL_MEMCPY_HOST_TO_HOST，Host内的内存复制。
+    1：ACL_MEMCPY_HOST_TO_DEVICE，Host到Device的内存复制。
+    2：ACL_MEMCPY_DEVICE_TO_HOST，Device到Host的内存复制。
+    3：ACL_MEMCPY_DEVICE_TO_DEVICE，Device内的内存复制。
+    """
+
+    ACL_MEMCPY_HOST_TO_HOST = 0
+    ACL_MEMCPY_HOST_TO_DEVICE = 1
+    ACL_MEMCPY_DEVICE_TO_HOST = 2
+    ACL_MEMCPY_DEVICE_TO_DEVICE = 3
+
+
+def numpy_dtype_2_acl_dtype(numpy_dtype):
+    if numpy_dtype == np.float32:
+        return AclDtype.ACL_FLOAT
+    if numpy_dtype == np.float16:
+        return AclDtype.ACL_FLOAT16
+    if numpy_dtype == np.int8:
+        return AclDtype.ACL_INT8
+    if numpy_dtype == np.int32:
+        return AclDtype.ACL_INT32
+    if numpy_dtype == np.uint8:
+        return AclDtype.ACL_UINT8
+    if numpy_dtype == np.int16:
+        return AclDtype.ACL_INT16
+    if numpy_dtype == np.uint16:
+        return AclDtype.ACL_UINT16
+    if numpy_dtype == np.uint32:
+        return AclDtype.ACL_UINT32
+    if numpy_dtype == np.int64:
+        return AclDtype.ACL_INT64
+    if numpy_dtype == np.uint64:
+        return AclDtype.ACL_UINT64
+    if numpy_dtype == np.double:
+        return AclDtype.ACL_DOUBLE
+    if numpy_dtype == np.bool_:
+        return AclDtype.ACL_BOOL
+    if numpy_dtype == np.string_:
+        return AclDtype.ACL_STRING
+    if numpy_dtype == np.complex64:
+        return AclDtype.ACL_COMPLEX64
+    if numpy_dtype == np.complex128:
+        return AclDtype.ACL_COMPLEX128
+    if numpy_dtype == np.complex_:
+        return AclDtype.ACL_COMPLEX32
+    # TODO 如何使用bf16
+
+
+def numpy_dtype_2_torch_dtype(numpy_dtype):
+    import torch
+    if numpy_dtype == np.float32:
+        return torch.float32
+    if numpy_dtype == np.float16:
+        return torch.float16
+    if numpy_dtype == np.int8:
+        return torch.int8
+    if numpy_dtype == np.int32:
+        return torch.int32
+    if numpy_dtype == np.uint8:
+        return torch.uint8
+    if numpy_dtype == np.int16:
+        return torch.int16
+    if numpy_dtype == np.uint16:
+        return torch.int16
+    if numpy_dtype == np.uint32:
+        return torch.int32
+    if numpy_dtype == np.int64:
+        return torch.int64
+    if numpy_dtype == np.uint64:
+        return torch.int64
+    if numpy_dtype == np.double:
+        return torch.double
+    if numpy_dtype == np.bool_:
+        return torch.bool
+    if numpy_dtype == np.complex64:
+        return torch.complex64
+    if numpy_dtype == np.complex128:
+        return torch.complex128
+    if numpy_dtype == np.complex_:
+        return torch.complex32
+
+
+if __name__ == "__main__":
+    a = np.zeros((3, 3), dtype=np.float16)
+    env = AclEnv(0)
+    nd_tensor = AclNDTensor(a)

l0n0lacl-0.0.1/l0n0lacl.egg-info/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.1
+Name: l0n0lacl
+Version: 0.0.1
+Summary: 用于调用ascendc编写的算子
+Author: l0n0l
+Author-email: 1038352856@qq.com
+Keywords: acl,ascendc,算子,算子开发
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.7, <4
+Description-Content-Type: text/markdown
+Requires-Dist: colorama
+Requires-Dist: numpy
+
+# 1 功能描述
+由于在ascendc算子开发过程中运行算子比较复杂，为了简化算子的运行，将运行算子变成可以用python直接调用的函数。所以编写了此代码。
+
+# 2 安装
+```
+pip install l0n0lacl
+```
+
+# 3 运行算子实例
+## 3.1 先切换到cann环境,比如我的环境是:
+```
+source /home/HwHiAiUser/Ascend/ascend-toolkit/set_env.sh
+```
+## 3.2 先安装我们编写的算子
+```
+bash custom_opp_xxx_aarch64.run
+```
+## 3.3 创建算子运行器
+```python
+from l0n0lacl import *
+ascendc_gelu = OpRunner("Gelu", op_path_prefix='customize')
+```
+
+## 3.4 调用算子
+### 3.4.1 先看调用传参顺序
+在算子工程编译后，会有代码生成，在算子工程目录:
+`${算子目录}/build_out/autogen/aclnn_xxx.h`中可以找到`aclnnXXXGetWorkspaceSize`函数。以Gelu为例：
+```c++
+__attribute__((visibility("default")))
+aclnnStatus aclnnGeluGetWorkspaceSize(
+    const aclTensor *x,
+    const aclTensor *out,
+    uint64_t *workspaceSize,
+    aclOpExecutor **executor);
+```
+可以看到参数为 `x`, `out`, `workspaceSize`, `executor`。其中 `workspaceSize`, `executor`不需要管。
+* `aclTensor*`对应`numpy.ndarray`
+* 其他参考: <a href = "https://docs.python.org/zh-cn/3/library/ctypes.html#fundamental-data-types">ctypes类型</a>
+### 3.4.2 调用算子
+```python
+import torch
+from l0n0lacl import *
+ascendc_gelu = OpRunner("Gelu", op_path_prefix='customize')
+target_dtype = torch.float
+x = torch.empty(shape, dtype=target_dtype).uniform_(-1, 1)
+y = torch.empty(shape, dtype=target_dtype).zero_()
+out = ascendc_gelu(x.numpy(), y.numpy()).to_cpu()
+print(out)
+```
+
+# 4. api参考
+## 4.1 AclNDTensor
+```python
+class AclNDTensor:
+    def __init__(self, np_array: np.ndarray):
+        pass
+    def to_cpu(self):
+        pass
+```
+numpy ndarray与ascend nd tensor间的桥梁
+### 4.1.1 `__init__`
+* `np_array`: numpy的tensor
+### 4.1.2 `to_cpu`
+将运算结果从npu拷贝到cpu
+## 4.2 OpRunner
+```python
+class OpRunner:
+    def __init__(self, name, op_path_prefix='customize', op_path=None, device_id=0) -> None:
+        pass
+    def __call__(self, *args, outCout=1, argtypes=None, stream=None) -> Union[AclNDTensor, List[AclNDTensor]]:
+        pass
+    def sync_stream(self)->None:
+        pass
+```
+### 4.2.1 `__init__`
+* `name`:算子名称，
+* `op_path_prefix`: 算子工程中**CMakePresets.json**文件中**vender_name**的值。默认是`customize`,可以不传
+```json
+"vendor_name": {
+    "type": "STRING",
+    "value": "customize"
+},
+```
+* `op_path`: 算子`libcust_opapi.so`库的绝对位置。不传。
+* `device_id`: 设备ID。默认`0`
+
+### 4.2.2 `__call__`
+* `args`: 表示传给`aclnnXXXGetWorkspaceSize`除了`workspaceSize`, `executor`的参数
+* `outCout` : 表示算子的输出个数。如果出处个数为`1`,返回一个`AclNDTensor`。如果输出个数大于1,返回`List[AclNDTensor]`
+* `argtypes`: 表示`aclnnXXXGetWorkspaceSize`的参数`ctypes`参数类型，对于特别复杂的算子，如果发现调用异常，可以手动指定类型。
+比如(**仅用于举例，其实可以不传，自动推导就可运行。但是当发现运行异常的情况下，可以自己指定**)，对于:
+```c++
+__attribute__((visibility("default")))
+aclnnStatus aclnnCumsumGetWorkspaceSize(
+    const aclTensor *x,
+    const aclTensor *axis,
+    bool exclusiveOptional,
+    bool reverseOptional,
+    const aclTensor *out,
+    uint64_t *workspaceSize,
+    aclOpExecutor **executor);
+```
+
+```python
+import ctypes
+from l0n0lacl import *
+ascendc_cumsum = OpRunner("Cumsum")
+target_dtype = np.float32
+data_range = (-10, 10)
+shape = [100, 3, 2304]
+axis_py = 1
+exclusive = True
+reverse = False
+x = np.random.uniform(*data_range, shape).astype(target_dtype)
+axis = np.array([axis_py]).astype(np.int32)
+golden: np.ndarray = tf.cumsum(x, axis_py, exclusive, reverse, argtypes=[
+    ctypes.c_void_p, # x
+    ctypes.c_void_p, # axis
+    ctypes.c_bool,   # exclusiveOptional
+    ctypes.c_bool,   # reverseOptional
+    ctypes.c_void_p, # out
+    ctypes.c_void_p, # workspaceSize
+    ctypes.c_void_p, # executor
+]).numpy()
+y = np.ones_like(golden, golden.dtype) * 123
+ascendc_cumsum(x, axis, exclusive, reverse,  y).to_cpu()
+print(y)
+```
+* `stream` 如果是多stream的情况下，可以自己指定stream:
+例如:
+```python
+import ctypes
+import tensorflow as tf
+from l0n0lacl import *
+ascendc_cumsum = OpRunner("Cumsum")
+target_dtype = np.float32
+data_range = (-10, 10)
+shape = [100, 3, 2304]
+axis_py = 1
+exclusive = True
+reverse = False
+x = np.random.uniform(*data_range, shape).astype(target_dtype)
+axis = np.array([axis_py]).astype(np.int32)
+golden: np.ndarray = tf.cumsum(x, axis_py, exclusive, reverse).numpy()
+y = np.ones_like(golden, golden.dtype) * 123
+ascendc_cumsum(x, axis, exclusive, reverse,  y, argtypes=[
+    ctypes.c_void_p, # x
+    ctypes.c_void_p, # axis
+    ctypes.c_bool,   # exclusiveOptional
+    ctypes.c_bool,   # reverseOptional
+    ctypes.c_void_p, # out
+    ctypes.c_void_p, # workspaceSize
+    ctypes.c_void_p, # executor
+]).to_cpu()
+verify_result(y, golden)
+print(y)
+```
+
+### 4.2.3 `sync_stream`
+用于同步stream
+
+## 4.3 verify_result
+参考自：https://gitee.com/ascend/samples/blob/master/operator/AddCustomSample/KernelLaunch/AddKernelInvocationNeo/scripts/verify_result.py
+```python
+def verify_result(real_result:numpy.ndarray, golden:numpy.ndarray):
+    pass
+```
+判断精度是否符合
+float16: 千分之一
+float32: 万分之一
+int16,int32,int8: 0

l0n0lacl-0.0.1/l0n0lacl.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+./l0n0lacl/AclNDTensor.py
+./l0n0lacl/AclStream.py
+./l0n0lacl/OpRunner.py
+./l0n0lacl/__init__.py
+./l0n0lacl/utils.py
+./l0n0lacl.egg-info/PKG-INFO
+./l0n0lacl.egg-info/SOURCES.txt
+./l0n0lacl.egg-info/dependency_links.txt
+./l0n0lacl.egg-info/requires.txt
+./l0n0lacl.egg-info/top_level.txt

l0n0lacl-0.0.1/l0n0lacl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

l0n0lacl-0.0.1/l0n0lacl.egg-info/requires.txt

@@ -0,0 +1,2 @@
+colorama
+numpy

l0n0lacl-0.0.1/l0n0lacl.egg-info/top_level.txt

@@ -0,0 +1 @@
+l0n0lacl

l0n0lacl-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

l0n0lacl-0.0.1/setup.py

@@ -0,0 +1,166 @@
+"""A setuptools based setup module.
+
+See:
+https://packaging.python.org/guides/distributing-packages-using-setuptools/
+https://github.com/pypa/sampleproject
+"""
+
+# Always prefer setuptools over distutils
+from setuptools import setup, find_packages
+import pathlib
+
+here = pathlib.Path(__file__).parent.resolve()
+
+# Get the long description from the README file
+long_description = (here / "README.md").read_text(encoding="utf-8")
+# Arguments marked as "Required" below must be included for upload to PyPI.
+# Fields marked as "Optional" may be commented out.
+
+setup(
+    # This is the name of your project. The first time you publish this
+    # package, this name will be registered for you. It will determine how
+    # users can install this project, e.g.:
+    #
+    # $ pip install sampleproject
+    #
+    # And where it will live on PyPI: https://pypi.org/project/sampleproject/
+    #
+    # There are some restrictions on what makes a valid project name
+    # specification here:
+    # https://packaging.python.org/specifications/core-metadata/#name
+    name="l0n0lacl",  # Required
+    # Versions should comply with PEP 440:
+    # https://www.python.org/dev/peps/pep-0440/
+    #
+    # For a discussion on single-sourcing the version across setup.py and the
+    # project code, see
+    # https://packaging.python.org/guides/single-sourcing-package-version/
+    version="0.0.1",  # Required
+    # This is a one-line description or tagline of what your project does. This
+    # corresponds to the "Summary" metadata field:
+    # https://packaging.python.org/specifications/core-metadata/#summary
+    description="用于调用ascendc编写的算子",  # Optional
+    # This is an optional longer description of your project that represents
+    # the body of text which users will see when they visit PyPI.
+    #
+    # Often, this is the same as your README, so you can just read it in from
+    # that file directly (as we have already done above)
+    #
+    # This field corresponds to the "Description" metadata field:
+    # https://packaging.python.org/specifications/core-metadata/#description-optional
+    long_description=long_description,  # Optional
+    # Denotes that our long_description is in Markdown; valid values are
+    # text/plain, text/x-rst, and text/markdown
+    #
+    # Optional if long_description is written in reStructuredText (rst) but
+    # required for plain-text or Markdown; if unspecified, "applications should
+    # attempt to render [the long_description] as text/x-rst; charset=UTF-8 and
+    # fall back to text/plain if it is not valid rst" (see link below)
+    #
+    # This field corresponds to the "Description-Content-Type" metadata field:
+    # https://packaging.python.org/specifications/core-metadata/#description-content-type-optional
+    long_description_content_type="text/markdown",  # Optional (see note above)
+    # This should be a valid link to your project's main homepage.
+    #
+    # This field corresponds to the "Home-Page" metadata field:
+    # https://packaging.python.org/specifications/core-metadata/#home-page-optional
+    # url="https://github.com/pypa/sampleproject",  # Optional
+    # This should be your name or the name of the organization which owns the
+    # project.
+    author="l0n0l",  # Optional
+    # This should be a valid email address corresponding to the author listed
+    # above.
+    author_email="1038352856@qq.com",  # Optional
+    # Classifiers help users find your project by categorizing it.
+    #
+    # For a list of valid classifiers, see https://pypi.org/classifiers/
+    classifiers=[  # Optional
+        # How mature is this project? Common values are
+        #   3 - Alpha
+        #   4 - Beta
+        #   5 - Production/Stable
+        "Development Status :: 3 - Alpha",
+        # Indicate who your project is intended for
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Build Tools",
+        # Pick your license as you wish
+        "License :: OSI Approved :: MIT License",
+        # Specify the Python versions you support here. In particular, ensure
+        # that you indicate you support Python 3. These classifiers are *not*
+        # checked by 'pip install'. See instead 'python_requires' below.
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3 :: Only",
+    ],
+    # This field adds keywords for your project which will appear on the
+    # project page. What does your project relate to?
+    #
+    # Note that this is a list of additional keywords, separated
+    # by commas, to be used to assist searching for the distribution in a
+    # larger catalog.
+    keywords="acl, ascendc, 算子, 算子开发",  # Optional
+    # When your source code is in a subdirectory under the project root, e.g.
+    # `src/`, it is necessary to specify the `package_dir` argument.
+    package_dir={"": "./"},  # Optional
+    # You can just specify package directories manually here if your project is
+    # simple. Or you can use find_packages().
+    #
+    # Alternatively, if you just want to distribute a single Python file, use
+    # the `py_modules` argument instead as follows, which will expect a file
+    # called `my_module.py` to exist:
+    #
+    #   py_modules=["my_module"],
+    #
+    packages=find_packages(where="./"),  # Required
+    # Specify which Python versions you support. In contrast to the
+    # 'Programming Language' classifiers above, 'pip install' will check this
+    # and refuse to install the project if the version does not match. See
+    # https://packaging.python.org/guides/distributing-packages-using-setuptools/#python-requires
+    python_requires=">=3.7, <4",
+    # This field lists other packages that your project depends on to run.
+    # Any package you put here will be installed by pip when your project is
+    # installed, so they must be valid existing projects.
+    #
+    # For an analysis of "install_requires" vs pip's requirements files see:
+    # https://packaging.python.org/discussions/install-requires-vs-requirements/
+    install_requires=["colorama", "numpy"],  # Optional
+    # List additional groups of dependencies here (e.g. development
+    # dependencies). Users will be able to install these using the "extras"
+    # syntax, for example:
+    #
+    #   $ pip install sampleproject[dev]
+    #
+    # Similar to `install_requires` above, these must be valid existing
+    # projects.
+    extras_require={  # Optional
+    },
+    # If there are data files included in your packages that need to be
+    # installed, specify them here.
+    package_data={  # Optional
+    },
+    # Entry points. The following would provide a command called `sample` which
+    # executes the function `main` from this package when invoked:
+    entry_points={  # Optional
+        # "console_scripts": [
+        #     "sample=sample:main",
+        # ],
+    },
+    # List additional URLs that are relevant to your project as a dict.
+    #
+    # This field corresponds to the "Project-URL" metadata fields:
+    # https://packaging.python.org/specifications/core-metadata/#project-url-multiple-use
+    #
+    # Examples listed include a pattern for specifying where the package tracks
+    # issues, where the source is hosted, where to say thanks to the package
+    # maintainers, and where to support the project financially. The key is
+    # what's used to render the link text on PyPI.
+    project_urls={  # Optional
+        # "Bug Reports": "https://github.com/pypa/sampleproject/issues",
+        # "Funding": "https://donate.pypi.org",
+        # "Say Thanks!": "http://saythanks.io/to/example",
+        # "Source": "https://github.com/pypa/sampleproject/",
+    },
+)