1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) 2022 Marvell. 3 */ 4 5 #include <unistd.h> 6 7 #include <rte_common.h> 8 #include <rte_malloc.h> 9 #include <rte_mldev.h> 10 11 #include "test_model_ops.h" 12 13 static bool 14 test_model_ops_cap_check(struct ml_options *opt) 15 { 16 if (!ml_test_cap_check(opt)) 17 return false; 18 19 return true; 20 } 21 22 static int 23 test_model_ops_opt_check(struct ml_options *opt) 24 { 25 uint32_t i; 26 int ret; 27 28 /* check common opts */ 29 ret = ml_test_opt_check(opt); 30 if (ret != 0) 31 return ret; 32 33 /* check model file availability */ 34 for (i = 0; i < opt->nb_filelist; i++) { 35 if (access(opt->filelist[i].model, F_OK) == -1) { 36 ml_err("Model file not available: id = %u, file = %s", i, 37 opt->filelist[i].model); 38 return -ENOENT; 39 } 40 } 41 42 return 0; 43 } 44 45 static void 46 test_model_ops_opt_dump(struct ml_options *opt) 47 { 48 uint32_t i; 49 50 /* dump common opts */ 51 ml_test_opt_dump(opt); 52 53 /* dump test specific opts */ 54 ml_dump_begin("models"); 55 for (i = 0; i < opt->nb_filelist; i++) 56 ml_dump_list("model", i, opt->filelist[i].model); 57 ml_dump_end; 58 } 59 60 static int 61 test_model_ops_setup(struct ml_test *test, struct ml_options *opt) 62 { 63 struct test_model_ops *t; 64 void *test_model_ops; 65 int ret = 0; 66 uint32_t i; 67 68 /* allocate model ops test structure */ 69 test_model_ops = rte_zmalloc_socket(test->name, sizeof(struct test_model_ops), 70 RTE_CACHE_LINE_SIZE, opt->socket_id); 71 if (test_model_ops == NULL) { 72 ml_err("Failed to allocate memory for test_model"); 73 ret = -ENOMEM; 74 goto error; 75 } 76 test->test_priv = test_model_ops; 77 t = ml_test_priv(test); 78 79 t->cmn.result = ML_TEST_FAILED; 80 t->cmn.opt = opt; 81 82 /* get device info */ 83 ret = rte_ml_dev_info_get(opt->dev_id, &t->cmn.dev_info); 84 if (ret < 0) { 85 ml_err("Failed to get device info"); 86 goto error; 87 } 88 89 /* set model initial state */ 90 for (i = 0; i < opt->nb_filelist; i++) 91 t->model[i].state = MODEL_INITIAL; 92 93 return 0; 94 95 error: 96 if (test_model_ops != NULL) 97 rte_free(test_model_ops); 98 99 return ret; 100 } 101 102 static void 103 test_model_ops_destroy(struct ml_test *test, struct ml_options *opt) 104 { 105 struct test_model_ops *t; 106 107 RTE_SET_USED(opt); 108 109 t = ml_test_priv(test); 110 if (t != NULL) 111 rte_free(t); 112 } 113 114 static int 115 test_model_ops_mldev_setup(struct ml_test *test, struct ml_options *opt) 116 { 117 int ret; 118 119 ret = ml_test_device_configure(test, opt); 120 if (ret != 0) 121 return ret; 122 123 ret = ml_test_device_start(test, opt); 124 if (ret != 0) 125 goto error; 126 127 return 0; 128 129 error: 130 ml_test_device_close(test, opt); 131 132 return ret; 133 } 134 135 static int 136 test_model_ops_mldev_destroy(struct ml_test *test, struct ml_options *opt) 137 { 138 int ret; 139 140 ret = ml_test_device_stop(test, opt); 141 if (ret != 0) 142 goto error; 143 144 ret = ml_test_device_close(test, opt); 145 if (ret != 0) 146 return ret; 147 148 return 0; 149 150 error: 151 ml_test_device_close(test, opt); 152 153 return ret; 154 } 155 156 /* Sub-test A: (load -> start -> stop -> unload) x n */ 157 static int 158 test_model_ops_subtest_a(struct ml_test *test, struct ml_options *opt) 159 { 160 struct test_model_ops *t; 161 int ret = 0; 162 uint32_t i; 163 164 t = ml_test_priv(test); 165 166 /* load + start + stop + unload */ 167 for (i = 0; i < opt->nb_filelist; i++) { 168 ret = ml_model_load(test, opt, &t->model[i], i); 169 if (ret != 0) 170 goto error; 171 172 ret = ml_model_start(test, opt, &t->model[i], i); 173 if (ret != 0) 174 goto error; 175 176 ret = ml_model_stop(test, opt, &t->model[i], i); 177 if (ret != 0) 178 goto error; 179 180 ret = ml_model_unload(test, opt, &t->model[i], i); 181 if (ret != 0) 182 goto error; 183 } 184 185 error: 186 for (i = 0; i < opt->nb_filelist; i++) 187 ml_model_stop(test, opt, &t->model[i], i); 188 189 for (i = 0; i < opt->nb_filelist; i++) 190 ml_model_unload(test, opt, &t->model[i], i); 191 192 return ret; 193 } 194 195 /* Sub-test B: load x n -> start x n -> stop x n -> unload x n */ 196 static int 197 test_model_ops_subtest_b(struct ml_test *test, struct ml_options *opt) 198 { 199 struct test_model_ops *t; 200 int ret = 0; 201 uint32_t i; 202 203 t = ml_test_priv(test); 204 205 /* load */ 206 for (i = 0; i < opt->nb_filelist; i++) { 207 ret = ml_model_load(test, opt, &t->model[i], i); 208 if (ret != 0) 209 goto error; 210 } 211 212 /* start */ 213 for (i = 0; i < opt->nb_filelist; i++) { 214 ret = ml_model_start(test, opt, &t->model[i], i); 215 if (ret != 0) 216 goto error; 217 } 218 219 /* stop */ 220 for (i = 0; i < opt->nb_filelist; i++) { 221 ret = ml_model_stop(test, opt, &t->model[i], i); 222 if (ret != 0) 223 goto error; 224 } 225 226 /* unload */ 227 for (i = 0; i < opt->nb_filelist; i++) { 228 ret = ml_model_unload(test, opt, &t->model[i], i); 229 if (ret != 0) 230 goto error; 231 } 232 233 return 0; 234 235 error: 236 for (i = 0; i < opt->nb_filelist; i++) 237 ml_model_stop(test, opt, &t->model[i], i); 238 239 for (i = 0; i < opt->nb_filelist; i++) 240 ml_model_unload(test, opt, &t->model[i], i); 241 242 return ret; 243 } 244 245 /* Sub-test C: load x n + (start + stop) x n + unload x n */ 246 static int 247 test_model_ops_subtest_c(struct ml_test *test, struct ml_options *opt) 248 { 249 struct test_model_ops *t; 250 int ret = 0; 251 uint32_t i; 252 253 t = ml_test_priv(test); 254 255 /* load */ 256 for (i = 0; i < opt->nb_filelist; i++) { 257 ret = ml_model_load(test, opt, &t->model[i], i); 258 if (ret != 0) 259 goto error; 260 } 261 262 /* start + stop */ 263 for (i = 0; i < opt->nb_filelist; i++) { 264 ret = ml_model_start(test, opt, &t->model[i], i); 265 if (ret != 0) 266 goto error; 267 268 ret = ml_model_stop(test, opt, &t->model[i], i); 269 if (ret != 0) 270 goto error; 271 } 272 273 /* unload */ 274 for (i = 0; i < opt->nb_filelist; i++) { 275 ret = ml_model_unload(test, opt, &t->model[i], i); 276 if (ret != 0) 277 goto error; 278 } 279 280 return 0; 281 282 error: 283 for (i = 0; i < opt->nb_filelist; i++) 284 ml_model_stop(test, opt, &t->model[i], i); 285 286 for (i = 0; i < opt->nb_filelist; i++) 287 ml_model_unload(test, opt, &t->model[i], i); 288 289 return ret; 290 } 291 292 /* Sub-test D: (load + start) x n -> (stop + unload) x n */ 293 static int 294 test_model_ops_subtest_d(struct ml_test *test, struct ml_options *opt) 295 { 296 struct test_model_ops *t; 297 int ret = 0; 298 uint32_t i; 299 300 t = ml_test_priv(test); 301 302 /* load + start */ 303 for (i = 0; i < opt->nb_filelist; i++) { 304 ret = ml_model_load(test, opt, &t->model[i], i); 305 if (ret != 0) 306 goto error; 307 308 ret = ml_model_start(test, opt, &t->model[i], i); 309 if (ret != 0) 310 goto error; 311 } 312 313 /* stop + unload */ 314 for (i = 0; i < opt->nb_filelist; i++) { 315 ret = ml_model_stop(test, opt, &t->model[i], i); 316 if (ret != 0) 317 goto error; 318 319 ret = ml_model_unload(test, opt, &t->model[i], i); 320 if (ret != 0) 321 goto error; 322 } 323 324 return 0; 325 326 error: 327 for (i = 0; i < opt->nb_filelist; i++) 328 ml_model_stop(test, opt, &t->model[i], i); 329 330 for (i = 0; i < opt->nb_filelist; i++) 331 ml_model_unload(test, opt, &t->model[i], i); 332 333 return ret; 334 } 335 336 static int 337 test_model_ops_driver(struct ml_test *test, struct ml_options *opt) 338 { 339 struct test_model_ops *t; 340 int ret = 0; 341 342 t = ml_test_priv(test); 343 344 /* device setup */ 345 ret = test_model_ops_mldev_setup(test, opt); 346 if (ret != 0) 347 return ret; 348 349 printf("\n"); 350 351 /* sub-test A */ 352 ret = test_model_ops_subtest_a(test, opt); 353 if (ret != 0) { 354 printf("Model Ops Sub-test A: " CLRED "%s" CLNRM "\n", "Failed"); 355 goto error; 356 } else { 357 printf("Model Ops Sub-test A: " CLYEL "%s" CLNRM "\n", "Passed"); 358 } 359 360 /* sub-test B */ 361 ret = test_model_ops_subtest_b(test, opt); 362 if (ret != 0) { 363 printf("Model Ops Sub-test B: " CLRED "%s" CLNRM "\n", "Failed"); 364 goto error; 365 } else { 366 printf("Model Ops Sub-test B: " CLYEL "%s" CLNRM "\n", "Passed"); 367 } 368 369 /* sub-test C */ 370 ret = test_model_ops_subtest_c(test, opt); 371 if (ret != 0) { 372 printf("Model Ops Sub-test C: " CLRED "%s" CLNRM "\n", "Failed"); 373 goto error; 374 } else { 375 printf("Model Ops Sub-test C: " CLYEL "%s" CLNRM "\n", "Passed"); 376 } 377 378 /* sub-test D */ 379 ret = test_model_ops_subtest_d(test, opt); 380 if (ret != 0) { 381 printf("Model Ops Sub-test D: " CLRED "%s" CLNRM "\n", "Failed"); 382 goto error; 383 } else { 384 printf("Model Ops Sub-test D: " CLYEL "%s" CLNRM "\n", "Passed"); 385 } 386 387 printf("\n"); 388 389 /* device destroy */ 390 ret = test_model_ops_mldev_destroy(test, opt); 391 if (ret != 0) 392 return ret; 393 394 t->cmn.result = ML_TEST_SUCCESS; 395 396 return 0; 397 398 error: 399 test_model_ops_mldev_destroy(test, opt); 400 401 t->cmn.result = ML_TEST_FAILED; 402 403 return ret; 404 } 405 406 static int 407 test_model_ops_result(struct ml_test *test, struct ml_options *opt) 408 { 409 struct test_model_ops *t; 410 411 RTE_SET_USED(opt); 412 413 t = ml_test_priv(test); 414 415 return t->cmn.result; 416 } 417 418 static const struct ml_test_ops model_ops = { 419 .cap_check = test_model_ops_cap_check, 420 .opt_check = test_model_ops_opt_check, 421 .opt_dump = test_model_ops_opt_dump, 422 .test_setup = test_model_ops_setup, 423 .test_destroy = test_model_ops_destroy, 424 .test_driver = test_model_ops_driver, 425 .test_result = test_model_ops_result, 426 }; 427 428 ML_TEST_REGISTER(model_ops); 429