[ceph.git] / ceph / src / spdk / dpdk / test / test / test_meter.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>

#include "test.h"

#include <rte_cycles.h>
#include <rte_meter.h>

#define mlog(format, ...) do{\
		printf("Line %d:",__LINE__);\
		printf(format, ##__VA_ARGS__);\
		printf("\n");\
	}while(0);

#define melog(format, ...) do{\
		printf("Line %d:",__LINE__);\
		printf(format, ##__VA_ARGS__);\
		printf(" failed!\n");\
		return -1;\
	}while(0);

#define TM_TEST_SRTCM_CIR_DF 46000000
#define TM_TEST_SRTCM_CBS_DF 2048
#define TM_TEST_SRTCM_EBS_DF 4096

#define TM_TEST_TRTCM_CIR_DF 46000000
#define TM_TEST_TRTCM_PIR_DF 69000000
#define TM_TEST_TRTCM_CBS_DF 2048
#define TM_TEST_TRTCM_PBS_DF 4096

static struct rte_meter_srtcm_params sparams =
				{.cir = TM_TEST_SRTCM_CIR_DF,
				 .cbs = TM_TEST_SRTCM_CBS_DF,
				 .ebs = TM_TEST_SRTCM_EBS_DF,};

static struct	rte_meter_trtcm_params tparams=
				{.cir = TM_TEST_TRTCM_CIR_DF,
				 .pir = TM_TEST_TRTCM_PIR_DF,
				 .cbs = TM_TEST_TRTCM_CBS_DF,
				 .pbs = TM_TEST_TRTCM_PBS_DF,};

/**
 * functional test for rte_meter_srtcm_config
 */
static inline int
tm_test_srtcm_config(void)
{
#define SRTCM_CFG_MSG "srtcm_config"
	struct rte_meter_srtcm_profile sp;
	struct  rte_meter_srtcm_params sparams1;

	/* invalid parameter test */
	if (rte_meter_srtcm_profile_config(NULL, NULL) == 0)
		melog(SRTCM_CFG_MSG);
	if (rte_meter_srtcm_profile_config(&sp, NULL) == 0)
		melog(SRTCM_CFG_MSG);
	if (rte_meter_srtcm_profile_config(NULL, &sparams) == 0)
		melog(SRTCM_CFG_MSG);

	/* cbs and ebs can't both be zero */
	sparams1 = sparams;
	sparams1.cbs = 0;
	sparams1.ebs = 0;
	if (rte_meter_srtcm_profile_config(&sp, &sparams1) == 0)
		melog(SRTCM_CFG_MSG);

	/* cir should never be 0 */
	sparams1 = sparams;
	sparams1.cir = 0;
	if (rte_meter_srtcm_profile_config(&sp, &sparams1) == 0)
		melog(SRTCM_CFG_MSG);

	/* one of ebs and cbs can be zero, should be successful */
	sparams1 = sparams;
	sparams1.ebs = 0;
	if (rte_meter_srtcm_profile_config(&sp, &sparams1) != 0)
		melog(SRTCM_CFG_MSG);

	sparams1 = sparams;
	sparams1.cbs = 0;
	if (rte_meter_srtcm_profile_config(&sp, &sparams1) != 0)
		melog(SRTCM_CFG_MSG);

	/* usual parameter, should be successful */
	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_CFG_MSG);

	return 0;

}

/**
 * functional test for rte_meter_trtcm_config
 */
static inline int
tm_test_trtcm_config(void)
{
	struct rte_meter_trtcm_profile tp;
	struct  rte_meter_trtcm_params tparams1;
#define TRTCM_CFG_MSG "trtcm_config"

	/* invalid parameter test */
	if (rte_meter_trtcm_profile_config(NULL, NULL) == 0)
		melog(TRTCM_CFG_MSG);
	if (rte_meter_trtcm_profile_config(&tp, NULL) == 0)
		melog(TRTCM_CFG_MSG);
	if (rte_meter_trtcm_profile_config(NULL, &tparams) == 0)
		melog(TRTCM_CFG_MSG);

	/* cir, cbs, pir and pbs never be zero */
	tparams1 = tparams;
	tparams1.cir = 0;
	if (rte_meter_trtcm_profile_config(&tp, &tparams1) == 0)
		melog(TRTCM_CFG_MSG);

	tparams1 = tparams;
	tparams1.cbs = 0;
	if (rte_meter_trtcm_profile_config(&tp, &tparams1) == 0)
		melog(TRTCM_CFG_MSG);

	tparams1 = tparams;
	tparams1.pbs = 0;
	if (rte_meter_trtcm_profile_config(&tp, &tparams1) == 0)
		melog(TRTCM_CFG_MSG);

	tparams1 = tparams;
	tparams1.pir = 0;
	if (rte_meter_trtcm_profile_config(&tp, &tparams1) == 0)
		melog(TRTCM_CFG_MSG);

	/* pir should be greater or equal to cir */
	tparams1 = tparams;
	tparams1.pir = tparams1.cir - 1;
	if (rte_meter_trtcm_profile_config(&tp, &tparams1) == 0)
		melog(TRTCM_CFG_MSG" pir < cir test");

	/* usual parameter, should be successful */
	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_CFG_MSG);

	return 0;
}

