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& para)
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)", para.c_str(), 0, QS_FW_CHIP_NUM_MAX);
105 4 : return false;
106 : }
107 :
108 34 : deviceId_ = static_cast<uint32_t>(val);
109 34 : withDeviceId_ = true;
110 34 : return true;
111 : }
112 :
113 22 : bool ArgsParser::ParseDeviceId(const std::string& para, int32_t& deviceId) const
114 : {
115 22 : int32_t val = 0;
116 22 : if (!TransStrToInt(para, val)) {
117 1 : BQS_LOG_WARN("Parse deviceId failed, param is %s", para.c_str());
118 1 : return false;
119 : }
120 :
121 21 : if ((val < 0) || (val >= QS_FW_CHIP_NUM_MAX)) {
122 2 : BQS_LOG_WARN("DeviceId param[%s] invalided, value is not in [%d, %d)", para.c_str(), 0, QS_FW_CHIP_NUM_MAX);
123 2 : return false;
124 : }
125 :
126 19 : deviceId = static_cast<uint32_t>(val);
127 19 : return true;
128 : }
129 :
130 34 : bool ArgsParser::ParseHostPid(const std::string& para)
131 : {
132 34 : int32_t val = 0;
133 34 : if (!TransStrToInt(para, val)) {
134 2 : BQS_LOG_ERROR("Parse pid failed, param is %s", para.c_str());
135 2 : return false;
136 : }
137 :
138 32 : if (val <= 0) {
139 2 : BQS_LOG_ERROR("Pid param[%s] value invalided", para.c_str());
140 2 : return false;
141 : }
142 :
143 30 : hostPid_ = static_cast<uint32_t>(val);
144 30 : withHostPid_ = true;
145 30 : return true;
146 : }
147 :
148 30 : bool ArgsParser::ParsePidSign(const std::string& para)
149 : {
150 30 : pidSign_ = para;
151 30 : withPidSign_ = true;
152 30 : return true;
153 : }
154 :
155 26 : bool ArgsParser::ParseVfId(const std::string& para)
156 : {
157 26 : int32_t val = 0;
158 26 : if (!TransStrToInt(para, val)) {
159 2 : BQS_LOG_ERROR("Parse vfId failed, param is %s", para.c_str());
160 2 : return false;
161 : }
162 :
163 24 : if ((val < 0) || (val > VF_ID_MAX)) {
164 2 : BQS_LOG_ERROR("VfId param[%s] invalided, value is not in [%u, %u]", para.c_str(), 0, VF_ID_MAX);
165 2 : return false;
166 : }
167 :
168 22 : vfId_ = static_cast<uint32_t>(val);
169 22 : withVfId_ = true;
170 22 : return true;
171 : }
172 :
173 27 : void ArgsParser::SetLogLevel(const int32_t logLevel, const int32_t eventLevel) const
174 : {
175 27 : if (bqs::FeatureCtrl::IsHostQs()) {
176 1 : bqs::HostQsLog::GetInstance().DlogSetLevel(logLevel, eventLevel);
177 1 : LogAttr dlogAttrInfo = {};
178 1 : dlogAttrInfo.type = APPLICATION;
179 1 : dlogAttrInfo.pid = hostPid_;
180 1 : dlogAttrInfo.deviceId = deviceId_;
181 1 : dlogAttrInfo.mode = 0;
182 1 : bqs::HostQsLog::GetInstance().DlogSetAttr(dlogAttrInfo);
183 : } else {
184 26 : if (&dlog_setlevel != nullptr) {
185 26 : if (dlog_setlevel(-1, logLevel, eventLevel) != SUCCESS_VALUE) {
186 24 : BQS_LOG_WARN("Set log level failed");
187 : }
188 : }
189 26 : if (&DlogSetAttr != nullptr) {
190 26 : LogAttr dlogAttrInfo = {};
191 26 : dlogAttrInfo.type = APPLICATION;
192 26 : dlogAttrInfo.pid = hostPid_;
193 26 : dlogAttrInfo.deviceId = deviceId_;
194 26 : dlogAttrInfo.mode = 0;
195 26 : if (DlogSetAttr(dlogAttrInfo) != SUCCESS_VALUE) {
196 2 : BQS_LOG_WARN("Set log attr failed");
197 : }
198 : }
199 : }
200 27 : }
201 :
202 1 : void ArgsParser::SetAicpuLogLevel() const
203 : {
204 1 : if ((aicpulogLevel_ >= DEBUG_LOG) && (aicpulogLevel_ <= ERROR_LOG)) {
205 1 : if (bqs::FeatureCtrl::IsHostQs()) {
206 0 : bqs::HostQsLog::GetInstance().DlogSetLevel(aicpulogLevel_, eventLevel_);
207 : } else {
208 1 : if (&dlog_setlevel != nullptr) {
209 1 : if (dlog_setlevel(AICPU, aicpulogLevel_, eventLevel_) != SUCCESS_VALUE) {
210 1 : BQS_LOG_WARN("Set aicpu log level failed");
211 : }
212 : }
213 : }
214 : }
215 1 : }
216 :
217 8 : bool ArgsParser::ParseLogAndEventLevel(const std::string& para)
218 : {
219 8 : int32_t val = 0;
220 8 : if (!TransStrToInt(para, val)) {
221 1 : return false;
222 : }
223 :
224 7 : if (val < 0) {
225 1 : return false;
226 : }
227 :
228 6 : logLevel_ = val % VALUE_FOR_CALCULATE_LOG_LEVEL;
229 6 : eventLevel_ = val / VALUE_FOR_CALCULATE_LOG_LEVEL;
230 6 : withLogLevel_ = true;
231 6 : SetLogLevel(logLevel_, eventLevel_);
232 6 : return true;
233 : }
234 :
235 2 : bool ArgsParser::ParseAicpuLogLevel(const std::string& para)
236 : {
237 2 : int32_t val = 0;
238 2 : if (!TransStrToInt(para, val)) {
239 1 : return true;
240 : }
241 :
242 1 : aicpulogLevel_ = val;
243 1 : withLogLevel_ = true;
244 1 : SetAicpuLogLevel();
245 1 : return true;
246 : }
247 :
248 28 : bool ArgsParser::ParseDeployMode(const std::string& para)
249 : {
250 28 : int32_t val = 0;
251 28 : if (!TransStrToInt(para, val)) {
252 2 : BQS_LOG_ERROR("Parse deploy mode failed, param is %s", para.c_str());
253 2 : return false;
254 : }
255 :
256 26 : if ((val < static_cast<int32_t>(bqs::QueueSchedulerRunMode::SINGLE_PROCESS)) ||
257 25 : (val > static_cast<int32_t>(bqs::QueueSchedulerRunMode::MULTI_THREAD))) {
258 1 : BQS_LOG_ERROR(
259 : "deploy mode param[%s] invalided, value is not in [%u, %u]", para.c_str(),
260 : static_cast<uint32_t>(QueueSchedulerRunMode::SINGLE_PROCESS),
261 : static_cast<uint32_t>(QueueSchedulerRunMode::MULTI_THREAD));
262 1 : return false;
263 : }
264 :
265 25 : deployMode_ = static_cast<QueueSchedulerRunMode>(val);
266 25 : return true;
267 : }
268 :
269 : // ignore error
270 29 : bool ArgsParser::ParseReschedInterval(const std::string& para)
271 : {
272 29 : int32_t val = 0;
273 29 : if (!TransStrToInt(para, val)) {
274 1 : BQS_LOG_WARN("Parse resched interval not success, using default value %d ms", reschedInterval_);
275 1 : return true;
276 : }
277 :
278 28 : if ((val < RESCHED_INTERVAL_CLOSE) || (val > RESCHED_INTERVAL_MAX)) {
279 1 : BQS_LOG_WARN(
280 : "resched interval param[%s] invalided, value is not in [%d, %d], using default value[%d] ms", para.c_str(),
281 : RESCHED_INTERVAL_CLOSE, RESCHED_INTERVAL_MAX, reschedInterval_);
282 1 : return true;
283 : }
284 :
285 27 : reschedInterval_ = val;
286 27 : return true;
287 : }
288 :
289 25 : bool ArgsParser::ParseGroupName(const std::string& para)
290 : {
291 25 : groupName_ = para;
292 25 : withGroupName_ = true;
293 25 : return true;
294 : }
295 :
296 2 : bool ArgsParser::ParseSchedPolicy(const std::string& para)
297 : {
298 2 : uint64_t val = 0;
299 2 : if (!TransStrToull(para, val)) {
300 1 : BQS_LOG_ERROR("Parse SchedPolicy failed, param is %s", para.c_str());
301 1 : return false;
302 : }
303 :
304 1 : BQS_LOG_INFO("SchedPolicy is [0x%lx].", val);
305 1 : schedPolicy_ = val;
306 1 : return true;
307 : }
308 :
309 : // ignore error
310 5 : bool ArgsParser::ParseStarter(const std::string& para)
311 : {
312 5 : int32_t val = 0;
313 5 : if (!TransStrToInt(para, val)) {
314 1 : BQS_LOG_WARN("Parse starter failed, param is %s", para.c_str());
315 1 : return true;
316 : }
317 :
318 4 : starter_ = static_cast<bqs::QsStartType>(val);
319 4 : withStarter_ = true;
320 4 : return true;
321 : }
322 :
323 1 : bool ArgsParser::ParseProfCfgData(const std::string& para)
324 : {
325 1 : profCfgData_ = para;
326 1 : return true;
327 : }
328 :
329 : // ignore error
330 3 : bool ArgsParser::ParseProfFlag(const std::string& para)
331 : {
332 3 : int32_t val = 0;
333 3 : if (!TransStrToInt(para, val)) {
334 1 : BQS_LOG_WARN("Parse prof flag failed, param is %s", para.c_str());
335 1 : return true;
336 : }
337 :
338 2 : profFlag_ = (val != 0);
339 2 : return true;
340 : }
341 :
342 : // ignore error
343 5 : bool ArgsParser::ParseAbnormalInterval(const std::string& para)
344 : {
345 5 : int32_t val = 0;
346 5 : if (!TransStrToInt(para, val)) {
347 1 : BQS_LOG_INFO("Parse abnormal interval not success, using default value %d", abnormalInterval_);
348 1 : return true;
349 : }
350 :
351 4 : if ((val <= ABNORMAL_INTERVAL_MIN) || (val > ABNORMAL_INTERVAL_MAX)) {
352 1 : BQS_LOG_WARN(
353 : "abnormal interval param[%s] invalided, value is not in [%d, %d], using default value[%d]", para.c_str(),
354 : ABNORMAL_INTERVAL_MIN, ABNORMAL_INTERVAL_MAX, abnormalInterval_);
355 1 : return true;
356 : }
357 :
358 3 : abnormalInterval_ = val;
359 3 : return true;
360 : }
361 :
362 : // ignore error
363 9 : bool ArgsParser::ParseResourceList(const std::string& para)
364 : {
365 9 : size_t pos = para.find(",");
366 9 : if (pos == std::string::npos) {
367 1 : return true;
368 : }
369 8 : std::string deviceStr0 = para.substr(0, pos);
370 8 : std::string deviceStr1 = para.substr(pos + 1, para.length());
371 8 : int32_t curId = 0;
372 8 : if (!ParseDeviceId(deviceStr0, curId)) {
373 1 : return true;
374 : }
375 7 : resVec_.push_back(curId);
376 :
377 7 : if (!ParseDeviceId(deviceStr1, curId)) {
378 1 : return true;
379 : }
380 6 : resVec_.push_back(curId);
381 6 : return true;
382 8 : }
383 :
384 : // ignore error
385 3 : bool ArgsParser::ParseDeviceIdsList(const std::string& para)
386 : {
387 3 : std::istringstream issStr(para);
388 3 : std::string idStr;
389 3 : int32_t curId = 0;
390 9 : while (std::getline(issStr, idStr, ',')) {
391 7 : if (!ParseDeviceId(idStr, curId)) {
392 1 : return true;
393 : }
394 6 : devIdVec_.push_back(curId);
395 : }
396 2 : return true;
397 3 : }
398 :
399 21 : std::string ArgsParser::GetParaParsedStr()
400 : {
401 21 : std::ostringstream oss;
402 21 : oss << "deviceId=" << deviceId_ << ", hostPid=" << hostPid_ << ", pidSign=" << pidSign_ << ", vfId=" << vfId_
403 21 : << ", logLevel=" << logLevel_ << ", eventLevel_=" << eventLevel_ << ", aicpulogLevel=" << aicpulogLevel_
404 21 : << ", deployMode_=" << static_cast<uint32_t>(deployMode_) << ", reschedInterval_=" << reschedInterval_
405 21 : << ", groupName_=" << groupName_ << ", schedPolicy_=" << schedPolicy_
406 21 : << ", starter_=" << static_cast<uint32_t>(starter_) << ", profCfgData_=" << profCfgData_
407 21 : << ", profFlag_=" << profFlag_ << ", abnormalInterval_=" << abnormalInterval_
408 21 : << ", withDeviceId_=" << withDeviceId_ << ", withHostPid_=" << withHostPid_ << ", withPidSign_=" << withPidSign_
409 21 : << ", withVfId_=" << withVfId_ << ", withLogLevel_=" << withLogLevel_ << ", withGroupName_=" << withGroupName_
410 21 : << ", withStarter_=" << withStarter_;
411 :
412 42 : return oss.str();
413 21 : }
414 : } // namespace bqs
|
