static int nop_burst(struct pg_brick *brick, enum pg_side from,
uint16_t edge_index, struct rte_mbuf **pkts, uint16_t nb,
uint64_t pkts_mask, struct pg_error **errp)
{
struct pg_brick_side *s = &brick->sides[pg_flip_side(from)];
if (s->edge.link == NULL)
return 1;
return pg_brick_burst(s->edge.link, from,
s->edge.pair_index,
pkts, nb, pkts_mask, errp);
}
static void test_sorting_pmtud(void)
{
struct pg_error *error = NULL;
struct pg_brick *pmtud;
struct pg_brick *col_east;
struct rte_mbuf **pkts;
uint64_t pkts_mask;
struct ether_addr eth = {{0}};
pkts = pg_packets_append_ether(pg_packets_create(pg_mask_firsts(64)),
pg_mask_firsts(64), ð, ð,
ETHER_TYPE_IPv4);
pg_packets_append_ipv4(pkts, pg_mask_firsts(64), 1, 2, 0, 0);
pg_packets_append_blank(pkts,
pg_mask_firsts(32),
431 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
pg_packets_append_blank(pkts,
pg_mask_firsts(64) & ~pg_mask_firsts(32),
430 - sizeof(struct ipv4_hdr) -
sizeof(struct ether_hdr));
pmtud = pg_pmtud_new("pmtud", PG_WEST_SIDE, 430, &error);
g_assert(!error);
col_east = pg_collect_new("col_east", &error);
g_assert(!error);
pg_brick_link(pmtud, col_east, &error);
g_assert(!error);
pg_brick_burst(pmtud, PG_WEST_SIDE, 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);
pg_brick_destroy(pmtud);
pg_brick_destroy(col_east);
pg_packets_free(pkts, pg_mask_firsts(64));
g_free(pkts);
}
static void test_sorting_pmtud_df(void)
{
struct pg_error *error = NULL;
struct pg_brick *pmtud;
struct pg_brick *col_east;
struct rte_mbuf **pkts;
uint64_t pkts_mask;
struct ether_addr eth = {{0}};
uint64_t buff[4] = {0, 0, 0, 0};
pkts = pg_packets_append_ether(pg_packets_create(pg_mask_firsts(64)),
pg_mask_firsts(64), ð, ð,
ETHER_TYPE_IPv4);
pg_packets_append_ipv4(pkts, pg_mask_firsts(32), 1, 2, 0, 0);
/* Initialise ip header to 0, this ensure that DF flag is not set*/
pg_packets_append_buf(pkts,
pg_mask_firsts(64) & ~pg_mask_firsts(32),
buff, sizeof(uint64_t) * 4);
pg_packets_append_blank(pkts, pg_mask_firsts(64), 400);
pmtud = pg_pmtud_new("pmtud", PG_WEST_SIDE, 430, &error);
g_assert(!error);
col_east = pg_collect_new("col_east", &error);
g_assert(!error);
pg_brick_link(pmtud, col_east, &error);
g_assert(!error);
pg_brick_burst(pmtud, PG_WEST_SIDE, 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);
pg_brick_destroy(pmtud);
pg_brick_destroy(col_east);
pg_packets_free(pkts, pg_mask_firsts(64));
g_free(pkts);
}
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;
}