/**
 * functional test for rte_meter_srtcm_color_blind_check
 */
static inline int
tm_test_srtcm_color_blind_check(void)
{
#define SRTCM_BLIND_CHECK_MSG "srtcm_blind_check"
	struct rte_meter_srtcm_profile sp;
	struct rte_meter_srtcm sm;
	uint64_t time;
	uint64_t hz = rte_get_tsc_hz();

	/* Test green */
	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_blind_check(
		&sm, &sp, time, TM_TEST_SRTCM_CBS_DF - 1)
		!= e_RTE_METER_GREEN)
		melog(SRTCM_BLIND_CHECK_MSG" GREEN");

	/* Test yellow */
	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_blind_check(
		&sm, &sp, time, TM_TEST_SRTCM_CBS_DF + 1)
		!= e_RTE_METER_YELLOW)
		melog(SRTCM_BLIND_CHECK_MSG" YELLOW");

	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_blind_check(
		&sm, &sp, time, (uint32_t)sp.ebs - 1) != e_RTE_METER_YELLOW)
		melog(SRTCM_BLIND_CHECK_MSG" YELLOW");

	/* Test red */
	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_blind_check(
		&sm, &sp, time, TM_TEST_SRTCM_EBS_DF + 1)
		!= e_RTE_METER_RED)
		melog(SRTCM_BLIND_CHECK_MSG" RED");

	return 0;

}

/**
 * functional test for rte_meter_trtcm_color_blind_check
 */
static inline int
tm_test_trtcm_color_blind_check(void)
{
#define TRTCM_BLIND_CHECK_MSG "trtcm_blind_check"

	uint64_t time;
	struct rte_meter_trtcm_profile tp;
	struct rte_meter_trtcm tm;
	uint64_t hz = rte_get_tsc_hz();

	/* Test green */
	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_blind_check(
		&tm, &tp, time, TM_TEST_TRTCM_CBS_DF - 1)
		!= e_RTE_METER_GREEN)
		melog(TRTCM_BLIND_CHECK_MSG" GREEN");

	/* Test yellow */
	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_blind_check(
		&tm, &tp, time, TM_TEST_TRTCM_CBS_DF + 1)
		!= e_RTE_METER_YELLOW)
		melog(TRTCM_BLIND_CHECK_MSG" YELLOW");

	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_blind_check(
		&tm, &tp, time, TM_TEST_TRTCM_PBS_DF - 1)
		!= e_RTE_METER_YELLOW)
		melog(TRTCM_BLIND_CHECK_MSG" YELLOW");

	/* Test red */
	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_BLIND_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_blind_check(
		&tm, &tp, time, TM_TEST_TRTCM_PBS_DF + 1)
		!= e_RTE_METER_RED)
		melog(TRTCM_BLIND_CHECK_MSG" RED");

	return 0;
}


/**
 * @in[4] : the flags packets carries.
 * @in[4] : the flags function expect to return.
 * It will do blind check at the time of 1 second from beginning.
 * At the time, it will use packets length of cbs -1, cbs + 1,
 * ebs -1 and ebs +1 with flag in[0], in[1], in[2] and in[3] to do
 * aware check, expect flag out[0], out[1], out[2] and out[3]
 */

static inline int
tm_test_srtcm_aware_check
(enum rte_meter_color in[4], enum rte_meter_color out[4])
{
#define SRTCM_AWARE_CHECK_MSG "srtcm_aware_check"
	struct rte_meter_srtcm_profile sp;
	struct rte_meter_srtcm sm;
	uint64_t time;
	uint64_t hz = rte_get_tsc_hz();

	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_aware_check(
		&sm, &sp, time, TM_TEST_SRTCM_CBS_DF - 1, in[0]) != out[0])
		melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[0], out[0]);

	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_aware_check(
		&sm, &sp, time, TM_TEST_SRTCM_CBS_DF + 1, in[1]) != out[1])
		melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[1], out[1]);

	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_aware_check(
		&sm, &sp, time, TM_TEST_SRTCM_EBS_DF - 1, in[2]) != out[2])
		melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[2], out[2]);

	if (rte_meter_srtcm_profile_config(&sp, &sparams) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	if (rte_meter_srtcm_config(&sm, &sp) != 0)
		melog(SRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_srtcm_color_aware_check(
		&sm, &sp, time, TM_TEST_SRTCM_EBS_DF + 1, in[3]) != out[3])
		melog(SRTCM_AWARE_CHECK_MSG" %u:%u", in[3], out[3]);

	return 0;
}


/**
 * functional test for rte_meter_srtcm_color_aware_check
 */
