test/test/test_meter.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <stdint.h>
   9 #include <unistd.h>
  10
  11 #include "test.h"
  12
  13 #include <rte_cycles.h>
  14 #include <rte_meter.h>
  15
  16 #define mlog(format, ...) do{\
  17                 printf("Line %d:",__LINE__);\
  18                 printf(format, ##__VA_ARGS__);\
  19                 printf("\n");\
  20         }while(0);
  21
  22 #define melog(format, ...) do{\
  23                 printf("Line %d:",__LINE__);\
  24                 printf(format, ##__VA_ARGS__);\
  25                 printf(" failed!\n");\
  26                 return -1;\
  27         }while(0);
  28
  29 #define TM_TEST_SRTCM_CIR_DF 46000000
  30 #define TM_TEST_SRTCM_CBS_DF 2048
  31 #define TM_TEST_SRTCM_EBS_DF 4096
  32
  33 #define TM_TEST_TRTCM_CIR_DF 46000000
  34 #define TM_TEST_TRTCM_PIR_DF 69000000
  35 #define TM_TEST_TRTCM_CBS_DF 2048
  36 #define TM_TEST_TRTCM_PBS_DF 4096
  37
  38 static struct rte_meter_srtcm_params sparams =
  39                                 {.cir = TM_TEST_SRTCM_CIR_DF,
  40                                  .cbs = TM_TEST_SRTCM_CBS_DF,
  41                                  .ebs = TM_TEST_SRTCM_EBS_DF,};
  42
  43 static struct   rte_meter_trtcm_params tparams=
  44                                 {.cir = TM_TEST_TRTCM_CIR_DF,
  45                                  .pir = TM_TEST_TRTCM_PIR_DF,
  46                                  .cbs = TM_TEST_TRTCM_CBS_DF,
  47                                  .pbs = TM_TEST_TRTCM_PBS_DF,};
  48
  49 /**
  50  * functional test for rte_meter_srtcm_config
  51  */
  52 static inline int
  53 tm_test_srtcm_config(void)
  54 {
  55 #define SRTCM_CFG_MSG "srtcm_config"
  56         struct rte_meter_srtcm sm;
  57         struct  rte_meter_srtcm_params sparams1;
  58
  59         /* invalid parameter test */
  60         if(rte_meter_srtcm_config(NULL, NULL) == 0)
  61                 melog(SRTCM_CFG_MSG);
  62         if(rte_meter_srtcm_config(&sm, NULL) == 0)
  63                 melog(SRTCM_CFG_MSG);
  64         if(rte_meter_srtcm_config(NULL, &sparams) == 0)
  65                 melog(SRTCM_CFG_MSG);
  66
  67         /* cbs and ebs can't both be zero */
  68         sparams1 = sparams;
  69         sparams1.cbs = 0;
  70         sparams1.ebs = 0;
  71         if(rte_meter_srtcm_config(&sm, &sparams1) == 0)
  72                 melog(SRTCM_CFG_MSG);
  73
  74         /* cir should never be 0 */
  75         sparams1 = sparams;
  76         sparams1.cir = 0;
  77         if(rte_meter_srtcm_config(&sm, &sparams1) == 0)
  78                 melog(SRTCM_CFG_MSG);
  79
  80         /* one of ebs and cbs can be zero, should be successful */
  81         sparams1 = sparams;
  82         sparams1.ebs = 0;
  83         if(rte_meter_srtcm_config(&sm, &sparams1) != 0)
  84                 melog(SRTCM_CFG_MSG);
  85
  86         sparams1 = sparams;
  87         sparams1.cbs = 0;
  88         if(rte_meter_srtcm_config(&sm, &sparams1) != 0)
  89                 melog(SRTCM_CFG_MSG);
  90
  91         /* usual parameter, should be successful */
  92         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
  93                 melog(SRTCM_CFG_MSG);
  94
  95         return 0;
  96
  97 }
  98
  99 /**
 100  * functional test for rte_meter_trtcm_config
 101  */
 102 static inline int
 103 tm_test_trtcm_config(void)
 104 {
 105         struct rte_meter_trtcm tm;
 106         struct  rte_meter_trtcm_params tparams1;
 107 #define TRTCM_CFG_MSG "trtcm_config"
 108
 109         /* invalid parameter test */
 110         if(rte_meter_trtcm_config(NULL, NULL) == 0)
 111                 melog(TRTCM_CFG_MSG);
 112         if(rte_meter_trtcm_config(&tm, NULL) == 0)
 113                 melog(TRTCM_CFG_MSG);
 114         if(rte_meter_trtcm_config(NULL, &tparams) == 0)
 115                 melog(TRTCM_CFG_MSG);
 116
 117         /* cir, cbs, pir and pbs never be zero */
 118         tparams1 = tparams;
 119         tparams1.cir = 0;
 120         if(rte_meter_trtcm_config(&tm, &tparams1) == 0)
 121                 melog(TRTCM_CFG_MSG);
 122
 123         tparams1 = tparams;
 124         tparams1.cbs = 0;
 125         if(rte_meter_trtcm_config(&tm, &tparams1) == 0)
 126                 melog(TRTCM_CFG_MSG);
 127
 128         tparams1 = tparams;
 129         tparams1.pbs = 0;
 130         if(rte_meter_trtcm_config(&tm, &tparams1) == 0)
 131                 melog(TRTCM_CFG_MSG);
 132
 133         tparams1 = tparams;
 134         tparams1.pir = 0;
 135         if(rte_meter_trtcm_config(&tm, &tparams1) == 0)
 136                 melog(TRTCM_CFG_MSG);
 137
 138         /* pir should be greater or equal to cir */
 139         tparams1 = tparams;
 140         tparams1.pir = tparams1.cir - 1;
 141         if(rte_meter_trtcm_config(&tm, &tparams1) == 0)
 142                 melog(TRTCM_CFG_MSG" pir < cir test");
 143
 144         /* usual parameter, should be successful */
 145         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 146                 melog(TRTCM_CFG_MSG);
 147
 148         return 0;
 149 }
 150
 151 /**
 152  * functional test for rte_meter_srtcm_color_blind_check
 153  */
 154 static inline int
 155 tm_test_srtcm_color_blind_check(void)
 156 {
 157 #define SRTCM_BLIND_CHECK_MSG "srtcm_blind_check"
 158         struct rte_meter_srtcm sm;
 159         uint64_t time;
 160         uint64_t hz = rte_get_tsc_hz();
 161
 162         /* Test green */
 163         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 164                 melog(SRTCM_BLIND_CHECK_MSG);
 165         time = rte_get_tsc_cycles() + hz;
 166         if(rte_meter_srtcm_color_blind_check(
 167                 &sm, time, TM_TEST_SRTCM_CBS_DF - 1)
 168                 != e_RTE_METER_GREEN)
 169                 melog(SRTCM_BLIND_CHECK_MSG" GREEN");
 170
 171         /* Test yellow */
 172         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 173                 melog(SRTCM_BLIND_CHECK_MSG);
 174         time = rte_get_tsc_cycles() + hz;
 175         if(rte_meter_srtcm_color_blind_check(
 176                 &sm, time, TM_TEST_SRTCM_CBS_DF + 1)
 177                 != e_RTE_METER_YELLOW)
 178                 melog(SRTCM_BLIND_CHECK_MSG" YELLOW");
 179
 180         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 181                 melog(SRTCM_BLIND_CHECK_MSG);
 182         time = rte_get_tsc_cycles() + hz;
 183         if(rte_meter_srtcm_color_blind_check(
 184                 &sm, time, (uint32_t)sm.ebs - 1) != e_RTE_METER_YELLOW)
 185                 melog(SRTCM_BLIND_CHECK_MSG" YELLOW");
 186
 187         /* Test red */
 188         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 189                 melog(SRTCM_BLIND_CHECK_MSG);
 190         time = rte_get_tsc_cycles() + hz;
 191         if(rte_meter_srtcm_color_blind_check(
 192                 &sm, time, TM_TEST_SRTCM_EBS_DF + 1)
 193                 != e_RTE_METER_RED)
 194                 melog(SRTCM_BLIND_CHECK_MSG" RED");
 195
 196         return 0;
 197
 198 }
 199
 200 /**
 201  * functional test for rte_meter_trtcm_color_blind_check
 202  */
 203 static inline int
 204 tm_test_trtcm_color_blind_check(void)
 205 {
 206 #define TRTCM_BLIND_CHECK_MSG "trtcm_blind_check"
 207
 208         uint64_t time;
 209         struct rte_meter_trtcm tm;
 210         uint64_t hz = rte_get_tsc_hz();
 211
 212         /* Test green */
 213         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 214                 melog(TRTCM_BLIND_CHECK_MSG);
 215         time = rte_get_tsc_cycles() + hz;
 216         if(rte_meter_trtcm_color_blind_check(
 217                 &tm, time, TM_TEST_TRTCM_CBS_DF - 1)
 218                 != e_RTE_METER_GREEN)
 219                 melog(TRTCM_BLIND_CHECK_MSG" GREEN");
 220
 221         /* Test yellow */
 222         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 223                 melog(TRTCM_BLIND_CHECK_MSG);
 224         time = rte_get_tsc_cycles() + hz;
 225         if(rte_meter_trtcm_color_blind_check(
 226                 &tm, time, TM_TEST_TRTCM_CBS_DF + 1)
 227                 != e_RTE_METER_YELLOW)
 228                 melog(TRTCM_BLIND_CHECK_MSG" YELLOW");
 229
 230         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 231                 melog(TRTCM_BLIND_CHECK_MSG);
 232         time = rte_get_tsc_cycles() + hz;
 233         if(rte_meter_trtcm_color_blind_check(
 234                 &tm, time, TM_TEST_TRTCM_PBS_DF - 1)
 235                 != e_RTE_METER_YELLOW)
 236                 melog(TRTCM_BLIND_CHECK_MSG" YELLOW");
 237
 238         /* Test red */
 239         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 240                 melog(TRTCM_BLIND_CHECK_MSG);
 241         time = rte_get_tsc_cycles() + hz;
 242         if(rte_meter_trtcm_color_blind_check(
 243                 &tm, time, TM_TEST_TRTCM_PBS_DF + 1)
 244                 != e_RTE_METER_RED)
 245                 melog(TRTCM_BLIND_CHECK_MSG" RED");
 246
 247         return 0;
 248 }
 249
 250
 251 /**
 252  * @in[4] : the flags packets carries.
 253  * @in[4] : the flags function expect to return.
 254  * It will do blind check at the time of 1 second from beginning.
 255  * At the time, it will use packets length of cbs -1, cbs + 1,
 256  * ebs -1 and ebs +1 with flag in[0], in[1], in[2] and in[3] to do
 257  * aware check, expect flag out[0], out[1], out[2] and out[3]
 258  */
 259
 260 static inline int
 261 tm_test_srtcm_aware_check
 262 (enum rte_meter_color in[4], enum rte_meter_color out[4])
 263 {
 264 #define SRTCM_AWARE_CHECK_MSG "srtcm_aware_check"
 265         struct rte_meter_srtcm sm;
 266         uint64_t time;
 267         uint64_t hz = rte_get_tsc_hz();
 268
 269         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 270                 melog(SRTCM_AWARE_CHECK_MSG);
 271         time = rte_get_tsc_cycles() + hz;
 272         if(rte_meter_srtcm_color_aware_check(
 273                 &sm, time, TM_TEST_SRTCM_CBS_DF - 1, in[0]) != out[0])
 274                 melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[0], out[0]);
 275
 276         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 277                 melog(SRTCM_AWARE_CHECK_MSG);
 278         time = rte_get_tsc_cycles() + hz;
 279         if(rte_meter_srtcm_color_aware_check(
 280                 &sm, time, TM_TEST_SRTCM_CBS_DF + 1, in[1]) != out[1])
 281                 melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[1], out[1]);
 282
 283         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 284                 melog(SRTCM_AWARE_CHECK_MSG);
 285         time = rte_get_tsc_cycles() + hz;
 286         if(rte_meter_srtcm_color_aware_check(
 287                 &sm, time, TM_TEST_SRTCM_EBS_DF - 1, in[2]) != out[2])
 288                 melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[2], out[2]);
 289
 290         if(rte_meter_srtcm_config(&sm, &sparams) != 0)
 291                 melog(SRTCM_AWARE_CHECK_MSG);
 292         time = rte_get_tsc_cycles() + hz;
 293         if(rte_meter_srtcm_color_aware_check(
 294                 &sm, time, TM_TEST_SRTCM_EBS_DF + 1, in[3]) != out[3])
 295                 melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[3], out[3]);
 296
 297         return 0;
 298 }
 299
 300
 301 /**
 302  * functional test for rte_meter_srtcm_color_aware_check
 303  */
 304 static inline int
 305 tm_test_srtcm_color_aware_check(void)
 306 {
 307         enum rte_meter_color in[4], out[4];
 308
 309         /**
 310           * test 4 points that will produce green, yellow, yellow, red flag
 311           * if using blind check
 312           */
 313
 314         /* previouly have a green, test points should keep unchanged */
 315         in[0] = in[1] = in[2] = in[3] = e_RTE_METER_GREEN;
 316         out[0] = e_RTE_METER_GREEN;
 317         out[1] = e_RTE_METER_YELLOW;
 318         out[2] = e_RTE_METER_YELLOW;
 319         out[3] = e_RTE_METER_RED;
 320         if(tm_test_srtcm_aware_check(in, out) != 0)
 321                 return -1;
 322
 323         /**
 324           * previously have a yellow, green & yellow = yellow
 325           * yellow & red = red
 326           */
 327         in[0] = in[1] = in[2] = in[3] = e_RTE_METER_YELLOW;
 328         out[0] = e_RTE_METER_YELLOW;
 329         out[1] = e_RTE_METER_YELLOW;
 330         out[2] = e_RTE_METER_YELLOW;
 331         out[3] = e_RTE_METER_RED;
 332         if(tm_test_srtcm_aware_check(in, out) != 0)
 333                 return -1;
 334
 335         /**
 336           * previously have a red, red & green = red
 337           * red & yellow = red
 338           */
 339         in[0] = in[1] = in[2] = in[3] = e_RTE_METER_RED;
 340         out[0] = e_RTE_METER_RED;
 341         out[1] = e_RTE_METER_RED;
 342         out[2] = e_RTE_METER_RED;
 343         out[3] = e_RTE_METER_RED;
 344         if(tm_test_srtcm_aware_check(in, out) != 0)
 345                 return -1;
 346
 347         return 0;
 348 }
 349
 350 /**
 351  * @in[4] : the flags packets carries.
 352  * @in[4] : the flags function expect to return.
 353  * It will do blind check at the time of 1 second from beginning.
 354  * At the time, it will use packets length of cbs -1, cbs + 1,
 355  * ebs -1 and ebs +1 with flag in[0], in[1], in[2] and in[3] to do
 356  * aware check, expect flag out[0], out[1], out[2] and out[3]
 357  */
 358 static inline int
 359 tm_test_trtcm_aware_check
 360 (enum rte_meter_color in[4], enum rte_meter_color out[4])
 361 {
 362 #define TRTCM_AWARE_CHECK_MSG "trtcm_aware_check"
 363         struct rte_meter_trtcm tm;
 364         uint64_t time;
 365         uint64_t hz = rte_get_tsc_hz();
 366
 367         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 368                 melog(TRTCM_AWARE_CHECK_MSG);
 369         time = rte_get_tsc_cycles() + hz;
 370         if(rte_meter_trtcm_color_aware_check(
 371                 &tm, time, TM_TEST_TRTCM_CBS_DF - 1, in[0]) != out[0])
 372                 melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[0], out[0]);
 373
 374         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 375                 melog(TRTCM_AWARE_CHECK_MSG);
 376         time = rte_get_tsc_cycles() + hz;
 377         if(rte_meter_trtcm_color_aware_check(
 378                 &tm, time, TM_TEST_TRTCM_CBS_DF + 1, in[1]) != out[1])
 379                 melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[1], out[1]);
 380
 381         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 382                 melog(TRTCM_AWARE_CHECK_MSG);
 383         time = rte_get_tsc_cycles() + hz;
 384         if(rte_meter_trtcm_color_aware_check(
 385                 &tm, time, TM_TEST_TRTCM_PBS_DF - 1, in[2]) != out[2])
 386                 melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[2], out[2]);
 387
 388         if(rte_meter_trtcm_config(&tm, &tparams) != 0)
 389                 melog(TRTCM_AWARE_CHECK_MSG);
 390         time = rte_get_tsc_cycles() + hz;
 391         if(rte_meter_trtcm_color_aware_check(
 392                 &tm, time, TM_TEST_TRTCM_PBS_DF + 1, in[3]) != out[3])
 393                 melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[3], out[3]);
 394
 395         return 0;
 396 }
 397
 398
 399 /**
 400  * functional test for rte_meter_trtcm_color_aware_check
 401  */
 402
 403 static inline int
 404 tm_test_trtcm_color_aware_check(void)
 405 {
 406         enum rte_meter_color in[4], out[4];
 407         /**
 408           * test 4 points that will produce green, yellow, yellow, red flag
 409           * if using blind check
 410           */
 411
 412         /* previouly have a green, test points should keep unchanged */
 413         in[0] = in[1] = in[2] = in[3] = e_RTE_METER_GREEN;
 414         out[0] = e_RTE_METER_GREEN;
 415         out[1] = e_RTE_METER_YELLOW;
 416         out[2] = e_RTE_METER_YELLOW;
 417         out[3] = e_RTE_METER_RED;
 418         if(tm_test_trtcm_aware_check(in, out) != 0)
 419                 return -1;
 420
 421         in[0] = in[1] = in[2] = in[3] = e_RTE_METER_YELLOW;
 422         out[0] = e_RTE_METER_YELLOW;
 423         out[1] = e_RTE_METER_YELLOW;
 424         out[2] = e_RTE_METER_YELLOW;
 425         out[3] = e_RTE_METER_RED;
 426         if(tm_test_trtcm_aware_check(in, out) != 0)
 427                 return -1;
 428
 429         in[0] = in[1] = in[2] = in[3] = e_RTE_METER_RED;
 430         out[0] = e_RTE_METER_RED;
 431         out[1] = e_RTE_METER_RED;
 432         out[2] = e_RTE_METER_RED;
 433         out[3] = e_RTE_METER_RED;
 434         if(tm_test_trtcm_aware_check(in, out) != 0)
 435                 return -1;
 436
 437         return 0;
 438 }
 439
 440 /**
 441  * test main entrance for library meter
 442  */
 443 static int
 444 test_meter(void)
 445 {
 446         if(tm_test_srtcm_config() != 0 )
 447                 return -1;
 448
 449         if(tm_test_trtcm_config() != 0 )
 450                 return -1;
 451
 452         if(tm_test_srtcm_color_blind_check() != 0)
 453                 return -1;
 454
 455         if(tm_test_trtcm_color_blind_check()!= 0)
 456                 return -1;
 457
 458         if(tm_test_srtcm_color_aware_check()!= 0)
 459                 return -1;
 460
 461         if(tm_test_trtcm_color_aware_check()!= 0)
 462                 return -1;
 463
 464         return 0;
 465
 466 }
 467
 468 REGISTER_TEST_COMMAND(meter_autotest, test_meter);