Line data Source code
1 : /**
2 : * Copyright (c) 2025 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 : #include <sstream>
12 : #include "qs_args_parser.h"
13 : #include "bqs_util.h"
14 : #include "bqs_log.h"
15 : #include "bqs_feature_ctrl.h"
16 :
17 : namespace bqs {
18 33 : bool ArgsParser::ParseArgs(const int32_t argc, const char_t * const argv[])
19 : {
20 33 : if ((argv == nullptr) || (argc <= 1)) {
21 1 : return false;
22 : }
23 :
24 262 : for (uint32_t i = 0; i < static_cast<uint32_t>(argc); ++i) {
25 478 : if (!ParseSinglePara(std::string(argv[i]))) {
26 9 : return false;
27 : }
28 : }
29 :
30 23 : return CheckRequiredParas();
31 : }
32 :
33 5 : bool ArgsParser::ParseArgs(const std::vector<std::string> &args)
34 : {
35 24 : for (const auto &iter : args) {
36 20 : if (!ParseSinglePara(iter)) {
37 1 : return false;
38 : }
39 : }
40 :
41 4 : return CheckRequiredParas();
42 : }
43 :
44 27 : bool ArgsParser::CheckRequiredParas() const
45 : {
46 27 : std::unordered_map<std::string, bool> requiredParamsMap;
47 27 : requiredParamsMap.insert(std::make_pair(PARAM_DEVICEID, withDeviceId_));
48 27 : requiredParamsMap.insert(std::make_pair(PARAM_HOST_PID, withHostPid_));
49 27 : if (bqs::GetRunContext() == bqs::RunContext::HOST) {
50 21 : requiredParamsMap.insert(std::make_pair(PARAM_GRP_NAME, withGroupName_));
51 : }
52 91 : for (auto requiredParams : requiredParamsMap) {
53 69 : if (!requiredParams.second) {
54 5 : BQS_LOG_ERROR("Param error. Must specify param with [%s].", requiredParams.first.c_str());
55 5 : return false;
56 : }
57 69 : }
58 :
59 22 : std::unordered_map<std::string, bool> requiredParamsWarnMap;
60 22 : requiredParamsWarnMap.insert(std::make_pair(PARAM_VFID, withVfId_));
61 22 : requiredParamsWarnMap.insert(std::make_pair(PARAM_PIDSIGN, withPidSign_));
62 66 : for (auto requiredParamsWarn : requiredParamsWarnMap) {
63 44 : if (!requiredParamsWarn.second) {
64 7 : BQS_LOG_WARN("param error. Param %s does not exist.", requiredParamsWarn.first.c_str());
65 : }
66 44 : }
67 :
68 22 : return true;
69 27 : }
70 :
71 263 : bool ArgsParser::ParseSinglePara(const std::string &singlePara)
72 : {
73 263 : const std::size_t offset = singlePara.find("=");
74 263 : if (offset == std::string::npos) {
75 35 : return true;
76 : }
77 :
78 228 : const std::string key = singlePara.substr(0U, offset + 1UL);
79 228 : const std::string val = singlePara.substr(offset + 1UL);
80 228 : const auto iter = argsParseFuncMap_.find(key);
81 228 : if (iter == argsParseFuncMap_.end()) {
82 : // Ignore unknown parameter
83 2 : BQS_LOG_WARN("unknown input parameter [%s] of function ParseArgs, ignore", key.c_str());
84 2 : return true;
85 : }
86 :
87 226 : const bool ret = (this->*(iter->second))(val);
88 226 : if (!ret) {
89 11 : return false;
90 : }
91 :
92 215 : return true;
93 228 : }
94 :
95 40 : bool ArgsParser::ParseDeviceId(const std::string ¶)
96 : {
97 40 : int32_t val = 0;
98 40 : if (!TransStrToInt(para, val)) {
99 2 : BQS_LOG_ERROR("Parse deviceId failed, param is %s", para.c_str());
100 2 : return false;
101 : }
102 :
103 38 : if ((val < 0) || (val >= QS_FW_CHIP_NUM_MAX)) {
104 4 : BQS_LOG_ERROR("DeviceId param[%s] invalided, value is not in [%d, %d)",
105 : para.c_str(), 0, QS_FW_CHIP_NUM_MAX);
106 4 : return false;
107 : }
108 :
109 34 : deviceId_ = static_cast<uint32_t>(val);
110 34 : withDeviceId_ = true;
111 34 : return true;
112 : }
113 :
114 22 : bool ArgsParser::ParseDeviceId(const std::string ¶, int32_t &deviceId) const
115 : {
116 22 : int32_t val = 0;
117 22 : if (!TransStrToInt(para, val)) {
118 1 : BQS_LOG_WARN("Parse deviceId failed, param is %s", para.c_str());
119 1 : return false;
120 : }
121 :
122 21 : if ((val < 0) || (val >= QS_FW_CHIP_NUM_MAX)) {
123 2 : BQS_LOG_WARN("DeviceId param[%s] invalided, value is not in [%d, %d)",
124 : para.c_str(), 0, QS_FW_CHIP_NUM_MAX);
125 2 : return false;
126 : }
127 :
128 19 : deviceId = static_cast<uint32_t>(val);
129 19 : return true;
130 : }
131 :
132 34 : bool ArgsParser::ParseHostPid(const std::string ¶)
133 : {
134 34 : int32_t val = 0;
135 34 : if (!TransStrToInt(para, val)) {
136 2 : BQS_LOG_ERROR("Parse pid failed, param is %s", para.c_str());
137 2 : return false;
138 : }
139 :
140 32 : if (val <= 0) {
141 2 : BQS_LOG_ERROR("Pid param[%s] value invalided", para.c_str());
142 2 : return false;
143 : }
144 :
145 30 : hostPid_ = static_cast<uint32_t>(val);
146 30 : withHostPid_ = true;
147 30 : return true;
148 : }
149 :
150 30 : bool ArgsParser::ParsePidSign(const std::string ¶)
151 : {
152 30 : pidSign_ = para;
153 30 : withPidSign_ = true;
154 30 : return true;
155 : }
156 :
157 26 : bool ArgsParser::ParseVfId(const std::string ¶)
158 : {
159 26 : int32_t val = 0;
160 26 : if (!TransStrToInt(para, val)) {
161 2 : BQS_LOG_ERROR("Parse vfId failed, param is %s", para.c_str());
162 2 : return false;
163 : }
164 :
165 24 : if ((val < 0) || (val > VF_ID_MAX)) {
166 2 : BQS_LOG_ERROR("VfId param[%s] invalided, value is not in [%u, %u]",
167 : para.c_str(), 0, VF_ID_MAX);
168 2 : return false;
169 : }
170 :
171 22 : vfId_ = static_cast<uint32_t>(val);
172 22 : withVfId_ = true;
173 22 : return true;
174 : }
175 :
176 27 : void ArgsParser::SetLogLevel(const int32_t logLevel, const int32_t eventLevel) const
177 : {
178 27 : if (bqs::FeatureCtrl::IsHostQs()) {
179 1 : bqs::HostQsLog::GetInstance().DlogSetLevel(logLevel, eventLevel);
180 1 : LogAttr dlogAttrInfo = {};
181 1 : dlogAttrInfo.type = APPLICATION;
182 1 : dlogAttrInfo.pid = hostPid_;
183 1 : dlogAttrInfo.deviceId = deviceId_;
184 1 : dlogAttrInfo.mode = 0;
185 1 : bqs::HostQsLog::GetInstance().DlogSetAttr(dlogAttrInfo);
186 : } else {
187 26 : if (&dlog_setlevel != nullptr) {
188 26 : if (dlog_setlevel(-1, logLevel, eventLevel) != SUCCESS_VALUE) {
189 24 : BQS_LOG_WARN("Set log level failed");
190 : }
191 : }
192 26 : if (&DlogSetAttr != nullptr) {
193 26 : LogAttr dlogAttrInfo = {};
194 26 : dlogAttrInfo.type = APPLICATION;
195 26 : dlogAttrInfo.pid = hostPid_;
196 26 : dlogAttrInfo.deviceId = deviceId_;
197 26 : dlogAttrInfo.mode = 0;
198 26 : if (DlogSetAttr(dlogAttrInfo) != SUCCESS_VALUE) {
199 2 : BQS_LOG_WARN("Set log attr failed");
200 : }
201 : }
202 : }
203 27 : }
204 :
205 1 : void ArgsParser::SetAicpuLogLevel() const
206 : {
207 1 : if ((aicpulogLevel_ >= DEBUG_LOG) && (aicpulogLevel_ <= ERROR_LOG)) {
208 1 : if (bqs::FeatureCtrl::IsHostQs()) {
209 0 : bqs::HostQsLog::GetInstance().DlogSetLevel(aicpulogLevel_, eventLevel_);
210 : } else {
211 1 : if (&dlog_setlevel != nullptr) {
212 1 : if (dlog_setlevel(AICPU, aicpulogLevel_, eventLevel_) != SUCCESS_VALUE) {
213 1 : BQS_LOG_WARN("Set aicpu log level failed");
214 : }
215 : }
216 : }
217 : }
218 1 : }
219 :
220 8 : bool ArgsParser::ParseLogAndEventLevel(const std::string ¶)
221 : {
222 8 : int32_t val = 0;
223 8 : if (!TransStrToInt(para, val)) {
224 1 : return false;
225 : }
226 :
227 7 : if (val < 0) {
228 1 : return false;
229 : }
230 :
231 6 : logLevel_ = val % VALUE_FOR_CALCULATE_LOG_LEVEL;
232 6 : eventLevel_ = val / VALUE_FOR_CALCULATE_LOG_LEVEL;
233 6 : withLogLevel_ = true;
234 6 : SetLogLevel(logLevel_, eventLevel_);
235 6 : return true;
236 : }
237 :
238 2 : bool ArgsParser::ParseAicpuLogLevel(const std::string ¶)
239 : {
240 2 : int32_t val = 0;
241 2 : if (!TransStrToInt(para, val)) {
242 1 : return true;
243 : }
244 :
245 1 : aicpulogLevel_ = val;
246 1 : withLogLevel_ = true;
247 1 : SetAicpuLogLevel();
248 1 : return true;
249 : }
250 :
251 28 : bool ArgsParser::ParseDeployMode(const std::string ¶)
252 : {
253 28 : int32_t val = 0;
254 28 : if (!TransStrToInt(para, val)) {
255 2 : BQS_LOG_ERROR("Parse deploy mode failed, param is %s", para.c_str());
256 2 : return false;
257 : }
258 :
259 26 : if ((val < static_cast<int32_t>(bqs::QueueSchedulerRunMode::SINGLE_PROCESS)) ||
260 25 : (val > static_cast<int32_t>(bqs::QueueSchedulerRunMode::MULTI_THREAD))) {
261 1 : BQS_LOG_ERROR("deploy mode param[%s] invalided, value is not in [%u, %u]", para.c_str(),
262 : static_cast<uint32_t>(QueueSchedulerRunMode::SINGLE_PROCESS),
263 : static_cast<uint32_t>(QueueSchedulerRunMode::MULTI_THREAD));
264 1 : return false;
265 : }
266 :
267 25 : deployMode_ = static_cast<QueueSchedulerRunMode>(val);
268 25 : return true;
269 : }
270 :
271 : // ignore error
272 29 : bool ArgsParser::ParseReschedInterval(const std::string ¶)
273 : {
274 29 : int32_t val = 0;
275 29 : if (!TransStrToInt(para, val)) {
276 1 : BQS_LOG_WARN("Parse resched interval not success, using default value %d ms", reschedInterval_);
277 1 : return true;
278 : }
279 :
280 28 : if ((val < RESCHED_INTERVAL_CLOSE) || (val > RESCHED_INTERVAL_MAX)) {
281 1 : BQS_LOG_WARN("resched interval param[%s] invalided, value is not in [%d, %d], using default value[%d] ms",
282 : para.c_str(), RESCHED_INTERVAL_CLOSE, RESCHED_INTERVAL_MAX, reschedInterval_);
283 1 : return true;
284 : }
285 :
286 27 : reschedInterval_ = val;
287 27 : return true;
288 : }
289 :
290 :
291 25 : bool ArgsParser::ParseGroupName(const std::string ¶)
292 : {
293 25 : groupName_ = para;
294 25 : withGroupName_ = true;
295 25 : return true;
296 : }
297 :
298 2 : bool ArgsParser::ParseSchedPolicy(const std::string ¶)
299 : {
300 2 : uint64_t val = 0;
301 2 : if (!TransStrToull(para, val)) {
302 1 : BQS_LOG_ERROR("Parse SchedPolicy failed, param is %s", para.c_str());
303 1 : return false;
304 : }
305 :
306 1 : BQS_LOG_INFO("SchedPolicy is [0x%lx].", val);
307 1 : schedPolicy_ = val;
308 1 : return true;
309 : }
310 :
311 : // ignore error
312 5 : bool ArgsParser::ParseStarter(const std::string ¶)
313 : {
314 5 : int32_t val = 0;
315 5 : if (!TransStrToInt(para, val)) {
316 1 : BQS_LOG_WARN("Parse starter failed, param is %s", para.c_str());
317 1 : return true;
318 : }
319 :
320 4 : starter_ = static_cast<bqs::QsStartType>(val);
321 4 : withStarter_ = true;
322 4 : return true;
323 : }
324 :
325 1 : bool ArgsParser::ParseProfCfgData(const std::string ¶)
326 : {
327 1 : profCfgData_ = para;
328 1 : return true;
329 : }
330 :
331 : // ignore error
332 3 : bool ArgsParser::ParseProfFlag(const std::string ¶)
333 : {
334 3 : int32_t val = 0;
335 3 : if (!TransStrToInt(para, val)) {
336 1 : BQS_LOG_WARN("Parse prof flag failed, param is %s", para.c_str());
337 1 : return true;
338 : }
339 :
340 2 : profFlag_ = (val != 0);
341 2 : return true;
342 : }
343 :
344 : // ignore error
345 5 : bool ArgsParser::ParseAbnormalInterval(const std::string ¶)
346 : {
347 5 : int32_t val = 0;
348 5 : if (!TransStrToInt(para, val)) {
349 1 : BQS_LOG_INFO("Parse abnormal interval not success, using default value %d", abnormalInterval_);
350 1 : return true;
351 : }
352 :
353 4 : if ((val <= ABNORMAL_INTERVAL_MIN) || (val > ABNORMAL_INTERVAL_MAX)) {
354 1 : BQS_LOG_WARN("abnormal interval param[%s] invalided, value is not in [%d, %d], using default value[%d]",
355 : para.c_str(), ABNORMAL_INTERVAL_MIN, ABNORMAL_INTERVAL_MAX, abnormalInterval_);
356 1 : return true;
357 : }
358 :
359 3 : abnormalInterval_ = val;
360 3 : return true;
361 : }
362 :
363 : // ignore error
364 9 : bool ArgsParser::ParseResourceList(const std::string ¶)
365 : {
366 9 : size_t pos = para.find(",");
367 9 : if (pos == std::string::npos) {
368 1 : return true;
369 : }
370 8 : std::string deviceStr0 = para.substr(0, pos);
371 8 : std::string deviceStr1 = para.substr(pos + 1, para.length());
372 8 : int32_t curId = 0;
373 8 : if (!ParseDeviceId(deviceStr0, curId)) {
374 1 : return true;
375 : }
376 7 : resVec_.push_back(curId);
377 :
378 7 : if (!ParseDeviceId(deviceStr1, curId)) {
379 1 : return true;
380 : }
381 6 : resVec_.push_back(curId);
382 6 : return true;
383 8 : }
384 :
385 : // ignore error
386 3 : bool ArgsParser::ParseDeviceIdsList(const std::string ¶)
387 : {
388 3 : std::istringstream issStr(para);
389 3 : std::string idStr;
390 3 : int32_t curId = 0;
391 9 : while (std::getline(issStr, idStr, ',')) {
392 7 : if (!ParseDeviceId(idStr, curId)) {
393 1 : return true;
394 : }
395 6 : devIdVec_.push_back(curId);
396 : }
397 2 : return true;
398 3 : }
399 :
400 21 : std::string ArgsParser::GetParaParsedStr()
401 : {
402 21 : std::ostringstream oss;
403 21 : oss << "deviceId=" << deviceId_ << ", hostPid=" << hostPid_ << ", pidSign=" << pidSign_
404 21 : << ", vfId=" << vfId_ << ", logLevel=" << logLevel_ << ", eventLevel_=" << eventLevel_
405 21 : << ", aicpulogLevel=" << aicpulogLevel_ << ", deployMode_=" << static_cast<uint32_t>(deployMode_)
406 21 : << ", reschedInterval_=" << reschedInterval_ << ", groupName_=" << groupName_
407 21 : << ", schedPolicy_=" << schedPolicy_ << ", starter_=" << static_cast<uint32_t>(starter_)
408 21 : << ", profCfgData_=" << profCfgData_ << ", profFlag_=" << profFlag_
409 21 : << ", abnormalInterval_=" << abnormalInterval_ << ", withDeviceId_=" << withDeviceId_
410 21 : << ", withHostPid_=" << withHostPid_ << ", withPidSign_=" << withPidSign_
411 21 : << ", withVfId_=" << withVfId_ << ", withLogLevel_=" << withLogLevel_
412 21 : << ", withGroupName_=" << withGroupName_ << ", withStarter_=" << withStarter_;
413 :
414 42 : return oss.str();
415 21 : }
416 : }
|