static inline int
tm_test_srtcm_color_aware_check(void)
{
	enum rte_meter_color in[4], out[4];

	/**
	  * test 4 points that will produce green, yellow, yellow, red flag
	  * if using blind check
	  */

	/* previouly have a green, test points should keep unchanged */
	in[0] = in[1] = in[2] = in[3] = e_RTE_METER_GREEN;
	out[0] = e_RTE_METER_GREEN;
	out[1] = e_RTE_METER_YELLOW;
	out[2] = e_RTE_METER_YELLOW;
	out[3] = e_RTE_METER_RED;
	if (tm_test_srtcm_aware_check(in, out) != 0)
		return -1;

	/**
	  * previously have a yellow, green & yellow = yellow
	  * yellow & red = red
	  */
	in[0] = in[1] = in[2] = in[3] = e_RTE_METER_YELLOW;
	out[0] = e_RTE_METER_YELLOW;
	out[1] = e_RTE_METER_YELLOW;
	out[2] = e_RTE_METER_YELLOW;
	out[3] = e_RTE_METER_RED;
	if (tm_test_srtcm_aware_check(in, out) != 0)
		return -1;

	/**
	  * previously have a red, red & green = red
	  * red & yellow = red
	  */
	in[0] = in[1] = in[2] = in[3] = e_RTE_METER_RED;
	out[0] = e_RTE_METER_RED;
	out[1] = e_RTE_METER_RED;
	out[2] = e_RTE_METER_RED;
	out[3] = e_RTE_METER_RED;
	if (tm_test_srtcm_aware_check(in, out) != 0)
		return -1;

	return 0;
}

/**
 * @in[4] : the flags packets carries.
 * @in[4] : the flags function expect to return.
 * It will do blind check at the time of 1 second from beginning.
 * At the time, it will use packets length of cbs -1, cbs + 1,
 * ebs -1 and ebs +1 with flag in[0], in[1], in[2] and in[3] to do
 * aware check, expect flag out[0], out[1], out[2] and out[3]
 */
static inline int
tm_test_trtcm_aware_check
(enum rte_meter_color in[4], enum rte_meter_color out[4])
{
#define TRTCM_AWARE_CHECK_MSG "trtcm_aware_check"
	struct rte_meter_trtcm_profile tp;
	struct rte_meter_trtcm tm;
	uint64_t time;
	uint64_t hz = rte_get_tsc_hz();

	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_aware_check(
		&tm, &tp, time, TM_TEST_TRTCM_CBS_DF - 1, in[0]) != out[0])
		melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[0], out[0]);

	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_aware_check(
		&tm, &tp, time, TM_TEST_TRTCM_CBS_DF + 1, in[1]) != out[1])
		melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[1], out[1]);

	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_aware_check(
		&tm, &tp, time, TM_TEST_TRTCM_PBS_DF - 1, in[2]) != out[2])
		melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[2], out[2]);

	if (rte_meter_trtcm_profile_config(&tp, &tparams) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	if (rte_meter_trtcm_config(&tm, &tp) != 0)
		melog(TRTCM_AWARE_CHECK_MSG);
	time = rte_get_tsc_cycles() + hz;
	if (rte_meter_trtcm_color_aware_check(
		&tm, &tp, time, TM_TEST_TRTCM_PBS_DF + 1, in[3]) != out[3])
		melog(TRTCM_AWARE_CHECK_MSG" %u:%u", in[3], out[3]);

	return 0;
}


/**
 * functional test for rte_meter_trtcm_color_aware_check
 */

static inline int
tm_test_trtcm_color_aware_check(void)
{
	enum rte_meter_color in[4], out[4];
	/**
	  * test 4 points that will produce green, yellow, yellow, red flag
	  * if using blind check
	  */

	/* previouly have a green, test points should keep unchanged */
	in[0] = in[1] = in[2] = in[3] = e_RTE_METER_GREEN;
	out[0] = e_RTE_METER_GREEN;
	out[1] = e_RTE_METER_YELLOW;
	out[2] = e_RTE_METER_YELLOW;
	out[3] = e_RTE_METER_RED;
	if (tm_test_trtcm_aware_check(in, out) != 0)
		return -1;

	in[0] = in[1] = in[2] = in[3] = e_RTE_METER_YELLOW;
	out[0] = e_RTE_METER_YELLOW;
	out[1] = e_RTE_METER_YELLOW;
	out[2] = e_RTE_METER_YELLOW;
	out[3] = e_RTE_METER_RED;
	if (tm_test_trtcm_aware_check(in, out) != 0)
		return -1;

	in[0] = in[1] = in[2] = in[3] = e_RTE_METER_RED;
	out[0] = e_RTE_METER_RED;
	out[1] = e_RTE_METER_RED;
	out[2] = e_RTE_METER_RED;
	out[3] = e_RTE_METER_RED;
	if (tm_test_trtcm_aware_check(in, out) != 0)
		return -1;

	return 0;
}

/**
 * test main entrance for library meter
 */
static int
test_meter(void)
{
	if (tm_test_srtcm_config() != 0)
		return -1;

	if (tm_test_trtcm_config() != 0)
		return -1;

	if (tm_test_srtcm_color_blind_check() != 0)
		return -1;

	if (tm_test_trtcm_color_blind_check() != 0)
		return -1;

	if (tm_test_srtcm_color_aware_check() != 0)
		return -1;

	if (tm_test_trtcm_color_aware_check() != 0)
		return -1;

	return 0;

}

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