static void test_brick_pkts_count_west(void)
{
TEST_PKTS_COUNT_INIT();
unsigned int pkts_count;
int j;
for (j = 0, pkts_count = NB_PKTS; j < NB_LOOP;
++j, pkts_count += NB_PKTS) {
pg_brick_burst_to_west(brick, 0, pkts,
pg_mask_firsts(NB_PKTS), &error);
g_assert(!error);
g_assert(pg_brick_pkts_count_get(collect_east, WEST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_east, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_west,
WEST_SIDE) == pkts_count);
g_assert(pg_brick_pkts_count_get(collect_west, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(brick, WEST_SIDE) == pkts_count);
g_assert(pg_brick_pkts_count_get(brick, EAST_SIDE) == 0);
TEST_PKTS_COUNT_CHECK(pg_brick_west_burst_get, collect_west, 0);
TEST_PKTS_COUNT_CHECK(pg_brick_east_burst_get, collect_west, 3);
TEST_PKTS_COUNT_CHECK(pg_brick_west_burst_get, collect_east, 0);
TEST_PKTS_COUNT_CHECK(pg_brick_east_burst_get, collect_east, 0);
}
TEST_PKTS_COUNT_DESTROY();
}
static void test_brick_flow_west(void)
{
struct pg_brick_config *config = pg_brick_config_new("mybrick", 4, 4);
struct pg_brick *brick1, *brick2, *collect_west, *collect_east;
struct rte_mbuf mbufs[NB_PKTS];
struct rte_mbuf **result_pkts;
struct rte_mbuf *pkts[NB_PKTS];
uint16_t i;
uint64_t pkts_mask;
struct pg_error *error = NULL;
/* prepare the packets to send */
for (i = 0; i < NB_PKTS; i++) {
mbufs[i].udata64 = i;
pkts[i] = &mbufs[i];
}
/* create a chain of a few nop brick with collectors on each sides */
brick1 = pg_brick_new("nop", config, &error);
g_assert(!error);
brick2 = pg_brick_new("nop", config, &error);
g_assert(!error);
collect_west = pg_brick_new("collect", config, &error);
g_assert(!error);
g_assert(collect_west);
collect_east = pg_brick_new("collect", config, &error);
g_assert(!error);
g_assert(collect_east);
pg_brick_link(collect_west, brick1, &error);
g_assert(!error);
pg_brick_link(brick1, brick2, &error);
g_assert(!error);
pg_brick_link(brick2, collect_east, &error);
g_assert(!error);
/* send a pkts to the west from the eastest nope brick */
pg_brick_burst_to_west(brick2, 0, pkts, NB_PKTS,
pg_mask_firsts(NB_PKTS), &error);
g_assert(!error);
/* check pkts counter */
g_assert(pg_brick_pkts_count_get(collect_east, WEST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_east, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(collect_west, WEST_SIDE) == 3);
g_assert(pg_brick_pkts_count_get(collect_west, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(brick1, WEST_SIDE) == 3);
g_assert(pg_brick_pkts_count_get(brick1, EAST_SIDE) == 0);
g_assert(pg_brick_pkts_count_get(brick2, WEST_SIDE) == 3);
g_assert(pg_brick_pkts_count_get(brick2, EAST_SIDE) == 0);
/* check no packet ended on the east */
result_pkts = pg_brick_west_burst_get(collect_east, &pkts_mask, &error);
g_assert(!error);
g_assert(!pkts_mask);
g_assert(!result_pkts);
result_pkts = pg_brick_east_burst_get(collect_east, &pkts_mask, &error);
g_assert(!error);
g_assert(!pkts_mask);
g_assert(!result_pkts);
/* collect pkts on the west */
result_pkts = pg_brick_west_burst_get(collect_west, &pkts_mask, &error);
g_assert(!error);
g_assert(!pkts_mask);
g_assert(!result_pkts);
result_pkts = pg_brick_east_burst_get(collect_west, &pkts_mask, &error);
g_assert(!error);
g_assert(pkts_mask == pg_mask_firsts(NB_PKTS));
g_assert(result_pkts);
for (i = 0; i < NB_PKTS; i++)
g_assert(result_pkts[i]->udata64 == i);
/* break the chain */
pg_brick_unlink(brick1, &error);
g_assert(!error);
pg_brick_unlink(brick2, &error);
g_assert(!error);
pg_brick_unlink(collect_west, &error);
g_assert(!error);
pg_brick_unlink(collect_east, &error);
g_assert(!error);
/* destroy */
pg_brick_decref(brick1, &error);
g_assert(!error);
pg_brick_decref(brick2, &error);
g_assert(!error);
pg_brick_decref(collect_west, &error);
g_assert(!error);
pg_brick_decref(collect_east, &error);
g_assert(!error);
pg_brick_config_free(config);
}
static void test_icmp_pmtud(void)
{
struct pg_error *error = NULL;
struct pg_brick *pmtud;
struct pg_brick *col_east;
struct pg_brick *col_west;
/* struct pg_brick *print_east; */
/* struct pg_brick *print_west; */
/* FILE *east_file = fopen("east_file.pcap", "w+"); */
/* FILE *west_file = fopen("west_file.pcap", "w+"); */
struct rte_mbuf **pkts;
struct rte_mbuf *tmp;
uint64_t pkts_mask;
struct ether_addr eth_s = {{2}};
struct ether_addr eth_d = {{4}};
pkts = pg_packets_append_ether(pg_packets_create(pg_mask_firsts(64)),
pg_mask_firsts(64), ð_s, ð_d,
ETHER_TYPE_IPv4);
pg_packets_append_ipv4(pkts, pg_mask_firsts(64), 1, 2, 0, 0);
/* 10 caracter with the \0*/
pg_packets_append_str(pkts, pg_mask_firsts(64), "siegzeon ");
pg_packets_append_blank(pkts,
pg_mask_firsts(32),
421 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
pg_packets_append_blank(pkts,
pg_mask_firsts(64) & ~pg_mask_firsts(32),
420 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
/*
* [col_west] -- [print_west] -- [pmtud] -- [print_east] -- [col_east]
*/
pmtud = pg_pmtud_new("pmtud", PG_WEST_SIDE, 430, &error);
g_assert(!error);
col_east = pg_collect_new("col_east", &error);
g_assert(col_east);
g_assert(!error);
col_west = pg_collect_new("col_west", &error);
g_assert(!error);
g_assert(col_west);
/* print_east = pg_print_new("print_east", 1, 1, east_file, */
/* PG_PRINT_FLAG_PCAP, NULL, &error); */
/* g_assert(col_east); */
/* g_assert(!error); */
/* print_west = pg_print_new("print_west", 1, 1, west_file, */
/* PG_PRINT_FLAG_PCAP, NULL, &error); */
/* g_assert(!error); */
/* g_assert(col_west); */
/* pg_brick_chained_links(&error, col_west, print_west, pmtud, */
/* print_east, col_east); */
/* g_assert(!error); */
pg_brick_chained_links(&error, col_west, pmtud, col_east);
g_assert(!error);
pg_brick_burst_to_east(pmtud, 0, pkts, pg_mask_firsts(64), &error);
g_assert(!error);
pg_brick_west_burst_get(col_east, &pkts_mask, &error);
g_assert(!error);
g_assert(pg_mask_count(pkts_mask) == 32);
g_assert(pg_brick_pkts_count_get(pmtud, PG_EAST_SIDE) == 64);
g_assert(pg_brick_pkts_count_get(col_east, PG_EAST_SIDE) == 32);
g_assert(pg_brick_pkts_count_get(col_west, PG_WEST_SIDE) == 32);
tmp = pg_brick_east_burst_get(col_west, &pkts_mask, &error)[0];
g_assert(pkts_mask == 1);
g_assert(tmp);
pg_brick_destroy(col_west);
pg_brick_destroy(pmtud);
pg_brick_destroy(col_east);
pg_packets_free(pkts, pg_mask_firsts(64));
/* fclose(east_file); */
/* fclose(west_file); */
g_free(pkts);
return;
}
int pg_bench_run(struct pg_bench *bench, struct pg_bench_stats *result,
struct pg_error **error)
{
uint64_t bit;
uint64_t it_mask;
uint64_t i;
uint16_t cnt;
uint64_t pkts_burst;
struct pg_brick_side *side = NULL;
struct pg_brick *count_brick;
struct pg_bench bl;
if (bench == NULL || result == NULL ||
bench->pkts == NULL || bench->pkts_nb == 0 ||
bench->max_burst_cnt == 0 || bench->pkts_mask == 0) {
*error = pg_error_new("missing or bad bench parameters");
return -1;
}
/* Link ouput brick to a nop brick to count outcoming packets. */
if (bench->count_brick == NULL) {
count_brick = pg_nop_new("nop-bench", error);
if (*error)
return -1;
if (bench->output_side == WEST_SIDE)
pg_brick_link(count_brick, bench->output_brick, error);
else
pg_brick_link(bench->output_brick, count_brick, error);
if (*error)
return -1;
} else {
count_brick = bench->count_brick;
}
/* Set all stats to zero. */
memset(result, 0, sizeof(struct pg_bench_stats));
/* Setup callback to get burst count. */
pkts_burst = 0;
switch (bench->input_brick->type) {
case PG_MONOPOLE:
side = bench->input_brick->sides;
break;
case PG_DIPOLE:
case PG_MULTIPOLE:
side = &(bench->input_brick->sides
[pg_flip_side(bench->input_side)]);
break;
default:
g_assert(0);
break;
}
side->burst_count_cb = pg_bench_burst_cb;
side->burst_count_private_data = (void *)(&pkts_burst);
/* Compute average size of packets. */
it_mask = bench->pkts_mask;
for (; it_mask;) {
pg_low_bit_iterate_full(it_mask, bit, i);
result->pkts_average_size += bench->pkts[i]->data_len;
}
result->pkts_average_size /= bench->pkts_nb;
/* Let's run ! */
memcpy(&bl, bench, sizeof(struct pg_bench));
gettimeofday(&result->date_start, NULL);
for (i = 0; i < bl.max_burst_cnt; i++) {
/* Burst packets. */
pg_brick_burst(bl.input_brick,
bl.input_side,
0,
bl.pkts,
bl.pkts_mask,
error);
sched_yield();
if (*error)
return -1;
/* Poll back packets if needed. */
if (bl.output_poll)
pg_brick_poll(bl.output_brick, &cnt, error);
if (bl.post_burst_op)
bl.post_burst_op(bench);
}
gettimeofday(&result->date_end, NULL);
memcpy(bench, &bl, sizeof(struct pg_bench));
result->pkts_sent = bench->max_burst_cnt * bench->pkts_nb;
result->burst_cnt = bench->max_burst_cnt;
result->pkts_burst = pkts_burst;
result->pkts_received = pg_brick_pkts_count_get(
count_brick,
bench->output_side);
if (bench->count_brick == NULL) {
pg_brick_unlink(count_brick, error);
if (*error)
return -1;
}
return 0;
}
