app/test/test_red.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <stdint.h>
  38 #include <unistd.h>
  39 #include <inttypes.h>
  40 #include <sys/time.h>
  41 #include <time.h>
  42 #include <math.h>
  43
  44 #include "test.h"
  45
  46 #include <rte_red.h>
  47
  48 #ifdef __INTEL_COMPILER
  49 #pragma warning(disable:2259)       /* conversion may lose significant bits */
  50 #pragma warning(disable:181)        /* Arg incompatible with format string */
  51 #endif
  52
  53 #define TEST_HZ_PER_KHZ 1000
  54 #define TEST_NSEC_MARGIN 500        /**< nanosecond margin when calculating clk freq */
  55
  56 #define MAX_QEMPTY_TIME_MSEC   50000
  57 #define MSEC_PER_SEC           1000      /**< Milli-seconds per second */
  58 #define USEC_PER_MSEC          1000      /**< Micro-seconds per milli-second */
  59 #define USEC_PER_SEC           1000000   /**< Micro-seconds per second */
  60
  61 /**< structures for testing rte_red performance and function */
  62 struct test_rte_red_config {        /**< Test structure for RTE_RED config */
  63         struct rte_red_config *rconfig; /**< RTE_RED configuration parameters */
  64         uint8_t num_cfg;                /**< Number of RTE_RED configs to test */
  65         uint8_t *wq_log2;               /**< Test wq_log2 value to use */
  66         uint32_t min_th;                /**< Queue minimum threshold */
  67         uint32_t max_th;                /**< Queue maximum threshold */
  68         uint8_t *maxp_inv;              /**< Inverse mark probability */
  69 };
  70
  71 struct test_queue {                 /**< Test structure for RTE_RED Queues */
  72         struct rte_red *rdata;          /**< RTE_RED runtime data */
  73         uint32_t num_queues;            /**< Number of RTE_RED queues to test */
  74         uint32_t *qconfig;              /**< Configuration of RTE_RED queues for test */
  75         uint32_t *q;                    /**< Queue size */
  76         uint32_t q_ramp_up;             /**< Num of enqueues to ramp up the queue */
  77         uint32_t avg_ramp_up;           /**< Average num of enqueues to ramp up the queue */
  78         uint32_t avg_tolerance;         /**< Tolerance in queue average */
  79         double drop_tolerance;          /**< Drop tolerance of packets not enqueued */
  80 };
  81
  82 struct test_var {                   /**< Test variables used for testing RTE_RED */
  83         uint32_t wait_usec;             /**< Micro second wait interval */
  84         uint32_t num_iterations;        /**< Number of test iterations */
  85         uint32_t num_ops;               /**< Number of test operations */
  86         uint64_t clk_freq;              /**< CPU clock frequency */
  87         uint32_t sleep_sec;             /**< Seconds to sleep */
  88         uint32_t *dropped;              /**< Test operations dropped */
  89         uint32_t *enqueued;             /**< Test operations enqueued */
  90 };
  91
  92 struct test_config {                /**< Master test structure for RTE_RED */
  93         const char *ifname;             /**< Interface name */
  94         const char *msg;                /**< Test message for display */
  95         const char *htxt;               /**< Header txt display for result output */
  96         struct test_rte_red_config *tconfig; /**< Test structure for RTE_RED config */
  97         struct test_queue *tqueue;      /**< Test structure for RTE_RED Queues */
  98         struct test_var *tvar;          /**< Test variables used for testing RTE_RED */
  99         uint32_t *tlevel;               /**< Queue levels */
 100 };
 101
 102 enum test_result {
 103         FAIL = 0,
 104         PASS
 105 };
 106
 107 /**< Test structure to define tests to run */
 108 struct tests {
 109         struct test_config *testcfg;
 110         enum test_result (*testfn)(struct test_config *);
 111 };
 112
 113 struct rdtsc_prof {
 114         uint64_t clk_start;
 115         uint64_t clk_min;               /**< min clocks */
 116         uint64_t clk_max;               /**< max clocks */
 117         uint64_t clk_avgc;              /**< count to calc average */
 118         double clk_avg;                 /**< cumulative sum to calc average */
 119         const char *name;
 120 };
 121
 122 static const uint64_t port_speed_bytes = (10ULL*1000ULL*1000ULL*1000ULL)/8ULL;
 123 static double inv_cycles_per_byte = 0;
 124 static double pkt_time_usec = 0;
 125
 126 static void init_port_ts(uint64_t cpu_clock)
 127 {
 128         double cycles_per_byte = (double)(cpu_clock) / (double)(port_speed_bytes);
 129         inv_cycles_per_byte = 1.0 / cycles_per_byte;
 130         pkt_time_usec = 1000000.0 / ((double)port_speed_bytes / (double)RTE_RED_S);
 131 }
 132
 133 static uint64_t get_port_ts(void)
 134 {
 135         return (uint64_t)((double)rte_rdtsc() * inv_cycles_per_byte);
 136 }
 137
 138 static void rdtsc_prof_init(struct rdtsc_prof *p, const char *name)
 139 {
 140         p->clk_min = (uint64_t)(-1LL);
 141         p->clk_max = 0;
 142         p->clk_avg = 0;
 143         p->clk_avgc = 0;
 144         p->name = name;
 145 }
 146
 147 static inline void rdtsc_prof_start(struct rdtsc_prof *p)
 148 {
 149         p->clk_start = rte_rdtsc_precise();
 150 }
 151
 152 static inline void rdtsc_prof_end(struct rdtsc_prof *p)
 153 {
 154         uint64_t clk_start = rte_rdtsc() - p->clk_start;
 155
 156         p->clk_avgc++;
 157         p->clk_avg += (double) clk_start;
 158
 159         if (clk_start > p->clk_max)
 160                 p->clk_max = clk_start;
 161         if (clk_start < p->clk_min)
 162                 p->clk_min = clk_start;
 163 }
 164
 165 static void rdtsc_prof_print(struct rdtsc_prof *p)
 166 {
 167         if (p->clk_avgc>0) {
 168                 printf("RDTSC stats for %s: n=%" PRIu64 ", min=%" PRIu64 ", max=%" PRIu64 ", avg=%.1f\n",
 169                         p->name,
 170                         p->clk_avgc,
 171                         p->clk_min,
 172                         p->clk_max,
 173                         (p->clk_avg / ((double) p->clk_avgc)));
 174         }
 175 }
 176
 177 static uint32_t rte_red_get_avg_int(const struct rte_red_config *red_cfg,
 178                                     struct rte_red *red)
 179 {
 180         /**
 181          * scale by 1/n and convert from fixed-point to integer
 182          */
 183         return red->avg >> (RTE_RED_SCALING + red_cfg->wq_log2);
 184 }
 185
 186 static double rte_red_get_avg_float(const struct rte_red_config *red_cfg,
 187                                     struct rte_red *red)
 188 {
 189         /**
 190          * scale by 1/n and convert from fixed-point to floating-point
 191          */
 192         return ldexp((double)red->avg,  -(RTE_RED_SCALING + red_cfg->wq_log2));
 193 }
 194
 195 static void rte_red_set_avg_int(const struct rte_red_config *red_cfg,
 196                                 struct rte_red *red,
 197                                 uint32_t avg)
 198 {
 199         /**
 200          * scale by n and convert from integer to fixed-point
 201          */
 202         red->avg = avg << (RTE_RED_SCALING + red_cfg->wq_log2);
 203 }
 204
 205 static double calc_exp_avg_on_empty(double avg, uint32_t n, uint32_t time_diff)
 206 {
 207         return avg * pow((1.0 - 1.0 / (double)n), (double)time_diff / pkt_time_usec);
 208 }
 209
 210 static double calc_drop_rate(uint32_t enqueued, uint32_t dropped)
 211 {
 212         return (double)dropped / ((double)enqueued + (double)dropped);
 213 }
 214
 215 /**
 216  * calculate the drop probability
 217  */
 218 static double calc_drop_prob(uint32_t min_th, uint32_t max_th,
 219                              uint32_t maxp_inv, uint32_t avg)
 220 {
 221         double drop_prob = 0.0;
 222
 223         if (avg < min_th) {
 224                 drop_prob = 0.0;
 225         } else if (avg < max_th) {
 226                 drop_prob = (1.0 / (double)maxp_inv)
 227                         * ((double)(avg - min_th)
 228                            / (double)(max_th - min_th));
 229         } else {
 230                 drop_prob = 1.0;
 231         }
 232         return drop_prob;
 233 }
 234
 235 /**
 236  *  check if drop rate matches drop probability within tolerance
 237  */
 238 static int check_drop_rate(double *diff, double drop_rate, double drop_prob, double tolerance)
 239 {
 240         double abs_diff = 0.0;
 241         int ret = 1;
 242
 243         abs_diff = fabs(drop_rate - drop_prob);
 244         if ((int)abs_diff == 0) {
 245                 *diff = 0.0;
 246         } else {
 247                 *diff = (abs_diff / drop_prob) * 100.0;
 248                 if (*diff > tolerance) {
 249                         ret = 0;
 250                 }
 251         }
 252         return ret;
 253 }
 254
 255 /**
 256  *  check if average queue size is within tolerance
 257  */
 258 static int check_avg(double *diff, double avg, double exp_avg, double tolerance)
 259 {
 260         double abs_diff = 0.0;
 261         int ret = 1;
 262
 263         abs_diff = fabs(avg - exp_avg);
 264         if ((int)abs_diff == 0) {
 265                 *diff = 0.0;
 266         } else {
 267                 *diff = (abs_diff / exp_avg) * 100.0;
 268                 if (*diff > tolerance) {
 269                         ret = 0;
 270                 }
 271         }
 272         return ret;
 273 }
 274
 275 /**
 276  * get the clk frequency in Hz
 277  */
 278 static uint64_t get_machclk_freq(void)
 279 {
 280         uint64_t start = 0;
 281         uint64_t end = 0;
 282         uint64_t diff = 0;
 283         uint64_t clk_freq_hz = 0;
 284         struct timespec tv_start = {0, 0}, tv_end = {0, 0};
 285         struct timespec req = {0, 0};
 286
 287         req.tv_sec = 1;
 288         req.tv_nsec = 0;
 289
 290         clock_gettime(CLOCK_REALTIME, &tv_start);
 291         start = rte_rdtsc();
 292
 293         if (nanosleep(&req, NULL) != 0) {
 294                 perror("get_machclk_freq()");
 295                 exit(EXIT_FAILURE);
 296         }
 297
 298         clock_gettime(CLOCK_REALTIME, &tv_end);
 299         end = rte_rdtsc();
 300
 301         diff = (uint64_t)(tv_end.tv_sec - tv_start.tv_sec) * USEC_PER_SEC
 302                 + ((tv_end.tv_nsec - tv_start.tv_nsec + TEST_NSEC_MARGIN) /
 303                    USEC_PER_MSEC); /**< diff is in micro secs */
 304
 305         if (diff == 0)
 306                 return 0;
 307
 308         clk_freq_hz = ((end - start) * USEC_PER_SEC / diff);
 309         return clk_freq_hz;
 310 }
 311
 312 /**
 313  * initialize the test rte_red config
 314  */
 315 static enum test_result
 316 test_rte_red_init(struct test_config *tcfg)
 317 {
 318         unsigned i = 0;
 319
 320         tcfg->tvar->clk_freq = get_machclk_freq();
 321         init_port_ts( tcfg->tvar->clk_freq );
 322
 323         for (i = 0; i < tcfg->tconfig->num_cfg; i++) {
 324                 if (rte_red_config_init(&tcfg->tconfig->rconfig[i],
 325                                         (uint16_t)tcfg->tconfig->wq_log2[i],
 326                                         (uint16_t)tcfg->tconfig->min_th,
 327                                         (uint16_t)tcfg->tconfig->max_th,
 328                                         (uint16_t)tcfg->tconfig->maxp_inv[i]) != 0) {
 329                         return FAIL;
 330                 }
 331         }
 332
 333         *tcfg->tqueue->q = 0;
 334         *tcfg->tvar->dropped = 0;
 335         *tcfg->tvar->enqueued = 0;
 336         return PASS;
 337 }
 338
 339 /**
 340  * enqueue until actual queue size reaches target level
 341  */
 342 static int
 343 increase_actual_qsize(struct rte_red_config *red_cfg,
 344                       struct rte_red *red,
 345                       uint32_t *q,
 346                       uint32_t level,
 347                       uint32_t attempts)
 348 {
 349         uint32_t i = 0;
 350
 351         for (i = 0; i < attempts; i++) {
 352                 int ret = 0;
 353
 354                 /**
 355                  * enqueue
 356                  */
 357                 ret = rte_red_enqueue(red_cfg, red, *q, get_port_ts() );
 358                 if (ret == 0) {
 359                         if (++(*q) >= level)
 360                                 break;
 361                 }
 362         }
 363         /**
 364         * check if target actual queue size has been reached
 365         */
 366         if (*q != level)
 367                 return -1;
 368         /**
 369          * success
 370          */
 371         return 0;
 372 }
 373
 374 /**
 375  * enqueue until average queue size reaches target level
 376  */
 377 static int
 378 increase_average_qsize(struct rte_red_config *red_cfg,
 379                        struct rte_red *red,
 380                        uint32_t *q,
 381                        uint32_t level,
 382                        uint32_t num_ops)
 383 {
 384         uint32_t avg = 0;
 385         uint32_t i = 0;
 386
 387         for (i = 0; i < num_ops; i++) {
 388                 /**
 389                  * enqueue
 390                  */
 391                 rte_red_enqueue(red_cfg, red, *q, get_port_ts());
 392         }
 393         /**
 394          * check if target average queue size has been reached
 395          */
 396         avg = rte_red_get_avg_int(red_cfg, red);
 397         if (avg != level)
 398                 return -1;
 399         /**
 400          * success
 401          */
 402         return 0;
 403 }
 404
 405 /**
 406  * setup default values for the functional test structures
 407  */
 408 static struct rte_red_config ft_wrconfig[1];
 409 static struct rte_red ft_rtdata[1];
 410 static uint8_t ft_wq_log2[] = {9};
 411 static uint8_t ft_maxp_inv[] = {10};
 412 static uint32_t  ft_qconfig[] = {0, 0, 1, 1};
 413 static uint32_t  ft_q[] ={0};
 414 static uint32_t  ft_dropped[] ={0};
 415 static uint32_t  ft_enqueued[] ={0};
 416
 417 static struct test_rte_red_config ft_tconfig =  {
 418         .rconfig = ft_wrconfig,
 419         .num_cfg = RTE_DIM(ft_wrconfig),
 420         .wq_log2 = ft_wq_log2,
 421         .min_th = 32,
 422         .max_th = 128,
 423         .maxp_inv = ft_maxp_inv,
 424 };
 425
 426 static struct test_queue ft_tqueue = {
 427         .rdata = ft_rtdata,
 428         .num_queues = RTE_DIM(ft_rtdata),
 429         .qconfig = ft_qconfig,
 430         .q = ft_q,
 431         .q_ramp_up = 1000000,
 432         .avg_ramp_up = 1000000,
 433         .avg_tolerance = 5,  /* 5 percent */
 434         .drop_tolerance = 50,  /* 50 percent */
 435 };
 436
 437 static struct test_var ft_tvar = {
 438         .wait_usec = 250000,
 439         .num_iterations = 20,
 440         .num_ops = 10000,
 441         .clk_freq = 0,
 442         .dropped = ft_dropped,
 443         .enqueued = ft_enqueued,
 444         .sleep_sec = (MAX_QEMPTY_TIME_MSEC / MSEC_PER_SEC) + 2,
 445 };
 446
 447 /**
 448  * functional test enqueue/dequeue packets
 449  */
 450 static void enqueue_dequeue_func(struct rte_red_config *red_cfg,
 451                                  struct rte_red *red,
 452                                  uint32_t *q,
 453                                  uint32_t num_ops,
 454                                  uint32_t *enqueued,
 455                                  uint32_t *dropped)
 456 {
 457         uint32_t i = 0;
 458
 459         for (i = 0; i < num_ops; i++) {
 460                 int ret = 0;
 461
 462                 /**
 463                  * enqueue
 464                  */
 465                 ret = rte_red_enqueue(red_cfg, red, *q, get_port_ts());
 466                 if (ret == 0)
 467                         (*enqueued)++;
 468                 else
 469                         (*dropped)++;
 470         }
 471 }
 472
 473 /**
 474  * Test F1: functional test 1
 475  */
 476 static uint32_t ft1_tlevels[] =  {6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102, 108, 114, 120, 126, 132, 138, 144};
 477
 478 static struct test_config func_test1_config = {
 479         .ifname = "functional test 1 interface",
 480         .msg = "functional test 1 : use one rte_red configuration,\n"
 481         "                   increase average queue size to various levels,\n"
 482         "                   compare drop rate to drop probability\n\n",
 483         .htxt = "                "
 484         "avg queue size "
 485         "enqueued       "
 486         "dropped        "
 487         "drop prob %    "
 488         "drop rate %    "
 489         "diff %         "
 490         "tolerance %    "
 491         "\n",
 492         .tconfig = &ft_tconfig,
 493         .tqueue = &ft_tqueue,
 494         .tvar = &ft_tvar,
 495         .tlevel = ft1_tlevels,
 496 };
 497
 498 static enum test_result func_test1(struct test_config *tcfg)
 499 {
 500         enum test_result result = PASS;
 501         uint32_t i = 0;
 502
 503         printf("%s", tcfg->msg);
 504
 505         if (test_rte_red_init(tcfg) != PASS) {
 506                 result = FAIL;
 507                 goto out;
 508         }
 509
 510         printf("%s", tcfg->htxt);
 511
 512         for (i = 0; i < RTE_DIM(ft1_tlevels); i++) {
 513                 const char *label = NULL;
 514                 uint32_t avg = 0;
 515                 double drop_rate = 0.0;
 516                 double drop_prob = 0.0;
 517                 double diff = 0.0;
 518
 519                 /**
 520                  * reset rte_red run-time data
 521                  */
 522                 rte_red_rt_data_init(tcfg->tqueue->rdata);
 523                 *tcfg->tvar->enqueued = 0;
 524                 *tcfg->tvar->dropped = 0;
 525
 526                 if (increase_actual_qsize(tcfg->tconfig->rconfig,
 527                                           tcfg->tqueue->rdata,
 528                                           tcfg->tqueue->q,
 529                                           tcfg->tlevel[i],
 530                                           tcfg->tqueue->q_ramp_up) != 0) {
 531                         result = FAIL;
 532                         goto out;
 533                 }
 534
 535                 if (increase_average_qsize(tcfg->tconfig->rconfig,
 536                                            tcfg->tqueue->rdata,
 537                                            tcfg->tqueue->q,
 538                                            tcfg->tlevel[i],
 539                                            tcfg->tqueue->avg_ramp_up) != 0)  {
 540                         result = FAIL;
 541                         goto out;
 542                 }
 543
 544                 enqueue_dequeue_func(tcfg->tconfig->rconfig,
 545                                      tcfg->tqueue->rdata,
 546                                      tcfg->tqueue->q,
 547                                      tcfg->tvar->num_ops,
 548                                      tcfg->tvar->enqueued,
 549                                      tcfg->tvar->dropped);
 550
 551                 avg = rte_red_get_avg_int(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
 552                 if (avg != tcfg->tlevel[i]) {
 553                         fprintf(stderr, "Fail: avg != level\n");
 554                         result = FAIL;
 555                 }
 556
 557                 drop_rate = calc_drop_rate(*tcfg->tvar->enqueued, *tcfg->tvar->dropped);
 558                 drop_prob = calc_drop_prob(tcfg->tconfig->min_th, tcfg->tconfig->max_th,
 559                                            *tcfg->tconfig->maxp_inv, tcfg->tlevel[i]);
 560                 if (!check_drop_rate(&diff, drop_rate, drop_prob, (double)tcfg->tqueue->drop_tolerance))
 561                         result = FAIL;
 562
 563                 if (tcfg->tlevel[i] == tcfg->tconfig->min_th)
 564                         label = "min thresh:     ";
 565                 else if (tcfg->tlevel[i] == tcfg->tconfig->max_th)
 566                         label = "max thresh:     ";
 567                 else
 568                         label = "                ";
 569                 printf("%s%-15u%-15u%-15u%-15.4lf%-15.4lf%-15.4lf%-15.4lf\n",
 570                        label, avg, *tcfg->tvar->enqueued, *tcfg->tvar->dropped,
 571                        drop_prob * 100.0, drop_rate * 100.0, diff,
 572                        (double)tcfg->tqueue->drop_tolerance);
 573         }
 574 out:
 575         return result;
 576 }
 577
 578 /**
 579  * Test F2: functional test 2
 580  */
 581 static uint32_t ft2_tlevel[] = {127};
 582 static uint8_t ft2_wq_log2[] = {9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
 583 static uint8_t ft2_maxp_inv[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
 584 static struct rte_red_config ft2_rconfig[10];
 585
 586 static struct test_rte_red_config ft2_tconfig =  {
 587         .rconfig = ft2_rconfig,
 588         .num_cfg = RTE_DIM(ft2_rconfig),
 589         .wq_log2 = ft2_wq_log2,
 590         .min_th = 32,
 591         .max_th = 128,
 592         .maxp_inv = ft2_maxp_inv,
 593 };
 594
 595 static struct test_config func_test2_config = {
 596         .ifname = "functional test 2 interface",
 597         .msg = "functional test 2 : use several RED configurations,\n"
 598         "                   increase average queue size to just below maximum threshold,\n"
 599         "                   compare drop rate to drop probability\n\n",
 600         .htxt = "RED config     "
 601         "avg queue size "
 602         "min threshold  "
 603         "max threshold  "
 604         "drop prob %    "
 605         "drop rate %    "
 606         "diff %         "
 607         "tolerance %    "
 608         "\n",
 609         .tconfig = &ft2_tconfig,
 610         .tqueue = &ft_tqueue,
 611         .tvar = &ft_tvar,
 612         .tlevel = ft2_tlevel,
 613 };
 614
 615 static enum test_result func_test2(struct test_config *tcfg)
 616 {
 617         enum test_result result = PASS;
 618         double prev_drop_rate = 1.0;
 619         uint32_t i = 0;
 620
 621         printf("%s", tcfg->msg);
 622
 623         if (test_rte_red_init(tcfg) != PASS) {
 624                 result = FAIL;
 625                 goto out;
 626         }
 627         rte_red_rt_data_init(tcfg->tqueue->rdata);
 628
 629         if (increase_actual_qsize(tcfg->tconfig->rconfig,
 630                                   tcfg->tqueue->rdata,
 631                                   tcfg->tqueue->q,
 632                                   *tcfg->tlevel,
 633                                   tcfg->tqueue->q_ramp_up) != 0) {
 634                 result = FAIL;
 635                 goto out;
 636         }
 637
 638         if (increase_average_qsize(tcfg->tconfig->rconfig,
 639                                    tcfg->tqueue->rdata,
 640                                    tcfg->tqueue->q,
 641                                    *tcfg->tlevel,
 642                                    tcfg->tqueue->avg_ramp_up) != 0) {
 643                 result = FAIL;
 644                 goto out;
 645         }
 646         printf("%s", tcfg->htxt);
 647
 648         for (i = 0; i < tcfg->tconfig->num_cfg; i++) {
 649                 uint32_t avg = 0;
 650                 double drop_rate = 0.0;
 651                 double drop_prob = 0.0;
 652                 double diff = 0.0;
 653
 654                 *tcfg->tvar->dropped = 0;
 655                 *tcfg->tvar->enqueued = 0;
 656
 657                 enqueue_dequeue_func(&tcfg->tconfig->rconfig[i],
 658                                      tcfg->tqueue->rdata,
 659                                      tcfg->tqueue->q,
 660                                      tcfg->tvar->num_ops,
 661                                      tcfg->tvar->enqueued,
 662                                      tcfg->tvar->dropped);
 663
 664                 avg = rte_red_get_avg_int(&tcfg->tconfig->rconfig[i], tcfg->tqueue->rdata);
 665                 if (avg != *tcfg->tlevel)
 666                         result = FAIL;
 667
 668                 drop_rate = calc_drop_rate(*tcfg->tvar->enqueued, *tcfg->tvar->dropped);
 669                 drop_prob = calc_drop_prob(tcfg->tconfig->min_th, tcfg->tconfig->max_th,
 670                                            tcfg->tconfig->maxp_inv[i], *tcfg->tlevel);
 671                 if (!check_drop_rate(&diff, drop_rate, drop_prob, (double)tcfg->tqueue->drop_tolerance))
 672                         result = FAIL;
 673                 /**
 674                  * drop rate should decrease as maxp_inv increases
 675                  */
 676                 if (drop_rate > prev_drop_rate)
 677                         result = FAIL;
 678                 prev_drop_rate = drop_rate;
 679
 680                 printf("%-15u%-15u%-15u%-15u%-15.4lf%-15.4lf%-15.4lf%-15.4lf\n",
 681                        i, avg, tcfg->tconfig->min_th, tcfg->tconfig->max_th,
 682                        drop_prob * 100.0, drop_rate * 100.0, diff,
 683                        (double)tcfg->tqueue->drop_tolerance);
 684         }
 685 out:
 686         return result;
 687 }
 688
 689 /**
 690  * Test F3: functional test 3
 691  */
 692 static uint32_t ft3_tlevel[] = {1022};
 693
 694 static struct test_rte_red_config ft3_tconfig =  {
 695         .rconfig = ft_wrconfig,
 696         .num_cfg = RTE_DIM(ft_wrconfig),
 697         .wq_log2 = ft_wq_log2,
 698         .min_th = 32,
 699         .max_th = 1023,
 700         .maxp_inv = ft_maxp_inv,
 701 };
 702
 703 static struct test_config func_test3_config = {
 704         .ifname = "functional test 3 interface",
 705         .msg = "functional test 3 : use one RED configuration,\n"
 706         "                   increase average queue size to target level,\n"
 707         "                   dequeue all packets until queue is empty,\n"
 708         "                   confirm that average queue size is computed correctly while queue is empty\n\n",
 709         .htxt = "q avg before   "
 710         "q avg after    "
 711         "expected       "
 712         "difference %   "
 713         "tolerance %    "
 714         "result  "
 715         "\n",
 716         .tconfig = &ft3_tconfig,
 717         .tqueue = &ft_tqueue,
 718         .tvar = &ft_tvar,
 719         .tlevel = ft3_tlevel,
 720 };
 721
 722 static enum test_result func_test3(struct test_config *tcfg)
 723 {
 724         enum test_result result = PASS;
 725         uint32_t i = 0;
 726
 727         printf("%s", tcfg->msg);
 728
 729         if (test_rte_red_init(tcfg) != PASS) {
 730                 result = FAIL;
 731                 goto out;
 732         }
 733
 734         rte_red_rt_data_init(tcfg->tqueue->rdata);
 735
 736         if (increase_actual_qsize(tcfg->tconfig->rconfig,
 737                                   tcfg->tqueue->rdata,
 738                                   tcfg->tqueue->q,
 739                                   *tcfg->tlevel,
 740                                   tcfg->tqueue->q_ramp_up) != 0) {
 741                 result = FAIL;
 742                 goto out;
 743         }
 744
 745         if (increase_average_qsize(tcfg->tconfig->rconfig,
 746                                    tcfg->tqueue->rdata,
 747                                    tcfg->tqueue->q,
 748                                    *tcfg->tlevel,
 749                                    tcfg->tqueue->avg_ramp_up) != 0) {
 750                 result = FAIL;
 751                 goto out;
 752         }
 753
 754         printf("%s", tcfg->htxt);
 755
 756         for (i = 0; i < tcfg->tvar->num_iterations; i++) {
 757                 double avg_before = 0;
 758                 double avg_after = 0;
 759                 double exp_avg = 0;
 760                 double diff = 0.0;
 761
 762                 avg_before = rte_red_get_avg_float(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
 763
 764                 /**
 765                 * empty the queue
 766                 */
 767                 *tcfg->tqueue->q = 0;
 768                 rte_red_mark_queue_empty(tcfg->tqueue->rdata, get_port_ts());
 769
 770                 rte_delay_us(tcfg->tvar->wait_usec);
 771
 772                 /**
 773                  * enqueue one packet to recalculate average queue size
 774                  */
 775                 if (rte_red_enqueue(tcfg->tconfig->rconfig,
 776                                     tcfg->tqueue->rdata,
 777                                     *tcfg->tqueue->q,
 778                                     get_port_ts()) == 0) {
 779                         (*tcfg->tqueue->q)++;
 780                 } else {
 781                         printf("%s:%d: packet enqueued on empty queue was dropped\n", __func__, __LINE__);
 782                         result = FAIL;
 783                 }
 784
 785                 exp_avg = calc_exp_avg_on_empty(avg_before,
 786                                               (1 << *tcfg->tconfig->wq_log2),
 787                                               tcfg->tvar->wait_usec);
 788                 avg_after = rte_red_get_avg_float(tcfg->tconfig->rconfig,
 789                                                   tcfg->tqueue->rdata);
 790                 if (!check_avg(&diff, avg_after, exp_avg, (double)tcfg->tqueue->avg_tolerance))
 791                         result = FAIL;
 792
 793                 printf("%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15s\n",
 794                        avg_before, avg_after, exp_avg, diff,
 795                        (double)tcfg->tqueue->avg_tolerance,
 796                        diff <= (double)tcfg->tqueue->avg_tolerance ? "pass" : "fail");
 797         }
 798 out:
 799         return result;
 800 }
 801
 802 /**
 803  * Test F4: functional test 4
 804  */
 805 static uint32_t ft4_tlevel[] = {1022};
 806 static uint8_t ft4_wq_log2[] = {11};
 807
 808 static struct test_rte_red_config ft4_tconfig =  {
 809         .rconfig = ft_wrconfig,
 810         .num_cfg = RTE_DIM(ft_wrconfig),
 811         .min_th = 32,
 812         .max_th = 1023,
 813         .wq_log2 = ft4_wq_log2,
 814         .maxp_inv = ft_maxp_inv,
 815 };
 816
 817 static struct test_queue ft4_tqueue = {
 818         .rdata = ft_rtdata,
 819         .num_queues = RTE_DIM(ft_rtdata),
 820         .qconfig = ft_qconfig,
 821         .q = ft_q,
 822         .q_ramp_up = 1000000,
 823         .avg_ramp_up = 1000000,
 824         .avg_tolerance = 0,  /* 0 percent */
 825         .drop_tolerance = 50,  /* 50 percent */
 826 };
 827
 828 static struct test_config func_test4_config = {
 829         .ifname = "functional test 4 interface",
 830         .msg = "functional test 4 : use one RED configuration,\n"
 831         "                   increase average queue size to target level,\n"
 832         "                   dequeue all packets until queue is empty,\n"
 833         "                   confirm that average queue size is computed correctly while\n"
 834         "                   queue is empty for more than 50 sec,\n"
 835         "                   (this test takes 52 sec to run)\n\n",
 836         .htxt = "q avg before   "
 837         "q avg after    "
 838         "expected       "
 839         "difference %   "
 840         "tolerance %    "
 841         "result  "
 842         "\n",
 843         .tconfig = &ft4_tconfig,
 844         .tqueue = &ft4_tqueue,
 845         .tvar = &ft_tvar,
 846         .tlevel = ft4_tlevel,
 847 };
 848
 849 static enum test_result func_test4(struct test_config *tcfg)
 850 {
 851         enum test_result result = PASS;
 852         uint64_t time_diff = 0;
 853         uint64_t start = 0;
 854         double avg_before = 0.0;
 855         double avg_after = 0.0;
 856         double exp_avg = 0.0;
 857         double diff = 0.0;
 858
 859         printf("%s", tcfg->msg);
 860
 861         if (test_rte_red_init(tcfg) != PASS) {
 862                 result = FAIL;
 863                 goto out;
 864         }
 865
 866         rte_red_rt_data_init(tcfg->tqueue->rdata);
 867
 868         if (increase_actual_qsize(tcfg->tconfig->rconfig,
 869                                   tcfg->tqueue->rdata,
 870                                   tcfg->tqueue->q,
 871                                   *tcfg->tlevel,
 872                                   tcfg->tqueue->q_ramp_up) != 0) {
 873                 result = FAIL;
 874                 goto out;
 875         }
 876
 877         if (increase_average_qsize(tcfg->tconfig->rconfig,
 878                                    tcfg->tqueue->rdata,
 879                                    tcfg->tqueue->q,
 880                                    *tcfg->tlevel,
 881                                    tcfg->tqueue->avg_ramp_up) != 0) {
 882                 result = FAIL;
 883                 goto out;
 884         }
 885
 886         printf("%s", tcfg->htxt);
 887
 888         avg_before = rte_red_get_avg_float(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
 889
 890         /**
 891          * empty the queue
 892          */
 893         *tcfg->tqueue->q = 0;
 894         rte_red_mark_queue_empty(tcfg->tqueue->rdata, get_port_ts());
 895
 896         /**
 897          * record empty time locally
 898          */
 899         start = rte_rdtsc();
 900
 901         sleep(tcfg->tvar->sleep_sec);
 902
 903         /**
 904          * enqueue one packet to recalculate average queue size
 905          */
 906         if (rte_red_enqueue(tcfg->tconfig->rconfig,
 907                             tcfg->tqueue->rdata,
 908                             *tcfg->tqueue->q,
 909                             get_port_ts()) != 0) {
 910                 result = FAIL;
 911                 goto out;
 912         }
 913         (*tcfg->tqueue->q)++;
 914
 915         /**
 916          * calculate how long queue has been empty
 917          */
 918         time_diff = ((rte_rdtsc() - start) / tcfg->tvar->clk_freq)
 919                   * MSEC_PER_SEC;
 920         if (time_diff < MAX_QEMPTY_TIME_MSEC) {
 921                 /**
 922                  * this could happen if sleep was interrupted for some reason
 923                  */
 924                 result = FAIL;
 925                 goto out;
 926         }
 927
 928         /**
 929          * confirm that average queue size is now at expected level
 930          */
 931         exp_avg = 0.0;
 932         avg_after = rte_red_get_avg_float(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
 933         if (!check_avg(&diff, avg_after, exp_avg, (double)tcfg->tqueue->avg_tolerance))
 934                 result = FAIL;
 935
 936         printf("%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15s\n",
 937                avg_before, avg_after, exp_avg,
 938                diff, (double)tcfg->tqueue->avg_tolerance,
 939                diff <= (double)tcfg->tqueue->avg_tolerance ? "pass" : "fail");
 940 out:
 941         return result;
 942 }
 943
 944 /**
 945  * Test F5: functional test 5
 946  */
 947 static uint32_t ft5_tlevel[] = {127};
 948 static uint8_t ft5_wq_log2[] = {9, 8};
 949 static uint8_t ft5_maxp_inv[] = {10, 20};
 950 static struct rte_red_config ft5_config[2];
 951 static struct rte_red ft5_data[4];
 952 static uint32_t ft5_q[4];
 953 static uint32_t ft5_dropped[] = {0, 0, 0, 0};
 954 static uint32_t ft5_enqueued[] = {0, 0, 0, 0};
 955
 956 static struct test_rte_red_config ft5_tconfig =  {
 957         .rconfig = ft5_config,
 958         .num_cfg = RTE_DIM(ft5_config),
 959         .min_th = 32,
 960         .max_th = 128,
 961         .wq_log2 = ft5_wq_log2,
 962         .maxp_inv = ft5_maxp_inv,
 963 };
 964
 965 static struct test_queue ft5_tqueue = {
 966         .rdata = ft5_data,
 967         .num_queues = RTE_DIM(ft5_data),
 968         .qconfig = ft_qconfig,
 969         .q = ft5_q,
 970         .q_ramp_up = 1000000,
 971         .avg_ramp_up = 1000000,
 972         .avg_tolerance = 5,  /* 10 percent */
 973         .drop_tolerance = 50,  /* 50 percent */
 974 };
 975
 976 struct test_var ft5_tvar = {
 977         .wait_usec = 0,
 978         .num_iterations = 15,
 979         .num_ops = 10000,
 980         .clk_freq = 0,
 981         .dropped = ft5_dropped,
 982         .enqueued = ft5_enqueued,
 983         .sleep_sec = 0,
 984 };
 985
 986 static struct test_config func_test5_config = {
 987         .ifname = "functional test 5 interface",
 988         .msg = "functional test 5 : use several queues (each with its own run-time data),\n"
 989         "                   use several RED configurations (such that each configuration is shared by multiple queues),\n"
 990         "                   increase average queue size to just below maximum threshold,\n"
 991         "                   compare drop rate to drop probability,\n"
 992         "                   (this is a larger scale version of functional test 2)\n\n",
 993         .htxt = "queue          "
 994         "config         "
 995         "avg queue size "
 996         "min threshold  "
 997         "max threshold  "
 998         "drop prob %    "
 999         "drop rate %    "
1000         "diff %         "
1001         "tolerance %    "
1002         "\n",
1003         .tconfig = &ft5_tconfig,
1004         .tqueue = &ft5_tqueue,
1005         .tvar = &ft5_tvar,
1006         .tlevel = ft5_tlevel,
1007 };
1008
1009 static enum test_result func_test5(struct test_config *tcfg)
1010 {
1011         enum test_result result = PASS;
1012         uint32_t j = 0;
1013
1014         printf("%s", tcfg->msg);
1015
1016         if (test_rte_red_init(tcfg) != PASS) {
1017                 result = FAIL;
1018                 goto out;
1019         }
1020
1021         printf("%s", tcfg->htxt);
1022
1023         for (j = 0; j < tcfg->tqueue->num_queues; j++) {
1024                 rte_red_rt_data_init(&tcfg->tqueue->rdata[j]);
1025                 tcfg->tqueue->q[j] = 0;
1026
1027                 if (increase_actual_qsize(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1028                                           &tcfg->tqueue->rdata[j],
1029                                           &tcfg->tqueue->q[j],
1030                                           *tcfg->tlevel,
1031                                           tcfg->tqueue->q_ramp_up) != 0) {
1032                         result = FAIL;
1033                         goto out;
1034                 }
1035
1036                 if (increase_average_qsize(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1037                                            &tcfg->tqueue->rdata[j],
1038                                            &tcfg->tqueue->q[j],
1039                                            *tcfg->tlevel,
1040                                            tcfg->tqueue->avg_ramp_up) != 0) {
1041                         result = FAIL;
1042                         goto out;
1043                 }
1044         }
1045
1046         for (j = 0; j < tcfg->tqueue->num_queues; j++) {
1047                 uint32_t avg = 0;
1048                 double drop_rate = 0.0;
1049                 double drop_prob = 0.0;
1050                 double diff = 0.0;
1051
1052                 tcfg->tvar->dropped[j] = 0;
1053                 tcfg->tvar->enqueued[j] = 0;
1054
1055                 enqueue_dequeue_func(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1056                                      &tcfg->tqueue->rdata[j],
1057                                      &tcfg->tqueue->q[j],
1058                                      tcfg->tvar->num_ops,
1059                                      &tcfg->tvar->enqueued[j],
1060                                      &tcfg->tvar->dropped[j]);
1061
1062                 avg = rte_red_get_avg_int(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1063                                           &tcfg->tqueue->rdata[j]);
1064                 if (avg != *tcfg->tlevel)
1065                         result = FAIL;
1066
1067                 drop_rate = calc_drop_rate(tcfg->tvar->enqueued[j],tcfg->tvar->dropped[j]);
1068                 drop_prob = calc_drop_prob(tcfg->tconfig->min_th, tcfg->tconfig->max_th,
1069                                            tcfg->tconfig->maxp_inv[tcfg->tqueue->qconfig[j]],
1070                                            *tcfg->tlevel);
1071                 if (!check_drop_rate(&diff, drop_rate, drop_prob, (double)tcfg->tqueue->drop_tolerance))
1072                         result = FAIL;
1073
1074                 printf("%-15u%-15u%-15u%-15u%-15u%-15.4lf%-15.4lf%-15.4lf%-15.4lf\n",
1075                        j, tcfg->tqueue->qconfig[j], avg,
1076                        tcfg->tconfig->min_th, tcfg->tconfig->max_th,
1077                        drop_prob * 100.0, drop_rate * 100.0,
1078                        diff, (double)tcfg->tqueue->drop_tolerance);
1079         }
1080 out:
1081         return result;
1082 }
1083
1084 /**
1085  * Test F6: functional test 6
1086  */
1087 static uint32_t ft6_tlevel[] = {1022};
1088 static uint8_t ft6_wq_log2[] = {9, 8};
1089 static uint8_t ft6_maxp_inv[] = {10, 20};
1090 static struct rte_red_config ft6_config[2];
1091 static struct rte_red ft6_data[4];
1092 static uint32_t ft6_q[4];
1093
1094 static struct test_rte_red_config ft6_tconfig =  {
1095         .rconfig = ft6_config,
1096         .num_cfg = RTE_DIM(ft6_config),
1097         .min_th = 32,
1098         .max_th = 1023,
1099         .wq_log2 = ft6_wq_log2,
1100         .maxp_inv = ft6_maxp_inv,
1101 };
1102
1103 static struct test_queue ft6_tqueue = {
1104         .rdata = ft6_data,
1105         .num_queues = RTE_DIM(ft6_data),
1106         .qconfig = ft_qconfig,
1107         .q = ft6_q,
1108         .q_ramp_up = 1000000,
1109         .avg_ramp_up = 1000000,
1110         .avg_tolerance = 5,  /* 10 percent */
1111         .drop_tolerance = 50,  /* 50 percent */
1112 };
1113
1114 static struct test_config func_test6_config = {
1115         .ifname = "functional test 6 interface",
1116         .msg = "functional test 6 : use several queues (each with its own run-time data),\n"
1117         "                   use several RED configurations (such that each configuration is sharte_red by multiple queues),\n"
1118         "                   increase average queue size to target level,\n"
1119         "                   dequeue all packets until queue is empty,\n"
1120         "                   confirm that average queue size is computed correctly while queue is empty\n"
1121         "                   (this is a larger scale version of functional test 3)\n\n",
1122         .htxt = "queue          "
1123         "config         "
1124         "q avg before   "
1125         "q avg after    "
1126         "expected       "
1127         "difference %   "
1128         "tolerance %    "
1129         "result  ""\n",
1130         .tconfig = &ft6_tconfig,
1131         .tqueue = &ft6_tqueue,
1132         .tvar = &ft_tvar,
1133         .tlevel = ft6_tlevel,
1134 };
1135
1136 static enum test_result func_test6(struct test_config *tcfg)
1137 {
1138         enum test_result result = PASS;
1139         uint32_t j = 0;
1140
1141         printf("%s", tcfg->msg);
1142         if (test_rte_red_init(tcfg) != PASS) {
1143                 result = FAIL;
1144                 goto out;
1145         }
1146         printf("%s", tcfg->htxt);
1147
1148         for (j = 0; j < tcfg->tqueue->num_queues; j++) {
1149                 rte_red_rt_data_init(&tcfg->tqueue->rdata[j]);
1150                 tcfg->tqueue->q[j] = 0;
1151
1152                 if (increase_actual_qsize(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1153                                           &tcfg->tqueue->rdata[j],
1154                                           &tcfg->tqueue->q[j],
1155                                           *tcfg->tlevel,
1156                                           tcfg->tqueue->q_ramp_up) != 0) {
1157                         result = FAIL;
1158                         goto out;
1159                 }
1160                 if (increase_average_qsize(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1161                                            &tcfg->tqueue->rdata[j],
1162                                            &tcfg->tqueue->q[j],
1163                                            *tcfg->tlevel,
1164                                            tcfg->tqueue->avg_ramp_up) != 0) {
1165                         result = FAIL;
1166                         goto out;
1167                 }
1168         }
1169         for (j = 0; j < tcfg->tqueue->num_queues; j++) {
1170                 double avg_before = 0;
1171                 double avg_after = 0;
1172                 double exp_avg = 0;
1173                 double diff = 0.0;
1174
1175                 avg_before = rte_red_get_avg_float(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1176                                                    &tcfg->tqueue->rdata[j]);
1177
1178                 /**
1179                  * empty the queue
1180                  */
1181                 tcfg->tqueue->q[j] = 0;
1182                 rte_red_mark_queue_empty(&tcfg->tqueue->rdata[j], get_port_ts());
1183                 rte_delay_us(tcfg->tvar->wait_usec);
1184
1185                 /**
1186                  * enqueue one packet to recalculate average queue size
1187                  */
1188                 if (rte_red_enqueue(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1189                                     &tcfg->tqueue->rdata[j],
1190                                     tcfg->tqueue->q[j],
1191                                     get_port_ts()) == 0) {
1192                         tcfg->tqueue->q[j]++;
1193                 } else {
1194                         printf("%s:%d: packet enqueued on empty queue was dropped\n", __func__, __LINE__);
1195                         result = FAIL;
1196                 }
1197
1198                 exp_avg = calc_exp_avg_on_empty(avg_before,
1199                                 (1 << tcfg->tconfig->wq_log2[tcfg->tqueue->qconfig[j]]),
1200                                 tcfg->tvar->wait_usec);
1201                 avg_after = rte_red_get_avg_float(&tcfg->tconfig->rconfig[tcfg->tqueue->qconfig[j]],
1202                                                 &tcfg->tqueue->rdata[j]);
1203                 if (!check_avg(&diff, avg_after, exp_avg, (double)tcfg->tqueue->avg_tolerance))
1204                         result = FAIL;
1205
1206                 printf("%-15u%-15u%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15s\n",
1207                        j, tcfg->tqueue->qconfig[j], avg_before, avg_after,
1208                        exp_avg, diff, (double)tcfg->tqueue->avg_tolerance,
1209                        diff <= tcfg->tqueue->avg_tolerance ? "pass" : "fail");
1210         }
1211 out:
1212         return result;
1213 }
1214
1215 /**
1216  * setup default values for the performance test structures
1217  */
1218 static struct rte_red_config pt_wrconfig[1];
1219 static struct rte_red pt_rtdata[1];
1220 static uint8_t pt_wq_log2[] = {9};
1221 static uint8_t pt_maxp_inv[] = {10};
1222 static uint32_t pt_qconfig[] = {0};
1223 static uint32_t pt_q[] = {0};
1224 static uint32_t pt_dropped[] = {0};
1225 static uint32_t pt_enqueued[] = {0};
1226
1227 static struct test_rte_red_config pt_tconfig =  {
1228         .rconfig = pt_wrconfig,
1229         .num_cfg = RTE_DIM(pt_wrconfig),
1230         .wq_log2 = pt_wq_log2,
1231         .min_th = 32,
1232         .max_th = 128,
1233         .maxp_inv = pt_maxp_inv,
1234 };
1235
1236 static struct test_queue pt_tqueue = {
1237         .rdata = pt_rtdata,
1238         .num_queues = RTE_DIM(pt_rtdata),
1239         .qconfig = pt_qconfig,
1240         .q = pt_q,
1241         .q_ramp_up = 1000000,
1242         .avg_ramp_up = 1000000,
1243         .avg_tolerance = 5,  /* 10 percent */
1244         .drop_tolerance = 50,  /* 50 percent */
1245 };
1246
1247 /**
1248  * enqueue/dequeue packets
1249  */
1250 static void enqueue_dequeue_perf(struct rte_red_config *red_cfg,
1251                                  struct rte_red *red,
1252                                  uint32_t *q,
1253                                  uint32_t num_ops,
1254                                  uint32_t *enqueued,
1255                                  uint32_t *dropped,
1256                                  struct rdtsc_prof *prof)
1257 {
1258         uint32_t i = 0;
1259
1260         for (i = 0; i < num_ops; i++) {
1261                 uint64_t ts = 0;
1262                 int ret = 0;
1263                 /**
1264                  * enqueue
1265                  */
1266                 ts = get_port_ts();
1267                 rdtsc_prof_start(prof);
1268                 ret = rte_red_enqueue(red_cfg, red, *q, ts );
1269                 rdtsc_prof_end(prof);
1270                 if (ret == 0)
1271                         (*enqueued)++;
1272                 else
1273                         (*dropped)++;
1274         }
1275 }
1276
1277 /**
1278  * Setup test structures for tests P1, P2, P3
1279  * performance tests 1, 2 and 3
1280  */
1281 static uint32_t pt1_tlevel[] = {16};
1282 static uint32_t pt2_tlevel[] = {80};
1283 static uint32_t pt3_tlevel[] = {144};
1284
1285 static struct test_var perf1_tvar = {
1286         .wait_usec = 0,
1287         .num_iterations = 15,
1288         .num_ops = 50000000,
1289         .clk_freq = 0,
1290         .dropped = pt_dropped,
1291         .enqueued = pt_enqueued,
1292         .sleep_sec = 0
1293 };
1294
1295 static struct test_config perf1_test1_config = {
1296         .ifname = "performance test 1 interface",
1297         .msg = "performance test 1 : use one RED configuration,\n"
1298         "                    set actual and average queue sizes to level below min threshold,\n"
1299         "                    measure enqueue performance\n\n",
1300         .tconfig = &pt_tconfig,
1301         .tqueue = &pt_tqueue,
1302         .tvar = &perf1_tvar,
1303         .tlevel = pt1_tlevel,
1304 };
1305
1306 static struct test_config perf1_test2_config = {
1307         .ifname = "performance test 2 interface",
1308         .msg = "performance test 2 : use one RED configuration,\n"
1309         "                    set actual and average queue sizes to level in between min and max thresholds,\n"
1310         "                    measure enqueue performance\n\n",
1311         .tconfig = &pt_tconfig,
1312         .tqueue = &pt_tqueue,
1313         .tvar = &perf1_tvar,
1314         .tlevel = pt2_tlevel,
1315 };
1316
1317 static struct test_config perf1_test3_config = {
1318         .ifname = "performance test 3 interface",
1319         .msg = "performance test 3 : use one RED configuration,\n"
1320         "                    set actual and average queue sizes to level above max threshold,\n"
1321         "                    measure enqueue performance\n\n",
1322         .tconfig = &pt_tconfig,
1323         .tqueue = &pt_tqueue,
1324         .tvar = &perf1_tvar,
1325         .tlevel = pt3_tlevel,
1326 };
1327
1328 /**
1329  * Performance test function to measure enqueue performance.
1330  * This runs performance tests 1, 2 and 3
1331  */
1332 static enum test_result perf1_test(struct test_config *tcfg)
1333 {
1334         enum test_result result = PASS;
1335         struct rdtsc_prof prof = {0, 0, 0, 0, 0.0, NULL};
1336         uint32_t total = 0;
1337
1338         printf("%s", tcfg->msg);
1339
1340         rdtsc_prof_init(&prof, "enqueue");
1341
1342         if (test_rte_red_init(tcfg) != PASS) {
1343                 result = FAIL;
1344                 goto out;
1345         }
1346
1347         /**
1348          * set average queue size to target level
1349          */
1350         *tcfg->tqueue->q = *tcfg->tlevel;
1351
1352         /**
1353          * initialize the rte_red run time data structure
1354          */
1355         rte_red_rt_data_init(tcfg->tqueue->rdata);
1356
1357         /**
1358          *  set the queue average
1359          */
1360         rte_red_set_avg_int(tcfg->tconfig->rconfig, tcfg->tqueue->rdata, *tcfg->tlevel);
1361         if (rte_red_get_avg_int(tcfg->tconfig->rconfig, tcfg->tqueue->rdata)
1362             != *tcfg->tlevel) {
1363                 result = FAIL;
1364                 goto out;
1365         }
1366
1367         enqueue_dequeue_perf(tcfg->tconfig->rconfig,
1368                              tcfg->tqueue->rdata,
1369                              tcfg->tqueue->q,
1370                              tcfg->tvar->num_ops,
1371                              tcfg->tvar->enqueued,
1372                              tcfg->tvar->dropped,
1373                              &prof);
1374
1375         total = *tcfg->tvar->enqueued + *tcfg->tvar->dropped;
1376
1377         printf("\ntotal: %u, enqueued: %u (%.2lf%%), dropped: %u (%.2lf%%)\n", total,
1378                *tcfg->tvar->enqueued, ((double)(*tcfg->tvar->enqueued) / (double)total) * 100.0,
1379                *tcfg->tvar->dropped, ((double)(*tcfg->tvar->dropped) / (double)total) * 100.0);
1380
1381         rdtsc_prof_print(&prof);
1382 out:
1383         return result;
1384 }
1385
1386 /**
1387  * Setup test structures for tests P4, P5, P6
1388  * performance tests 4, 5 and 6
1389  */
1390 static uint32_t pt4_tlevel[] = {16};
1391 static uint32_t pt5_tlevel[] = {80};
1392 static uint32_t pt6_tlevel[] = {144};
1393
1394 static struct test_var perf2_tvar = {
1395         .wait_usec = 500,
1396         .num_iterations = 10000,
1397         .num_ops = 10000,
1398         .dropped = pt_dropped,
1399         .enqueued = pt_enqueued,
1400         .sleep_sec = 0
1401 };
1402
1403 static struct test_config perf2_test4_config = {
1404         .ifname = "performance test 4 interface",
1405         .msg = "performance test 4 : use one RED configuration,\n"
1406         "                    set actual and average queue sizes to level below min threshold,\n"
1407         "                    dequeue all packets until queue is empty,\n"
1408         "                    measure enqueue performance when queue is empty\n\n",
1409         .htxt = "iteration      "
1410         "q avg before   "
1411         "q avg after    "
1412         "expected       "
1413         "difference %   "
1414         "tolerance %    "
1415         "result  ""\n",
1416         .tconfig = &pt_tconfig,
1417         .tqueue = &pt_tqueue,
1418         .tvar = &perf2_tvar,
1419         .tlevel = pt4_tlevel,
1420 };
1421
1422 static struct test_config perf2_test5_config = {
1423         .ifname = "performance test 5 interface",
1424         .msg = "performance test 5 : use one RED configuration,\n"
1425         "                    set actual and average queue sizes to level in between min and max thresholds,\n"
1426         "                    dequeue all packets until queue is empty,\n"
1427         "                    measure enqueue performance when queue is empty\n\n",
1428         .htxt = "iteration      "
1429         "q avg before   "
1430         "q avg after    "
1431         "expected       "
1432         "difference     "
1433         "tolerance      "
1434         "result  ""\n",
1435         .tconfig = &pt_tconfig,
1436         .tqueue = &pt_tqueue,
1437         .tvar = &perf2_tvar,
1438         .tlevel = pt5_tlevel,
1439 };
1440
1441 static struct test_config perf2_test6_config = {
1442         .ifname = "performance test 6 interface",
1443         .msg = "performance test 6 : use one RED configuration,\n"
1444         "                    set actual and average queue sizes to level above max threshold,\n"
1445         "                    dequeue all packets until queue is empty,\n"
1446         "                    measure enqueue performance when queue is empty\n\n",
1447         .htxt = "iteration      "
1448         "q avg before   "
1449         "q avg after    "
1450         "expected       "
1451         "difference %   "
1452         "tolerance %    "
1453         "result  ""\n",
1454         .tconfig = &pt_tconfig,
1455         .tqueue = &pt_tqueue,
1456         .tvar = &perf2_tvar,
1457         .tlevel = pt6_tlevel,
1458 };
1459
1460 /**
1461  * Performance test function to measure enqueue performance when the
1462  * queue is empty. This runs performance tests 4, 5 and 6
1463  */
1464 static enum test_result perf2_test(struct test_config *tcfg)
1465 {
1466         enum test_result result = PASS;
1467         struct rdtsc_prof prof = {0, 0, 0, 0, 0.0, NULL};
1468         uint32_t total = 0;
1469         uint32_t i = 0;
1470
1471         printf("%s", tcfg->msg);
1472
1473         rdtsc_prof_init(&prof, "enqueue");
1474
1475         if (test_rte_red_init(tcfg) != PASS) {
1476                 result = FAIL;
1477                 goto out;
1478         }
1479
1480         printf("%s", tcfg->htxt);
1481
1482         for (i = 0; i < tcfg->tvar->num_iterations; i++) {
1483                 uint32_t count = 0;
1484                 uint64_t ts = 0;
1485                 double avg_before = 0;
1486                 int ret = 0;
1487
1488                 /**
1489                  * set average queue size to target level
1490                  */
1491                 *tcfg->tqueue->q = *tcfg->tlevel;
1492                 count = (*tcfg->tqueue->rdata).count;
1493
1494                 /**
1495                  * initialize the rte_red run time data structure
1496                  */
1497                 rte_red_rt_data_init(tcfg->tqueue->rdata);
1498                 (*tcfg->tqueue->rdata).count = count;
1499
1500                 /**
1501                  * set the queue average
1502                  */
1503                 rte_red_set_avg_int(tcfg->tconfig->rconfig, tcfg->tqueue->rdata, *tcfg->tlevel);
1504                 avg_before = rte_red_get_avg_float(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
1505                 if ((avg_before < *tcfg->tlevel) || (avg_before > *tcfg->tlevel)) {
1506                         result = FAIL;
1507                         goto out;
1508                 }
1509
1510                 /**
1511                  * empty the queue
1512                  */
1513                 *tcfg->tqueue->q = 0;
1514                 rte_red_mark_queue_empty(tcfg->tqueue->rdata, get_port_ts());
1515
1516                 /**
1517                  * wait for specified period of time
1518                  */
1519                 rte_delay_us(tcfg->tvar->wait_usec);
1520
1521                 /**
1522                  * measure performance of enqueue operation while queue is empty
1523                  */
1524                 ts = get_port_ts();
1525                 rdtsc_prof_start(&prof);
1526                 ret = rte_red_enqueue(tcfg->tconfig->rconfig, tcfg->tqueue->rdata,
1527                                       *tcfg->tqueue->q, ts );
1528                 rdtsc_prof_end(&prof);
1529
1530                 /**
1531                  * gather enqueued/dropped statistics
1532                  */
1533                 if (ret == 0)
1534                         (*tcfg->tvar->enqueued)++;
1535                 else
1536                         (*tcfg->tvar->dropped)++;
1537
1538                 /**
1539                  * on first and last iteration, confirm that
1540                  * average queue size was computed correctly
1541                  */
1542                 if ((i == 0) || (i == tcfg->tvar->num_iterations - 1)) {
1543                         double avg_after = 0;
1544                         double exp_avg = 0;
1545                         double diff = 0.0;
1546                         int ok = 0;
1547
1548                         avg_after = rte_red_get_avg_float(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
1549                         exp_avg = calc_exp_avg_on_empty(avg_before,
1550                                                   (1 << *tcfg->tconfig->wq_log2),
1551                                                   tcfg->tvar->wait_usec);
1552                         if (check_avg(&diff, avg_after, exp_avg, (double)tcfg->tqueue->avg_tolerance))
1553                                 ok = 1;
1554                         printf("%-15u%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15.4lf%-15s\n",
1555                                 i, avg_before, avg_after, exp_avg, diff,
1556                                 (double)tcfg->tqueue->avg_tolerance, ok ? "pass" : "fail");
1557                         if (!ok) {
1558                                 result = FAIL;
1559                                 goto out;
1560                         }
1561                 }
1562         }
1563         total =  *tcfg->tvar->enqueued +  *tcfg->tvar->dropped;
1564         printf("\ntotal: %u, enqueued: %u (%.2lf%%), dropped: %u (%.2lf%%)\n", total,
1565                *tcfg->tvar->enqueued, ((double)(*tcfg->tvar->enqueued) / (double)total) * 100.0,
1566                *tcfg->tvar->dropped, ((double)(*tcfg->tvar->dropped) / (double)total) * 100.0);
1567
1568         rdtsc_prof_print(&prof);
1569 out:
1570         return result;
1571 }
1572
1573 /**
1574  * setup default values for overflow test structures
1575  */
1576 static uint32_t avg_max = 0;
1577 static uint32_t avg_max_bits = 0;
1578
1579 static struct rte_red_config ovfl_wrconfig[1];
1580 static struct rte_red ovfl_rtdata[1];
1581 static uint8_t ovfl_maxp_inv[] = {10};
1582 static uint32_t ovfl_qconfig[] = {0, 0, 1, 1};
1583 static uint32_t ovfl_q[] ={0};
1584 static uint32_t ovfl_dropped[] ={0};
1585 static uint32_t ovfl_enqueued[] ={0};
1586 static uint32_t ovfl_tlevel[] = {1023};
1587 static uint8_t ovfl_wq_log2[] = {12};
1588
1589 static struct test_rte_red_config ovfl_tconfig =  {
1590         .rconfig = ovfl_wrconfig,
1591         .num_cfg = RTE_DIM(ovfl_wrconfig),
1592         .wq_log2 = ovfl_wq_log2,
1593         .min_th = 32,
1594         .max_th = 1023,
1595         .maxp_inv = ovfl_maxp_inv,
1596 };
1597
1598 static struct test_queue ovfl_tqueue = {
1599         .rdata = ovfl_rtdata,
1600         .num_queues = RTE_DIM(ovfl_rtdata),
1601         .qconfig = ovfl_qconfig,
1602         .q = ovfl_q,
1603         .q_ramp_up = 1000000,
1604         .avg_ramp_up = 1000000,
1605         .avg_tolerance = 5,  /* 10 percent */
1606         .drop_tolerance = 50,  /* 50 percent */
1607 };
1608
1609 static struct test_var ovfl_tvar = {
1610         .wait_usec = 10000,
1611         .num_iterations = 1,
1612         .num_ops = 10000,
1613         .clk_freq = 0,
1614         .dropped = ovfl_dropped,
1615         .enqueued = ovfl_enqueued,
1616         .sleep_sec = 0
1617 };
1618
1619 static void ovfl_check_avg(uint32_t avg)
1620 {
1621         if (avg > avg_max) {
1622                 double avg_log = 0;
1623                 uint32_t bits = 0;
1624                 avg_max = avg;
1625                 avg_log = log(((double)avg_max));
1626                 avg_log = avg_log / log(2.0);
1627                 bits = (uint32_t)ceil(avg_log);
1628                 if (bits > avg_max_bits)
1629                         avg_max_bits = bits;
1630         }
1631 }
1632
1633 static struct test_config ovfl_test1_config = {
1634         .ifname = "queue avergage overflow test interface",
1635         .msg = "overflow test 1 : use one RED configuration,\n"
1636         "                 increase average queue size to target level,\n"
1637         "                 check maximum number of bits requirte_red to represent avg_s\n\n",
1638         .htxt = "avg queue size  "
1639         "wq_log2  "
1640         "fraction bits  "
1641         "max queue avg  "
1642         "num bits  "
1643         "enqueued  "
1644         "dropped   "
1645         "drop prob %  "
1646         "drop rate %  "
1647         "\n",
1648         .tconfig = &ovfl_tconfig,
1649         .tqueue = &ovfl_tqueue,
1650         .tvar = &ovfl_tvar,
1651         .tlevel = ovfl_tlevel,
1652 };
1653
1654 static enum test_result ovfl_test1(struct test_config *tcfg)
1655 {
1656         enum test_result result = PASS;
1657         uint32_t avg = 0;
1658         uint32_t i = 0;
1659         double drop_rate = 0.0;
1660         double drop_prob = 0.0;
1661         double diff = 0.0;
1662         int ret = 0;
1663
1664         printf("%s", tcfg->msg);
1665
1666         if (test_rte_red_init(tcfg) != PASS) {
1667
1668                 result = FAIL;
1669                 goto out;
1670         }
1671
1672         /**
1673          * reset rte_red run-time data
1674          */
1675         rte_red_rt_data_init(tcfg->tqueue->rdata);
1676
1677         /**
1678          * increase actual queue size
1679          */
1680         for (i = 0; i < tcfg->tqueue->q_ramp_up; i++) {
1681                 ret = rte_red_enqueue(tcfg->tconfig->rconfig, tcfg->tqueue->rdata,
1682                                       *tcfg->tqueue->q, get_port_ts());
1683
1684                 if (ret == 0) {
1685                         if (++(*tcfg->tqueue->q) >= *tcfg->tlevel)
1686                                 break;
1687                 }
1688         }
1689
1690         /**
1691          * enqueue
1692          */
1693         for (i = 0; i < tcfg->tqueue->avg_ramp_up; i++) {
1694                 ret = rte_red_enqueue(tcfg->tconfig->rconfig, tcfg->tqueue->rdata,
1695                                       *tcfg->tqueue->q, get_port_ts());
1696                 ovfl_check_avg((*tcfg->tqueue->rdata).avg);
1697                 avg = rte_red_get_avg_int(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
1698                 if (avg == *tcfg->tlevel) {
1699                         if (ret == 0)
1700                                 (*tcfg->tvar->enqueued)++;
1701                         else
1702                                 (*tcfg->tvar->dropped)++;
1703                 }
1704         }
1705
1706         /**
1707          * check if target average queue size has been reached
1708          */
1709         avg = rte_red_get_avg_int(tcfg->tconfig->rconfig, tcfg->tqueue->rdata);
1710         if (avg != *tcfg->tlevel) {
1711                 result = FAIL;
1712                 goto out;
1713         }
1714
1715         /**
1716          * check drop rate against drop probability
1717          */
1718         drop_rate = calc_drop_rate(*tcfg->tvar->enqueued, *tcfg->tvar->dropped);
1719         drop_prob = calc_drop_prob(tcfg->tconfig->min_th,
1720                                    tcfg->tconfig->max_th,
1721                                    *tcfg->tconfig->maxp_inv,
1722                                    *tcfg->tlevel);
1723         if (!check_drop_rate(&diff, drop_rate, drop_prob, (double)tcfg->tqueue->drop_tolerance))
1724                 result = FAIL;
1725
1726         printf("%s", tcfg->htxt);
1727
1728         printf("%-16u%-9u%-15u0x%08x     %-10u%-10u%-10u%-13.2lf%-13.2lf\n",
1729                avg, *tcfg->tconfig->wq_log2, RTE_RED_SCALING,
1730                avg_max, avg_max_bits,
1731                *tcfg->tvar->enqueued, *tcfg->tvar->dropped,
1732                drop_prob * 100.0, drop_rate * 100.0);
1733 out:
1734         return result;
1735 }
1736
1737 /**
1738  * define the functional and performance tests to be executed
1739  */
1740 struct tests func_tests[] = {
1741         { &func_test1_config, func_test1 },
1742         { &func_test2_config, func_test2 },
1743         { &func_test3_config, func_test3 },
1744         { &func_test4_config, func_test4 },
1745         { &func_test5_config, func_test5 },
1746         { &func_test6_config, func_test6 },
1747         { &ovfl_test1_config, ovfl_test1 },
1748 };
1749
1750 struct tests perf_tests[] = {
1751         { &perf1_test1_config, perf1_test },
1752         { &perf1_test2_config, perf1_test },
1753         { &perf1_test3_config, perf1_test },
1754         { &perf2_test4_config, perf2_test },
1755         { &perf2_test5_config, perf2_test },
1756         { &perf2_test6_config, perf2_test },
1757 };
1758
1759 /**
1760  * function to execute the required_red tests
1761  */
1762 static void run_tests(struct tests *test_type, uint32_t test_count, uint32_t *num_tests, uint32_t *num_pass)
1763 {
1764         enum test_result result = PASS;
1765         uint32_t i = 0;
1766
1767         for (i = 0; i < test_count; i++) {
1768                 printf("\n--------------------------------------------------------------------------------\n");
1769                 result = test_type[i].testfn(test_type[i].testcfg);
1770                 (*num_tests)++;
1771                 if (result == PASS) {
1772                         (*num_pass)++;
1773                                 printf("-------------------------------------<pass>-------------------------------------\n");
1774                 } else {
1775                         printf("-------------------------------------<fail>-------------------------------------\n");
1776                 }
1777         }
1778         return;
1779 }
1780
1781 /**
1782  * check if functions accept invalid parameters
1783  *
1784  * First, all functions will be called without initialized RED
1785  * Then, all of them will be called with NULL/invalid parameters
1786  *
1787  * Some functions are not tested as they are performance-critical and thus
1788  * don't do any parameter checking.
1789  */
1790 static int
1791 test_invalid_parameters(void)
1792 {
1793         struct rte_red_config config;
1794
1795         if (rte_red_rt_data_init(NULL) == 0) {
1796                 printf("rte_red_rt_data_init should have failed!\n");
1797                 return -1;
1798         }
1799
1800         if (rte_red_config_init(NULL, 0, 0, 0, 0) == 0) {
1801                 printf("rte_red_config_init should have failed!\n");
1802                 return -1;
1803         }
1804
1805         if (rte_red_rt_data_init(NULL) == 0) {
1806                 printf("rte_red_rt_data_init should have failed!\n");
1807                 return -1;
1808         }
1809
1810         /* NULL config */
1811         if (rte_red_config_init(NULL, 0, 0, 0, 0) == 0) {
1812                 printf("%i: rte_red_config_init should have failed!\n", __LINE__);
1813                 return -1;
1814         }
1815         /* min_treshold == max_treshold */
1816         if (rte_red_config_init(&config, 0, 1, 1, 0) == 0) {
1817                 printf("%i: rte_red_config_init should have failed!\n", __LINE__);
1818                 return -1;
1819         }
1820         /* min_treshold > max_treshold */
1821         if (rte_red_config_init(&config, 0, 2, 1, 0) == 0) {
1822                 printf("%i: rte_red_config_init should have failed!\n", __LINE__);
1823                 return -1;
1824         }
1825         /* wq_log2 > RTE_RED_WQ_LOG2_MAX */
1826         if (rte_red_config_init(&config,
1827                         RTE_RED_WQ_LOG2_MAX + 1, 1, 2, 0) == 0) {
1828                 printf("%i: rte_red_config_init should have failed!\n", __LINE__);
1829                 return -1;
1830         }
1831         /* wq_log2 < RTE_RED_WQ_LOG2_MIN */
1832         if (rte_red_config_init(&config,
1833                         RTE_RED_WQ_LOG2_MIN - 1, 1, 2, 0) == 0) {
1834                 printf("%i: rte_red_config_init should have failed!\n", __LINE__);
1835                 return -1;
1836         }
1837         /* maxp_inv > RTE_RED_MAXP_INV_MAX */
1838         if (rte_red_config_init(&config,
1839                         RTE_RED_WQ_LOG2_MIN, 1, 2, RTE_RED_MAXP_INV_MAX + 1) == 0) {
1840                 printf("%i: rte_red_config_init should have failed!\n", __LINE__);
1841                 return -1;
1842         }
1843         /* maxp_inv < RTE_RED_MAXP_INV_MIN */
1844         if (rte_red_config_init(&config,
1845                         RTE_RED_WQ_LOG2_MIN, 1, 2, RTE_RED_MAXP_INV_MIN - 1) == 0) {
1846                 printf("%i: rte_red_config_init should have failed!\n", __LINE__);
1847                 return -1;
1848         }
1849
1850         return 0;
1851 }
1852
1853 static int
1854 test_red(void)
1855 {
1856         uint32_t num_tests = 0;
1857         uint32_t num_pass = 0;
1858         int ret = 0;
1859
1860         if (test_invalid_parameters() < 0)
1861                 return -1;
1862
1863         run_tests(func_tests, RTE_DIM(func_tests), &num_tests, &num_pass);
1864         run_tests(perf_tests, RTE_DIM(perf_tests), &num_tests, &num_pass);
1865
1866         if (num_pass == num_tests) {
1867                 printf("[total: %u, pass: %u]\n", num_tests, num_pass);
1868                 ret = 0;
1869         } else {
1870                 printf("[total: %u, pass: %u, fail: %u]\n", num_tests, num_pass, num_tests - num_pass);
1871                 ret = -1;
1872         }
1873         return ret;
1874 }
1875
1876 static struct test_command red_cmd = {
1877         .command = "red_autotest",
1878         .callback = test_red,
1879 };
1880 REGISTER_TEST_COMMAND(red_cmd);