Line data Source code
1 : /**
2 : * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #ifndef HCOMM_TEAM_H
12 : #define HCOMM_TEAM_H
13 : #include <stdint.h>
14 : #include <stddef.h>
15 : #include <stdbool.h>
16 : #include "hcomm_res_defs.h"
17 : #include "hcomm_team_defs.h"
18 : #include "hcomm_result_defs.h"
19 :
20 : #ifdef __cplusplus
21 : extern "C" {
22 : #endif // __cplusplus
23 :
24 : typedef enum {
25 : HCOMM_TEAM_WINDOW_FLAG_INVALID = -1,
26 : HCOMM_TEAM_WINDOW_FLAG_SYMMETRIC = 0, // 当前仅支持配置为0
27 : } HcommTeamWindowFlag;
28 :
29 : typedef struct {
30 : CommAbiHeader header;
31 : uint32_t memberNum;
32 : uint32_t selfMemberId;
33 : const uint32_t*
34 : worldMemberIds; /*worldMemberIds在创建worldteam的时候是nullptr，创建subteam的时候是subteam的成员在worldteam中的memberId数组，长度是memberNum*/
35 : uint32_t netLayer; /* 用户希望使用的网络层，0表示默认选择 */
36 : CommProtocol protocol; /* 用户希望使用的通信协议，-1表示保留协议类型, 1个team仅支持一个协议 */
37 : HcommTeamSyncMemRequirement requirement;
38 : uint32_t reserved[6];
39 : } HcommTeamCreateDesc;
40 :
41 : typedef struct {
42 : CommAbiHeader header;
43 : uint32_t* channelNumPerMember; /* 长度为memberNum，表示每个成员的channel数量 */
44 : ChannelHandle** channelsByMemberId;
45 : uint32_t memberNum;
46 : uint32_t reserved[8];
47 : } HcommTeamBindChannelsDesc;
48 :
49 : typedef struct {
50 : CommAbiHeader header;
51 : CommMem* mems; // 下标是成员id，长度是memberNum，如果是selfMemberId，则是本地内存，否则是远端内存
52 : uint32_t memberNum;
53 : uint32_t reserved[5];
54 : } HcommTeamWindowDesc;
55 :
56 : typedef struct {
57 : CommAbiHeader header;
58 : CommMem* remoteMems;
59 : uint32_t remoteMemNum;
60 : uint32_t reserved[5];
61 : } HcommTeamBindSyncMemDesc;
62 :
63 : static const uint32_t HCOMM_TEAM_CREATE_DESC_MAGIC_WORD = 0x0f0f0f10U;
64 : static const uint32_t HCOMM_TEAM_CREATE_DESC_VERSION = 1U;
65 :
66 : static const uint32_t HCOMM_TEAM_BIND_CHANNELS_DESC_MAGIC_WORD = 0x0f0f0f11U;
67 : static const uint32_t HCOMM_TEAM_BIND_CHANNELS_DESC_VERSION = 1U;
68 :
69 : static const uint32_t HCOMM_TEAM_WINDOW_DESC_MAGIC_WORD = 0x0f0f0f12U;
70 : static const uint32_t HCOMM_TEAM_WINDOW_DESC_VERSION = 1U;
71 :
72 : static const uint32_t HCOMM_TEAM_BIND_SYNCMEM_DESC_MAGIC_WORD = 0x0f0f0f13U;
73 : static const uint32_t HCOMM_TEAM_BIND_SYNCMEM_DESC_VERSION = 1U;
74 :
75 40 : static inline HcommResult HcommTeamCreateDescInit(HcommTeamCreateDesc* desc)
76 : {
77 40 : const HcommResult hcommEPointer = HCOMM_E_PTR;
78 :
79 40 : if (desc == nullptr) {
80 0 : return hcommEPointer;
81 : }
82 :
83 40 : (void)memset_s(desc, sizeof(HcommTeamCreateDesc), 0xFF, sizeof(HcommTeamCreateDesc));
84 40 : desc->header.version = HCOMM_TEAM_CREATE_DESC_VERSION;
85 40 : desc->header.magicWord = HCOMM_TEAM_CREATE_DESC_MAGIC_WORD;
86 40 : desc->header.size = sizeof(HcommTeamCreateDesc);
87 40 : desc->header.reserved = 0;
88 40 : desc->memberNum = 0;
89 40 : desc->selfMemberId = 0;
90 40 : desc->worldMemberIds = nullptr;
91 40 : desc->netLayer = 0;
92 40 : desc->protocol = COMM_PROTOCOL_RESERVED;
93 40 : desc->requirement.signalCount = 0;
94 40 : desc->requirement.counterCount = 0;
95 40 : desc->requirement.barrierCount = 0;
96 40 : const uint32_t reqReservedCount = sizeof(desc->requirement.reserved) / sizeof(desc->requirement.reserved[0]);
97 240 : for (uint32_t i = 0; i < reqReservedCount; ++i) {
98 200 : desc->requirement.reserved[i] = 0;
99 : }
100 40 : const uint32_t reservedCount = sizeof(desc->reserved) / sizeof(desc->reserved[0]);
101 280 : for (uint32_t i = 0; i < reservedCount; ++i) {
102 240 : desc->reserved[i] = 0;
103 : }
104 :
105 40 : return 0;
106 : }
107 :
108 8 : static inline HcommResult HcommTeamBindChannelsDescInit(HcommTeamBindChannelsDesc* desc)
109 : {
110 8 : const HcommResult hcommEPointer = HCOMM_E_PTR;
111 :
112 8 : if (desc == nullptr) {
113 0 : return hcommEPointer;
114 : }
115 :
116 8 : (void)memset_s(desc, sizeof(HcommTeamBindChannelsDesc), 0xFF, sizeof(HcommTeamBindChannelsDesc));
117 8 : desc->header.version = HCOMM_TEAM_BIND_CHANNELS_DESC_VERSION;
118 8 : desc->header.magicWord = HCOMM_TEAM_BIND_CHANNELS_DESC_MAGIC_WORD;
119 8 : desc->header.size = sizeof(HcommTeamBindChannelsDesc);
120 8 : desc->header.reserved = 0;
121 8 : desc->memberNum = 0;
122 8 : desc->channelNumPerMember = nullptr;
123 8 : desc->channelsByMemberId = nullptr;
124 8 : const uint32_t reservedCount = sizeof(desc->reserved) / sizeof(desc->reserved[0]);
125 72 : for (uint32_t i = 0; i < reservedCount; ++i) {
126 64 : desc->reserved[i] = 0;
127 : }
128 :
129 8 : return 0;
130 : }
131 :
132 6 : static inline HcommResult HcommTeamWindowDescInit(HcommTeamWindowDesc* desc)
133 : {
134 6 : const HcommResult hcommEPointer = HCOMM_E_PTR;
135 :
136 6 : if (desc == nullptr) {
137 0 : return hcommEPointer;
138 : }
139 :
140 6 : (void)memset_s(desc, sizeof(HcommTeamWindowDesc), 0xFF, sizeof(HcommTeamWindowDesc));
141 6 : desc->header.version = HCOMM_TEAM_WINDOW_DESC_VERSION;
142 6 : desc->header.magicWord = HCOMM_TEAM_WINDOW_DESC_MAGIC_WORD;
143 6 : desc->header.size = sizeof(HcommTeamWindowDesc);
144 6 : desc->header.reserved = 0;
145 6 : desc->mems = nullptr;
146 6 : desc->memberNum = 0;
147 6 : const uint32_t reservedCount = sizeof(desc->reserved) / sizeof(desc->reserved[0]);
148 36 : for (uint32_t i = 0; i < reservedCount; ++i) {
149 30 : desc->reserved[i] = 0;
150 : }
151 :
152 6 : return 0;
153 : }
154 :
155 5 : static inline HcommResult HcommTeamBindSyncMemDescInit(HcommTeamBindSyncMemDesc* desc)
156 : {
157 5 : const HcommResult hcommEPointer = HCOMM_E_PTR;
158 :
159 5 : if (desc == nullptr) {
160 0 : return hcommEPointer;
161 : }
162 :
163 5 : (void)memset_s(desc, sizeof(HcommTeamBindSyncMemDesc), 0xFF, sizeof(HcommTeamBindSyncMemDesc));
164 5 : desc->header.version = HCOMM_TEAM_BIND_SYNCMEM_DESC_VERSION;
165 5 : desc->header.magicWord = HCOMM_TEAM_BIND_SYNCMEM_DESC_MAGIC_WORD;
166 5 : desc->header.size = sizeof(HcommTeamBindSyncMemDesc);
167 5 : desc->header.reserved = 0;
168 5 : desc->remoteMems = nullptr;
169 5 : desc->remoteMemNum = 0;
170 5 : const uint32_t reservedCount = sizeof(desc->reserved) / sizeof(desc->reserved[0]);
171 30 : for (uint32_t i = 0; i < reservedCount; ++i) {
172 25 : desc->reserved[i] = 0;
173 : }
174 :
175 5 : return 0;
176 : }
177 :
178 : /* ===== team 生命周期 ===== */
179 : HcommResult HcommTeamCreate(
180 : HcommTeamHandle worldTeam, const HcommTeamCreateDesc* desc, HcommTeamHandle* team, uint64_t* syncMemSize);
181 : HcommResult HcommTeamDestroy(HcommTeamHandle team);
182 :
183 : /* ===== team 窗口操作 ===== */
184 : HcommResult HcommTeamWindowRegister(
185 : HcommTeamHandle worldTeam, const HcommTeamWindowDesc* desc, HcommWindowHandle* handle, HcommTeamWindowFlag flag);
186 : HcommResult HcommTeamWindowDeregister(HcommTeamHandle worldTeam, HcommWindowHandle handle);
187 :
188 : /* ===== team 资源绑定 ===== */
189 : HcommResult HcommTeamBindChannels(HcommTeamHandle team, const HcommTeamBindChannelsDesc* desc);
190 : HcommResult HcommTeamBindRemoteSyncMem(HcommTeamHandle team, const HcommTeamBindSyncMemDesc* remoteDesc);
191 : HcommResult
192 : HcommTeamWindowBindRemoteMems(HcommTeamHandle team, HcommWindowHandle handle, const HcommTeamWindowDesc* remoteDesc);
193 :
194 : #ifdef __cplusplus
195 : }
196 : #endif // __cplusplus
197 : #endif // HCOMM_TEAM_H
|
