---
title: kupl::queue_submit(kernel)
description: "向 queue 提交需要执行的 kernel。相较于kupl::queue_submit(item)接口而言，该接口语义为提交kernel至queue上，kernel是指提交至队列执行的并行计算任务。两者的差异主要在函数接口的入参上，采用C++函数重载的能力进行实现。"
url: https://www.hikunpeng.com/document/detail/zh/kunpenghpcs/hpckit/devg/KunpengHPCKit_developer_057.html
sourcePath: /source/zh/kunpenghpcs/hpckit/devg/KunpengHPCKit_developer_057.html
indexId: 57a36655cd1363a662d3e529db4f4c26156bda00e99bc9957d3c765740c7f78767
---
# kupl::queue_submit(kernel)

向 queue 提交需要执行的 kernel。相较于kupl::queue_submit(item)接口而言，该接口语义为提交kernel至queue上，kernel是指提交至队列执行的并行计算任务。两者的差异主要在函数接口的入参上，采用C++函数重载的能力进行实现。

该接口需要使用 C++ 编译器, range 目前只支持 1d。


#### 接口定义

int kupl::queue_submit(kupl_queue_h queue, kupl_queue_kernel_desc_t *desc, const std::function<void(const kupl_nd_range_t *)> &kernel);


#### 参数


**表1 参数定义**

| 参数名 | 类型 | 描述 | 输入/输出 |
| --- | --- | --- | --- |
| queue | kupl\_queue\_h | 执行 kernel 的 queue | 输入 |
| desc | kupl\_queue\_kernel\_desc\_t | kernel 的描述 | 输入 |
| kernel | const std::function<void(const kupl\_nd\_range\_t \*)> | kernel 的内容，一般是 lambda 表达式 | 输入 |


**表2 kupl_queue_kernel_desc_t 的数据结构**

| 参数名 | 类型 | 描述 |
| --- | --- | --- |
| field\_mask | uint64\_t | kernel 描述的掩码，用于表示哪些参数启用，必选。不开启选项时填 0。 可用选项： KUPL\_QUEUE\_KERNEL\_DESC\_FIELD\_NAME |
| range | kupl\_nd\_range\_t \* | kernel 的 range 信息，必选 |
| egroup | kupl\_egroup\_h | kernel 可用的 executor 信息，必选 |
| name | const char \* | kernel 的名字，可选 |


#### 返回值

成功：返回 KUPL_OK

失败：返回 KUPL_ERROR


#### 示例

```
#include <atomic>
#include <assert.h>
#include "kupl.h"
int main() {
auto queue = kupl_queue_create();
const int num_executors = 10;
kupl_nd_range_t range;
KUPL_1D_RANGE_INIT(range, 0, num_executors);
int exe[num_executors];
for (int i = 0; i < num_executors; i++) {
exe[i] = i;
}
kupl_egroup_h egroup = kupl_egroup_create(exe, num_executors);
kupl_queue_kernel_desc_t desc = {
.range = &range,
.egroup = egroup,
.field_mask = 0,
};
std::atomic<size_t> sum(0);
const size_t count = 1000000;
size_t sum_cal = (1 + count) * count / 2;
size_t *data = (size_t *)malloc(count * sizeof(count));
for (size_t i = 0; i < count; i++) {
data[i] = i + 1;
}
int ret =
kupl::queue_submit
(queue, &desc, [&](const kupl_nd_range_t *nd_range) {
int start_index = nd_range->nd_range[0].lower * (count / num_executors);
for (size_t i = 0; i < count / num_executors; i++) {
sum += data[start_index + i];
}
});
assert(ret == KUPL_OK);
kupl_queue_wait(queue);
assert(sum.load() == sum_cal);
printf("sum: %lu\n", sum.load());
kupl_egroup_destroy(egroup);
kupl_queue_destroy(queue);
}
```

运行结果如下。

```
sum: 500000500000
```

上述示例演示了向 queue 提交 kernel，在 10 个线程上计算一个长度为 1000000 的数组总和，并等待直到 queue 上全部 kernel 执行完成的流程，最终和直接计算的结果相比较，并输出结果。