Hi Alan, Thanks for your work!
I do have some comments (see below), but generally looks good to me. > -----Original Message----- > From: alangordonde...@gmail.com [mailto:alangordonde...@gmail.com] > Sent: Tuesday, October 3, 2017 10:22 AM > To: Dumitrescu, Cristian <cristian.dumitre...@intel.com> > Cc: dev@dpdk.org; Alan Dewar <alan.de...@att.com> > Subject: [PATCH v4] sched: make RED scaling configurable > > From: Alan Dewar <alan.de...@att.com> > > The RED code stores the weighted moving average in a 32-bit integer as > a pseudo fixed-point floating number with 10 fractional bits. Twelve > other bits are used to encode the filter weight, leaving just 10 bits > for the queue length. This limits the maximum queue length supported > by RED queues to 1024 packets. > > Introduce a new API to allow the RED scaling factor to be configured > based upon maximum queue length. If this API is not called, the RED > scaling factor remains at its default value. > > Added some new RED scaling unit-tests to test with RED queue-lengths > up to 8192 packets long. > > Signed-off-by: Alan Dewar <alan.de...@att.com> > --- > lib/librte_sched/rte_red.c | 53 ++++++- > lib/librte_sched/rte_red.h | 63 ++++++-- > lib/librte_sched/rte_sched_version.map | 6 + > test/test/test_red.c | 274 > ++++++++++++++++++++++++++++++++- > 4 files changed, 374 insertions(+), 22 deletions(-) > > diff --git a/lib/librte_sched/rte_red.c b/lib/librte_sched/rte_red.c > index ade57d1..0dc8d28 100644 > --- a/lib/librte_sched/rte_red.c > +++ b/lib/librte_sched/rte_red.c > @@ -43,6 +43,8 @@ > static int rte_red_init_done = 0; /**< Flag to indicate that global > initialisation is done */ > uint32_t rte_red_rand_val = 0; /**< Random value cache */ > uint32_t rte_red_rand_seed = 0; /**< Seed for random number > generation */ > +uint8_t rte_red_scaling = RTE_RED_SCALING_DEFAULT; > +uint16_t rte_red_max_threshold = RTE_RED_DEFAULT_QUEUE_LENGTH - > 1; > > /** > * table[i] = log2(1-Wq) * Scale * -1 > @@ -66,7 +68,7 @@ __rte_red_init_tables(void) > double scale = 0.0; > double table_size = 0.0; > > - scale = (double)(1 << RTE_RED_SCALING); > + scale = (double)(1 << rte_red_scaling); > table_size = (double)(RTE_DIM(rte_red_pow2_frac_inv)); > > for (i = 0; i < RTE_DIM(rte_red_pow2_frac_inv); i++) { > @@ -119,7 +121,7 @@ rte_red_config_init(struct rte_red_config *red_cfg, > if (red_cfg == NULL) { > return -1; > } > - if (max_th > RTE_RED_MAX_TH_MAX) { > + if (max_th > rte_red_max_threshold) { > return -2; > } > if (min_th >= max_th) { > @@ -148,11 +150,52 @@ rte_red_config_init(struct rte_red_config > *red_cfg, > rte_red_init_done = 1; > } > > - red_cfg->min_th = ((uint32_t) min_th) << (wq_log2 + > RTE_RED_SCALING); > - red_cfg->max_th = ((uint32_t) max_th) << (wq_log2 + > RTE_RED_SCALING); > - red_cfg->pa_const = (2 * (max_th - min_th) * maxp_inv) << > RTE_RED_SCALING; > + red_cfg->min_th = ((uint32_t) min_th) << (wq_log2 + > rte_red_scaling); > + red_cfg->max_th = ((uint32_t) max_th) << (wq_log2 + > rte_red_scaling); > + red_cfg->pa_const = (2 * (max_th - min_th) * maxp_inv) << > + rte_red_scaling; > red_cfg->maxp_inv = maxp_inv; > red_cfg->wq_log2 = wq_log2; > > return 0; > } > + > +int > +rte_red_set_scaling(uint16_t max_red_queue_length) > +{ > + int8_t count; > + > + if (rte_red_init_done) > + /** > + * Can't change the scaling once the red table has been > + * computed. > + */ > + return -1; > + > + if (max_red_queue_length < RTE_RED_MIN_QUEUE_LENGTH) > + return -2; > + > + if (max_red_queue_length > RTE_RED_MAX_QUEUE_LENGTH) > + return -3; > + > + if (!rte_is_power_of_2(max_red_queue_length)) > + return -4; > + > + count = 0; > + while (max_red_queue_length != 0) { > + max_red_queue_length >>= 1; > + count++; > + } > + > + rte_red_scaling -= count - RTE_RED_SCALING_DEFAULT; > + rte_red_max_threshold = max_red_queue_length - 1; > + return 0; > +} > + > +void > +rte_red_reset_scaling(void) > +{ > + rte_red_init_done = 0; > + rte_red_scaling = RTE_RED_SCALING_DEFAULT; > + rte_red_max_threshold = RTE_RED_DEFAULT_QUEUE_LENGTH - 1; > +} Why do we need this function? These global variables are already initialized at the top of the file. My vote is to remove it. > diff --git a/lib/librte_sched/rte_red.h b/lib/librte_sched/rte_red.h > index ca12227..be1fb0f 100644 > --- a/lib/librte_sched/rte_red.h > +++ b/lib/librte_sched/rte_red.h > @@ -52,14 +52,31 @@ extern "C" { > #include <rte_cycles.h> > #include <rte_branch_prediction.h> > > -#define RTE_RED_SCALING 10 /**< Fraction size > for fixed- > point */ > -#define RTE_RED_S (1 << 22) /**< Packet size > multiplied > by number of leaf queues */ > -#define RTE_RED_MAX_TH_MAX 1023 /**< Max threshold > limit in fixed point format */ > -#define RTE_RED_WQ_LOG2_MIN 1 /**< Min inverse > filter > weight value */ > -#define RTE_RED_WQ_LOG2_MAX 12 /**< Max inverse > filter weight value */ > -#define RTE_RED_MAXP_INV_MIN 1 /**< Min inverse mark > probability value */ > -#define RTE_RED_MAXP_INV_MAX 255 /**< Max inverse > mark probability value */ > -#define RTE_RED_2POW16 (1<<16) /**< 2 power 16 */ > +/**< Default fraction size for fixed-point */ > +#define RTE_RED_SCALING_DEFAULT 10 Let's keep the name of this macro undchanges, i.e. RTE_RED_SCALING. IMO it is ckear enough this is the default value (also stated in the comment). > + > +/**< Packet size multiplied by number of leaf queues */ > +#define RTE_RED_S (1 << 22) > + > +/**< Minimum, default and maximum RED queue length */ > +#define RTE_RED_MIN_QUEUE_LENGTH 64 > +#define RTE_RED_DEFAULT_QUEUE_LENGTH 1024 > +#define RTE_RED_MAX_QUEUE_LENGTH 8192 > + > +/**< Min inverse filter weight value */ > +#define RTE_RED_WQ_LOG2_MIN 1 > + > +/**< Max inverse filter weight value */ > +#define RTE_RED_WQ_LOG2_MAX 12 > + > +/**< Min inverse mark probability value */ > +#define RTE_RED_MAXP_INV_MIN 1 > + > +/**< Max inverse mark probability value */ > +#define RTE_RED_MAXP_INV_MAX 255 > + > +/**< 2 power 16 */ > +#define RTE_RED_2POW16 (1<<16) > #define RTE_RED_INT16_NBITS (sizeof(uint16_t) * CHAR_BIT) > #define RTE_RED_WQ_LOG2_NUM (RTE_RED_WQ_LOG2_MAX - > RTE_RED_WQ_LOG2_MIN + 1) > All the above Doxygen comments are incorrectly formatted: as you want to change their behavior to refer to the variable _after_ the comment, they have to start with /**, not with /**< (which should be used if the comment refers to the variable _before_ the comment). Please fix. > @@ -71,6 +88,8 @@ extern uint32_t rte_red_rand_val; > extern uint32_t rte_red_rand_seed; > extern uint16_t rte_red_log2_1_minus_Wq[RTE_RED_WQ_LOG2_NUM]; > extern uint16_t rte_red_pow2_frac_inv[16]; > +extern uint8_t rte_red_scaling; > +extern uint16_t rte_red_max_threshold; > > /** > * RED configuration parameters passed by user > @@ -137,6 +156,26 @@ rte_red_config_init(struct rte_red_config *red_cfg, > const uint16_t maxp_inv); > > /** > + * @brief Configures the global setting for the RED scaling factor > + * > + * @param max_red_queue_length [in] must be a power of two > + * > + * @return Operation status > + * @retval 0 success > + * @retval !0 error > + */ > +int > +rte_red_set_scaling(uint16_t max_red_queue_length); > + > +/** > + * @brief Reset the RED scaling factor - only for use by RED unit-tests > + * > + * @return Operation status > + */ > +void > +rte_red_reset_scaling(void); As stated above, this function is probably not useful and my vote is to remove it. > + > +/** > * @brief Generate random number for RED > * > * Implemenetation based on: > @@ -206,7 +245,7 @@ __rte_red_calc_qempty_factor(uint8_t wq_log2, > uint16_t m) > f = (n >> 6) & 0xf; > n >>= 10; > > - if (n < RTE_RED_SCALING) > + if (n < rte_red_scaling) > return (uint16_t) ((rte_red_pow2_frac_inv[f] + (1 << (n - 1))) > >> n); > > return 0; > @@ -258,7 +297,9 @@ rte_red_enqueue_empty(const struct rte_red_config > *red_cfg, > if (m >= RTE_RED_2POW16) { > red->avg = 0; > } else { > - red->avg = (red->avg >> RTE_RED_SCALING) * > __rte_red_calc_qempty_factor(red_cfg->wq_log2, (uint16_t) m); > + red->avg = (red->avg >> rte_red_scaling) * > + __rte_red_calc_qempty_factor(red_cfg->wq_log2, > + (uint16_t) m); > } > > return 0; > @@ -365,7 +406,7 @@ rte_red_enqueue_nonempty(const struct > rte_red_config *red_cfg, > */ > > /* avg update */ > - red->avg += (q << RTE_RED_SCALING) - (red->avg >> red_cfg- > >wq_log2); > + red->avg += (q << rte_red_scaling) - (red->avg >> red_cfg- > >wq_log2); > > /* avg < min_th: do not mark the packet */ > if (red->avg < red_cfg->min_th) { > diff --git a/lib/librte_sched/rte_sched_version.map > b/lib/librte_sched/rte_sched_version.map > index 3aa159a..92e51f8 100644 > --- a/lib/librte_sched/rte_sched_version.map > +++ b/lib/librte_sched/rte_sched_version.map > @@ -29,3 +29,9 @@ DPDK_2.1 { > rte_sched_port_pkt_read_color; > > } DPDK_2.0; > + > +DPDK_17.08 { > + global; > + > + rte_red_set_scaling; > +} DPDK_2.1; > diff --git a/test/test/test_red.c b/test/test/test_red.c > index 348075d..f2d50ef 100644 > --- a/test/test/test_red.c > +++ b/test/test/test_red.c > @@ -67,6 +67,7 @@ struct test_rte_red_config { /**< Test structure > for RTE_RED config */ > uint32_t min_th; /**< Queue minimum threshold */ > uint32_t max_th; /**< Queue maximum threshold */ > uint8_t *maxp_inv; /**< Inverse mark probability */ > + uint16_t max_queue_len; /**< Maximum queue length */ > }; > > struct test_queue { /**< Test structure for RTE_RED Queues */ > @@ -181,7 +182,7 @@ static uint32_t rte_red_get_avg_int(const struct > rte_red_config *red_cfg, > /** > * scale by 1/n and convert from fixed-point to integer > */ > - return red->avg >> (RTE_RED_SCALING + red_cfg->wq_log2); > + return red->avg >> (rte_red_scaling + red_cfg->wq_log2); > } > > static double rte_red_get_avg_float(const struct rte_red_config *red_cfg, > @@ -190,7 +191,7 @@ static double rte_red_get_avg_float(const struct > rte_red_config *red_cfg, > /** > * scale by 1/n and convert from fixed-point to floating-point > */ > - return ldexp((double)red->avg, -(RTE_RED_SCALING + red_cfg- > >wq_log2)); > + return ldexp((double)red->avg, -(rte_red_scaling + red_cfg- > >wq_log2)); > } > > static void rte_red_set_avg_int(const struct rte_red_config *red_cfg, > @@ -200,7 +201,7 @@ static void rte_red_set_avg_int(const struct > rte_red_config *red_cfg, > /** > * scale by n and convert from integer to fixed-point > */ > - red->avg = avg << (RTE_RED_SCALING + red_cfg->wq_log2); > + red->avg = avg << (rte_red_scaling + red_cfg->wq_log2); > } > > static double calc_exp_avg_on_empty(double avg, uint32_t n, uint32_t > time_diff) > @@ -280,10 +281,23 @@ static enum test_result > test_rte_red_init(struct test_config *tcfg) > { > unsigned i = 0; > + int ret; > > tcfg->tvar->clk_freq = rte_get_timer_hz(); > init_port_ts( tcfg->tvar->clk_freq ); > > + rte_red_reset_scaling(); > + ret = rte_red_set_scaling(tcfg->tconfig->max_queue_len); > + if (ret) { > + printf("rte_red_set_scaling failed: %d\n", ret); > + return FAIL; > + } > + if (rte_red_max_threshold < tcfg->tconfig->max_th) { > + printf("rte_red_max_th (%u) < tconfig->max_th (%u)\n", > + rte_red_max_threshold, tcfg->tconfig->max_th); > + return FAIL; > + } > + > for (i = 0; i < tcfg->tconfig->num_cfg; i++) { > if (rte_red_config_init(&tcfg->tconfig->rconfig[i], > (uint16_t)tcfg->tconfig->wq_log2[i], > @@ -385,6 +399,7 @@ static struct test_rte_red_config ft_tconfig = { > .min_th = 32, > .max_th = 128, > .maxp_inv = ft_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_queue ft_tqueue = { > @@ -554,6 +569,7 @@ static struct test_rte_red_config ft2_tconfig = { > .min_th = 32, > .max_th = 128, > .maxp_inv = ft2_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_config func_test2_config = { > @@ -576,6 +592,41 @@ static struct test_config func_test2_config = { > .tlevel = ft2_tlevel, > }; > > +/** > + * Test F2: functional test 2 - with long queues and smaller red-scaling > factor > + */ > +static uint32_t ft2_tlevel_scaling[] = {8190}; > + > +static struct test_rte_red_config ft2_tconfig_scaling = { > + .rconfig = ft2_rconfig, > + .num_cfg = RTE_DIM(ft2_rconfig), > + .wq_log2 = ft2_wq_log2, > + .min_th = 32, > + .max_th = 8191, > + .maxp_inv = ft2_maxp_inv, > + .max_queue_len = 8192, > +}; > + > +static struct test_config func_test2_config_scaling = { > + .ifname = "functional test 2 interface", > + .msg = "functional test 2 : use several RED configurations and long > queues,\n" > + " increase average queue size to just below > maximum threshold,\n" > + " compare drop rate to drop probability\n\n", > + .htxt = "RED config " > + "avg queue size " > + "min threshold " > + "max threshold " > + "drop prob % " > + "drop rate % " > + "diff % " > + "tolerance % " > + "\n", > + .tconfig = &ft2_tconfig_scaling, > + .tqueue = &ft_tqueue, > + .tvar = &ft_tvar, > + .tlevel = ft2_tlevel_scaling, > +}; > + > static enum test_result func_test2(struct test_config *tcfg) > { > enum test_result result = PASS; > @@ -662,6 +713,7 @@ static struct test_rte_red_config ft3_tconfig = { > .min_th = 32, > .max_th = 1023, > .maxp_inv = ft_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_config func_test3_config = { > @@ -683,6 +735,40 @@ static struct test_config func_test3_config = { > .tlevel = ft3_tlevel, > }; > > +/** > + * Test F3: functional test 3 - with large queues and smaller red scaling > factor > + */ > +static uint32_t ft3_tlevel_scaling[] = {8190}; > + > +static struct test_rte_red_config ft3_tconfig_scaling = { > + .rconfig = ft_wrconfig, > + .num_cfg = RTE_DIM(ft_wrconfig), > + .wq_log2 = ft_wq_log2, > + .min_th = 32, > + .max_th = 8191, > + .maxp_inv = ft_maxp_inv, > + .max_queue_len = 8192, > +}; > + > +static struct test_config func_test3_config_scaling = { > + .ifname = "functional test 3 interface", > + .msg = "functional test 3 : use one RED configuration and long > queues,\n" > + " increase average queue size to target level,\n" > + " dequeue all packets until queue is empty,\n" > + " confirm that average queue size is computed > correctly while queue is empty\n\n", > + .htxt = "q avg before " > + "q avg after " > + "expected " > + "difference % " > + "tolerance % " > + "result " > + "\n", > + .tconfig = &ft3_tconfig_scaling, > + .tqueue = &ft_tqueue, > + .tvar = &ft_tvar, > + .tlevel = ft3_tlevel_scaling, > +}; > + > static enum test_result func_test3(struct test_config *tcfg) > { > enum test_result result = PASS; > @@ -776,6 +862,7 @@ static struct test_rte_red_config ft4_tconfig = { > .max_th = 1023, > .wq_log2 = ft4_wq_log2, > .maxp_inv = ft_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_queue ft4_tqueue = { > @@ -810,6 +897,42 @@ static struct test_config func_test4_config = { > .tlevel = ft4_tlevel, > }; > > +/** > + * Test F4: functional test 4 > + */ > +static uint32_t ft4_tlevel_scaling[] = {8190}; > + > +static struct test_rte_red_config ft4_tconfig_scaling = { > + .rconfig = ft_wrconfig, > + .num_cfg = RTE_DIM(ft_wrconfig), > + .min_th = 32, > + .max_th = 8191, > + .wq_log2 = ft4_wq_log2, > + .maxp_inv = ft_maxp_inv, > + .max_queue_len = 8192, > +}; > + > +static struct test_config func_test4_config_scaling = { > + .ifname = "functional test 4 interface", > + .msg = "functional test 4 : use one RED configuration on long > queue,\n" > + " increase average queue size to target level,\n" > + " dequeue all packets until queue is empty,\n" > + " confirm that average queue size is computed > correctly while\n" > + " queue is empty for more than 50 sec,\n" > + " (this test takes 52 sec to run)\n\n", > + .htxt = "q avg before " > + "q avg after " > + "expected " > + "difference % " > + "tolerance % " > + "result " > + "\n", > + .tconfig = &ft4_tconfig_scaling, > + .tqueue = &ft4_tqueue, > + .tvar = &ft_tvar, > + .tlevel = ft4_tlevel_scaling, > +}; > + > static enum test_result func_test4(struct test_config *tcfg) > { > enum test_result result = PASS; > @@ -924,6 +1047,7 @@ static struct test_rte_red_config ft5_tconfig = { > .max_th = 128, > .wq_log2 = ft5_wq_log2, > .maxp_inv = ft5_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_queue ft5_tqueue = { > @@ -970,6 +1094,45 @@ static struct test_config func_test5_config = { > .tlevel = ft5_tlevel, > }; > > + > +/** > + * Test F5: functional test 5 > + */ > +static uint32_t ft5_tlevel_scaling[] = {8190}; > + > +static struct test_rte_red_config ft5_tconfig_scaling = { > + .rconfig = ft5_config, > + .num_cfg = RTE_DIM(ft5_config), > + .min_th = 32, > + .max_th = 8191, > + .wq_log2 = ft5_wq_log2, > + .maxp_inv = ft5_maxp_inv, > + .max_queue_len = 8192, > +}; > + > +static struct test_config func_test5_config_scaling = { > + .ifname = "functional test 5 interface", > + .msg = "functional test 5 : use several long queues (each with its > own run-time data),\n" > + " use several RED configurations (such that each > configuration is shared by multiple queues),\n" > + " increase average queue size to just below > maximum threshold,\n" > + " compare drop rate to drop probability,\n" > + " (this is a larger scale version of functional test > 2)\n\n", > + .htxt = "queue " > + "config " > + "avg queue size " > + "min threshold " > + "max threshold " > + "drop prob % " > + "drop rate % " > + "diff % " > + "tolerance % " > + "\n", > + .tconfig = &ft5_tconfig_scaling, > + .tqueue = &ft5_tqueue, > + .tvar = &ft5_tvar, > + .tlevel = ft5_tlevel_scaling, > +}; > + > static enum test_result func_test5(struct test_config *tcfg) > { > enum test_result result = PASS; > @@ -1062,6 +1225,7 @@ static struct test_rte_red_config ft6_tconfig = { > .max_th = 1023, > .wq_log2 = ft6_wq_log2, > .maxp_inv = ft6_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_queue ft6_tqueue = { > @@ -1078,7 +1242,7 @@ static struct test_queue ft6_tqueue = { > static struct test_config func_test6_config = { > .ifname = "functional test 6 interface", > .msg = "functional test 6 : use several queues (each with its own > run-time data),\n" > - " use several RED configurations (such that each > configuration is sharte_red by multiple queues),\n" > + " use several RED configurations (such that each > configuration is shared by multiple queues),\n" > " increase average queue size to target level,\n" > " dequeue all packets until queue is empty,\n" > " confirm that average queue size is computed > correctly while queue is empty\n" > @@ -1097,6 +1261,44 @@ static struct test_config func_test6_config = { > .tlevel = ft6_tlevel, > }; > > +/** > + * Test F6: functional test 6 > + */ > +static uint32_t ft6_tlevel_scaling[] = {8190}; > + > +static struct test_rte_red_config ft6_tconfig_scaling = { > + .rconfig = ft6_config, > + .num_cfg = RTE_DIM(ft6_config), > + .min_th = 32, > + .max_th = 8191, > + .wq_log2 = ft6_wq_log2, > + .maxp_inv = ft6_maxp_inv, > + .max_queue_len = 8192, > +}; > + > +static struct test_config func_test6_config_scaling = { > + .ifname = "functional test 6 interface", > + .msg = "functional test 6 : use several long queues (each with its > own run-time data),\n" > + " use several RED configurations (such that each > configuration is shared by multiple queues),\n" > + " increase average queue size to target level,\n" > + " dequeue all packets until queue is empty,\n" > + " confirm that average queue size is computed > correctly while queue is empty\n" > + " (this is a larger scale version of functional test > 3)\n\n", > + .htxt = "queue " > + "config " > + "q avg before " > + "q avg after " > + "expected " > + "difference % " > + "tolerance % " > + "result " > + "\n", > + .tconfig = &ft6_tconfig_scaling, > + .tqueue = &ft6_tqueue, > + .tvar = &ft_tvar, > + .tlevel = ft6_tlevel_scaling, > +}; > + > static enum test_result func_test6(struct test_config *tcfg) > { > enum test_result result = PASS; > @@ -1195,6 +1397,7 @@ static struct test_rte_red_config pt_tconfig = { > .min_th = 32, > .max_th = 128, > .maxp_inv = pt_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_queue pt_tqueue = { > @@ -1557,6 +1760,7 @@ static struct test_rte_red_config ovfl_tconfig = { > .min_th = 32, > .max_th = 1023, > .maxp_inv = ovfl_maxp_inv, > + .max_queue_len = RTE_RED_DEFAULT_QUEUE_LENGTH, > }; > > static struct test_queue ovfl_tqueue = { > @@ -1598,7 +1802,7 @@ static struct test_config ovfl_test1_config = { > .ifname = "queue avergage overflow test interface", > .msg = "overflow test 1 : use one RED configuration,\n" > " increase average queue size to target level,\n" > - " check maximum number of bits requirte_red to > represent avg_s\n\n", > + " check maximum number of bits required to > represent avg_s\n\n", > .htxt = "avg queue size " > "wq_log2 " > "fraction bits " > @@ -1615,6 +1819,39 @@ static struct test_config ovfl_test1_config = { > .tlevel = ovfl_tlevel, > }; > > +static uint32_t ovfl_tlevel_scaling[] = {8191}; > + > +static struct test_rte_red_config ovfl_tconfig_scaling = { > + .rconfig = ovfl_wrconfig, > + .num_cfg = RTE_DIM(ovfl_wrconfig), > + .wq_log2 = ovfl_wq_log2, > + .min_th = 32, > + .max_th = 8191, > + .maxp_inv = ovfl_maxp_inv, > + .max_queue_len = 8192, > +}; > + > +static struct test_config ovfl_test1_config_scaling = { > + .ifname = "queue average overflow test interface", > + .msg = "overflow test 1 on long queue: use one RED > configuration,\n" > + " increase average queue size to target level,\n" > + " check maximum number of bits required to > represent avg_s\n\n", > + .htxt = "avg queue size " > + "wq_log2 " > + "fraction bits " > + "max queue avg " > + "num bits " > + "enqueued " > + "dropped " > + "drop prob % " > + "drop rate % " > + "\n", > + .tconfig = &ovfl_tconfig_scaling, > + .tqueue = &ovfl_tqueue, > + .tvar = &ovfl_tvar, > + .tlevel = ovfl_tlevel_scaling, > +}; > + > static enum test_result ovfl_test1(struct test_config *tcfg) > { > enum test_result result = PASS; > @@ -1690,7 +1927,7 @@ static enum test_result ovfl_test1(struct > test_config *tcfg) > printf("%s", tcfg->htxt); > > printf("%-16u%-9u%-15u0x%08x %-10u%-10u%-10u%-13.2lf%- > 13.2lf\n", > - avg, *tcfg->tconfig->wq_log2, RTE_RED_SCALING, > + avg, *tcfg->tconfig->wq_log2, rte_red_scaling, > avg_max, avg_max_bits, > *tcfg->tvar->enqueued, *tcfg->tvar->dropped, > drop_prob * 100.0, drop_rate * 100.0); > @@ -1730,6 +1967,15 @@ struct tests perf_tests[] = { > { &perf2_test6_config, perf2_test }, > }; > > +struct tests scale_tests[] = { > + { &func_test2_config_scaling, func_test2 }, > + { &func_test3_config_scaling, func_test3 }, > + { &func_test4_config_scaling, func_test4 }, > + { &func_test5_config_scaling, func_test5 }, > + { &func_test6_config_scaling, func_test6 }, > + { &ovfl_test1_config_scaling, ovfl_test1 }, > +}; > + > /** > * function to execute the required_red tests > */ > @@ -1866,6 +2112,20 @@ test_red_perf(void) > } > > static int > +test_red_scaling(void) > +{ > + uint32_t num_tests = 0; > + uint32_t num_pass = 0; > + > + if (test_invalid_parameters() < 0) > + return -1; > + > + run_tests(scale_tests, RTE_DIM(scale_tests), &num_tests, > &num_pass); > + show_stats(num_tests, num_pass); > + return tell_the_result(num_tests, num_pass); > +} > + > +static int > test_red_all(void) > { > uint32_t num_tests = 0; > @@ -1876,10 +2136,12 @@ test_red_all(void) > > run_tests(func_tests, RTE_DIM(func_tests), &num_tests, > &num_pass); > run_tests(perf_tests, RTE_DIM(perf_tests), &num_tests, > &num_pass); > + run_tests(scale_tests, RTE_DIM(scale_tests), &num_tests, > &num_pass); > show_stats(num_tests, num_pass); > return tell_the_result(num_tests, num_pass); > } > > REGISTER_TEST_COMMAND(red_autotest, test_red); > REGISTER_TEST_COMMAND(red_perf, test_red_perf); > +REGISTER_TEST_COMMAND(red_scaling, test_red_scaling); > REGISTER_TEST_COMMAND(red_all, test_red_all); > -- > 2.1.4 Regards, Cristian
