This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "".
The branch, master has been updated via 807aa18bcd266a7e7f66e2293db7ee2fe4923a2d (commit) via 878ca435ac623687b4506e0ec3c6391566a31e3f (commit) via 4063f3df1a50ef2d41270eef7a1426f0fb451b8b (commit) via ad57370a0cb158aa87acb85e5004a42d73a82f06 (commit) via 44431af475b89d16b81dfcb92db27b03b7475b74 (commit) via f55749bb0598ba9447a9ed312782821c057ef3a4 (commit) via 76cf03d62e77c6eea7e67f66cde729e8f64a618f (commit) via df93cd4cdf73df1bc9d63161bab18db611041a5c (commit) via 4898f2ff2054c2365588baef44f64e4c67003a57 (commit) from 88deaa9611c7d16d8438b8b8c7732d74889fc4af (commit)
Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below.
- Log ----------------------------------------------------------------- commit 807aa18bcd266a7e7f66e2293db7ee2fe4923a2d Author: Petri Savolainen petri.savolainen@nokia.com Date: Fri Nov 15 10:39:46 2019 +0200
validation: packet: add max pools test
Test that maximum number of packet pools can be created. Suite init has created already one, so this test creates "max_pools - 1" pools more.
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index 47e20c049..90226819c 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -2554,6 +2554,70 @@ static void packet_test_ref(void) odp_packet_free(ref_pkt[1]); }
+static void packet_test_max_pools(void) +{ + odp_pool_param_t param; + uint32_t i, num_pool, num_pkt; + void *addr; + odp_event_t ev; + uint32_t len = 500; + /* Suite init has created one pool already */ + uint32_t max_pools = pool_capa.pkt.max_pools - 1; + odp_pool_t pool[max_pools]; + odp_packet_t packet[max_pools]; + + CU_ASSERT_FATAL(max_pools != 0); + + printf("\n Creating %u pools\n", max_pools); + + odp_pool_param_init(¶m); + param.type = ODP_POOL_PACKET; + param.pkt.len = len; + param.pkt.num = 1; + param.pkt.max_num = 1; + + for (i = 0; i < max_pools; i++) { + pool[i] = odp_pool_create(NULL, ¶m); + + if (pool[i] == ODP_POOL_INVALID) + break; + } + + num_pool = i; + + CU_ASSERT(num_pool == max_pools); + if (num_pool != max_pools) + printf("Error: created only %u pools\n", num_pool); + + for (i = 0; i < num_pool; i++) { + packet[i] = odp_packet_alloc(pool[i], len); + + if (packet[i] == ODP_PACKET_INVALID) + break; + + CU_ASSERT_FATAL(odp_packet_pool(packet[i]) == pool[i]); + + ev = odp_packet_to_event(packet[i]); + CU_ASSERT(odp_packet_from_event(ev) == packet[i]); + CU_ASSERT(odp_event_type(ev) == ODP_EVENT_PACKET); + + CU_ASSERT(odp_packet_len(packet[i]) == len); + addr = odp_packet_data(packet[i]); + + /* Write packet data */ + memset(addr, 0, len); + } + + num_pkt = i; + CU_ASSERT(num_pkt == num_pool); + + if (num_pkt) + odp_packet_free_multi(packet, num_pkt); + + for (i = 0; i < num_pool; i++) + CU_ASSERT(odp_pool_destroy(pool[i]) == 0); +} + static int packet_parse_suite_init(void) { int num_test_pkt, i; @@ -3493,6 +3557,7 @@ odp_testinfo_t packet_suite[] = { ODP_TEST_INFO(packet_test_align), ODP_TEST_INFO(packet_test_offset), ODP_TEST_INFO(packet_test_ref), + ODP_TEST_INFO(packet_test_max_pools), ODP_TEST_INFO_NULL, };
commit 878ca435ac623687b4506e0ec3c6391566a31e3f Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 15:46:55 2019 +0200
validation: packet: use common pool capability
Read pool capability in suite init and use it on all tests.
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index 777ea0dc7..47e20c049 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -12,7 +12,7 @@ #include <test_packet_parser.h>
/* Reserve some tailroom for tests */ -#define PACKET_TAILROOM_RESERVE 4 +#define TAILROOM_RESERVE 4 /* Number of packets in the test packet pool */ #define PACKET_POOL_NUM 300 /* Number of large, possibly segmented, test packets */ @@ -24,6 +24,7 @@ ODP_STATIC_ASSERT(PACKET_POOL_NUM_SEG > 1 && /* Number of packets in parse test */ #define PARSE_TEST_NUM_PKT 10
+static odp_pool_capability_t pool_capa; static odp_pool_param_t default_param; static odp_pool_t default_pool; static uint32_t packet_len; @@ -148,7 +149,6 @@ static int fill_data_backward(odp_packet_t pkt, uint32_t offset, uint32_t len, static int packet_suite_init(void) { odp_pool_param_t params; - odp_pool_capability_t capa; odp_packet_t pkt_tbl[PACKET_POOL_NUM_SEG]; struct udata_struct *udat; uint32_t udat_size; @@ -157,34 +157,36 @@ static int packet_suite_init(void) uint32_t num = PACKET_POOL_NUM; int ret;
- if (odp_pool_capability(&capa) < 0) { + memset(&pool_capa, 0, sizeof(odp_pool_capability_t)); + + if (odp_pool_capability(&pool_capa) < 0) { printf("pool_capability failed\n"); return -1; } - if (capa.pkt.max_segs_per_pkt == 0) - capa.pkt.max_segs_per_pkt = 10; + if (pool_capa.pkt.max_segs_per_pkt == 0) + pool_capa.pkt.max_segs_per_pkt = 10;
/* Pick a typical packet size and decrement it to the single segment * limit if needed (min_seg_len maybe equal to max_len * on some systems). */ packet_len = 512; - while (packet_len > (capa.pkt.min_seg_len - PACKET_TAILROOM_RESERVE)) + while (packet_len > (pool_capa.pkt.min_seg_len - TAILROOM_RESERVE)) packet_len--;
- if (capa.pkt.max_len) { - segmented_packet_len = capa.pkt.max_len; + if (pool_capa.pkt.max_len) { + segmented_packet_len = pool_capa.pkt.max_len; } else { - segmented_packet_len = capa.pkt.min_seg_len * - capa.pkt.max_segs_per_pkt; + segmented_packet_len = pool_capa.pkt.min_seg_len * + pool_capa.pkt.max_segs_per_pkt; } - if (capa.pkt.max_num != 0 && capa.pkt.max_num < num) - num = capa.pkt.max_num; + if (pool_capa.pkt.max_num != 0 && pool_capa.pkt.max_num < num) + num = pool_capa.pkt.max_num;
odp_pool_param_init(¶ms);
params.type = ODP_POOL_PACKET; - params.pkt.seg_len = capa.pkt.min_seg_len; - params.pkt.len = capa.pkt.min_seg_len; + params.pkt.seg_len = pool_capa.pkt.min_seg_len; + params.pkt.len = pool_capa.pkt.min_seg_len; params.pkt.num = num; params.pkt.uarea_size = sizeof(struct udata_struct);
@@ -216,11 +218,11 @@ static int packet_suite_init(void) if (ret != PACKET_POOL_NUM_SEG) { if (ret > 0) odp_packet_free_multi(pkt_tbl, ret); - segmented_packet_len -= capa.pkt.min_seg_len; + segmented_packet_len -= pool_capa.pkt.min_seg_len; continue; } } while (ret != PACKET_POOL_NUM_SEG && - segmented_packet_len > capa.pkt.min_seg_len); + segmented_packet_len > pool_capa.pkt.min_seg_len);
if (ret != PACKET_POOL_NUM_SEG) { printf("packet alloc failed\n"); @@ -281,16 +283,13 @@ static void packet_test_alloc_free(void) odp_pool_t pool; odp_packet_t packet; odp_pool_param_t params; - odp_pool_capability_t capa; odp_event_subtype_t subtype;
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - odp_pool_param_init(¶ms);
params.type = ODP_POOL_PACKET; - params.pkt.seg_len = capa.pkt.min_seg_len; - params.pkt.len = capa.pkt.min_seg_len; + params.pkt.seg_len = pool_capa.pkt.min_seg_len; + params.pkt.len = pool_capa.pkt.min_seg_len; params.pkt.num = 1;
pool = odp_pool_create("packet_pool_alloc", ¶ms); @@ -355,15 +354,12 @@ static void packet_test_alloc_free_multi(void) odp_packet_t packet[2 * num_pkt + 1]; odp_packet_t inval_pkt[num_pkt]; odp_pool_param_t params; - odp_pool_capability_t capa; - - CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0);
odp_pool_param_init(¶ms);
params.type = ODP_POOL_PACKET; - params.pkt.seg_len = capa.pkt.min_seg_len; - params.pkt.len = capa.pkt.min_seg_len; + params.pkt.seg_len = pool_capa.pkt.min_seg_len; + params.pkt.len = pool_capa.pkt.min_seg_len; params.pkt.num = num_pkt;
pool[0] = odp_pool_create("packet_pool_alloc_multi_0", ¶ms); @@ -432,13 +428,10 @@ static void packet_test_free_sp(void) int i, ret; odp_packet_t packet[num_pkt]; odp_pool_param_t params; - odp_pool_capability_t capa; uint32_t len = packet_len;
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - - if (capa.pkt.max_len < len) - len = capa.pkt.max_len; + if (pool_capa.pkt.max_len < len) + len = pool_capa.pkt.max_len;
odp_pool_param_init(¶ms);
@@ -477,26 +470,25 @@ static void packet_test_alloc_segmented(void) uint32_t max_len; odp_pool_t pool; odp_pool_param_t params; - odp_pool_capability_t capa; int ret, i, num_alloc;
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - if (capa.pkt.max_segs_per_pkt == 0) - capa.pkt.max_segs_per_pkt = 10; + if (pool_capa.pkt.max_segs_per_pkt == 0) + pool_capa.pkt.max_segs_per_pkt = 10;
- if (capa.pkt.max_len) - max_len = capa.pkt.max_len; + if (pool_capa.pkt.max_len) + max_len = pool_capa.pkt.max_len; else - max_len = capa.pkt.min_seg_len * capa.pkt.max_segs_per_pkt; + max_len = pool_capa.pkt.min_seg_len * + pool_capa.pkt.max_segs_per_pkt;
odp_pool_param_init(¶ms);
params.type = ODP_POOL_PACKET; - params.pkt.seg_len = capa.pkt.min_seg_len; + params.pkt.seg_len = pool_capa.pkt.min_seg_len; params.pkt.len = max_len;
/* Ensure that 'num' segmented packets can be allocated */ - params.pkt.num = num * capa.pkt.max_segs_per_pkt; + params.pkt.num = num * pool_capa.pkt.max_segs_per_pkt;
pool = odp_pool_create("pool_alloc_segmented", ¶ms); CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); @@ -629,9 +621,6 @@ static void packet_test_length(void) odp_packet_t pkt = test_packet; uint32_t buf_len, headroom, tailroom, seg_len; void *data; - odp_pool_capability_t capa; - - CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0);
buf_len = odp_packet_buf_len(pkt); headroom = odp_packet_headroom(pkt); @@ -643,8 +632,8 @@ static void packet_test_length(void) CU_ASSERT(odp_packet_seg_len(pkt) <= packet_len); CU_ASSERT(odp_packet_data_seg_len(pkt, &seg_len) == data); CU_ASSERT(seg_len == odp_packet_seg_len(pkt)); - CU_ASSERT(headroom >= capa.pkt.min_headroom); - CU_ASSERT(tailroom >= capa.pkt.min_tailroom); + CU_ASSERT(headroom >= pool_capa.pkt.min_headroom); + CU_ASSERT(tailroom >= pool_capa.pkt.min_tailroom);
CU_ASSERT(buf_len >= packet_len + headroom + tailroom); } @@ -874,14 +863,11 @@ static void packet_test_headroom(void) uint32_t room; uint32_t seg_data_len; uint32_t push_val, pull_val; - odp_pool_capability_t capa; - - CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); room = odp_packet_headroom(pkt);
- CU_ASSERT(room >= capa.pkt.min_headroom); + CU_ASSERT(room >= pool_capa.pkt.min_headroom);
seg_data_len = odp_packet_seg_len(pkt); CU_ASSERT(seg_data_len >= 1); @@ -995,16 +981,13 @@ static void packet_test_tailroom(void) uint32_t room; uint32_t seg_data_len; uint32_t push_val, pull_val; - odp_pool_capability_t capa; - - CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
segment = odp_packet_last_seg(pkt); CU_ASSERT(segment != ODP_PACKET_SEG_INVALID); room = odp_packet_tailroom(pkt); - CU_ASSERT(room >= capa.pkt.min_tailroom); + CU_ASSERT(room >= pool_capa.pkt.min_tailroom);
seg_data_len = odp_packet_seg_data_len(pkt, segment); CU_ASSERT(seg_data_len >= 1); @@ -1197,12 +1180,9 @@ static void packet_test_add_rem_data(void) void *usr_ptr; struct udata_struct *udat, *new_udat; int ret; - odp_pool_capability_t capa; uint32_t min_seg_len;
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - - min_seg_len = capa.pkt.min_seg_len; + min_seg_len = pool_capa.pkt.min_seg_len;
pkt = odp_packet_alloc(default_pool, packet_len); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); @@ -1609,7 +1589,6 @@ static void packet_test_concatsplit(void)
static void packet_test_concat_small(void) { - odp_pool_capability_t capa; odp_pool_t pool; odp_pool_param_t param; odp_packet_t pkt, pkt2; @@ -1619,10 +1598,8 @@ static void packet_test_concat_small(void) uint32_t len = PACKET_POOL_NUM / 4; uint8_t buf[len];
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - - if (capa.pkt.max_len && capa.pkt.max_len < len) - len = capa.pkt.max_len; + if (pool_capa.pkt.max_len && pool_capa.pkt.max_len < len) + len = pool_capa.pkt.max_len;
odp_pool_param_init(¶m);
@@ -1672,7 +1649,6 @@ static void packet_test_concat_small(void)
static void packet_test_concat_extend_trunc(void) { - odp_pool_capability_t capa; odp_pool_t pool; odp_pool_param_t param; odp_packet_t pkt, pkt2; @@ -1680,10 +1656,8 @@ static void packet_test_concat_extend_trunc(void) uint32_t alloc_len, ext_len, trunc_len, cur_len; uint32_t len = 1900;
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - - if (capa.pkt.max_len && capa.pkt.max_len < len) - len = capa.pkt.max_len; + if (pool_capa.pkt.max_len && pool_capa.pkt.max_len < len) + len = pool_capa.pkt.max_len;
alloc_len = len / 8; ext_len = len / 4; @@ -1760,7 +1734,6 @@ static void packet_test_concat_extend_trunc(void)
static void packet_test_extend_small(void) { - odp_pool_capability_t capa; odp_pool_t pool; odp_pool_param_t param; odp_packet_t pkt; @@ -1771,10 +1744,8 @@ static void packet_test_extend_small(void) uint32_t len = 32000; uint8_t buf[len];
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - - if (capa.pkt.max_len && capa.pkt.max_len < len) - len = capa.pkt.max_len; + if (pool_capa.pkt.max_len && pool_capa.pkt.max_len < len) + len = pool_capa.pkt.max_len;
odp_pool_param_init(¶m);
@@ -1852,7 +1823,6 @@ static void packet_test_extend_small(void)
static void packet_test_extend_large(void) { - odp_pool_capability_t capa; odp_pool_t pool; odp_pool_param_t param; odp_packet_t pkt; @@ -1865,10 +1835,8 @@ static void packet_test_extend_large(void) uint32_t len = 32000; uint8_t buf[len];
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - - if (capa.pkt.max_len && capa.pkt.max_len < len) - len = capa.pkt.max_len; + if (pool_capa.pkt.max_len && pool_capa.pkt.max_len < len) + len = pool_capa.pkt.max_len;
odp_pool_param_init(¶m);
@@ -1972,7 +1940,6 @@ static void packet_test_extend_large(void)
static void packet_test_extend_mix(void) { - odp_pool_capability_t capa; odp_pool_t pool; odp_pool_param_t param; odp_packet_t pkt; @@ -1984,10 +1951,8 @@ static void packet_test_extend_mix(void) uint32_t len = 32000; uint8_t buf[len];
- CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0); - - if (capa.pkt.max_len && capa.pkt.max_len < len) - len = capa.pkt.max_len; + if (pool_capa.pkt.max_len && pool_capa.pkt.max_len < len) + len = pool_capa.pkt.max_len;
odp_pool_param_init(¶m);
@@ -2088,9 +2053,6 @@ static void packet_test_extend_ref(void) { odp_packet_t max_pkt, ref; uint32_t hr, tr, max_len; - odp_pool_capability_t capa; - - CU_ASSERT_FATAL(odp_pool_capability(&capa) == 0);
max_pkt = odp_packet_copy(segmented_test_packet, odp_packet_pool(segmented_test_packet)); @@ -2104,7 +2066,7 @@ static void packet_test_extend_ref(void) odp_packet_push_tail(max_pkt, tr);
/* Max packet should not be extendable at either end */ - if (max_len == capa.pkt.max_len) { + if (max_len == pool_capa.pkt.max_len) { CU_ASSERT(odp_packet_extend_tail(&max_pkt, 1, NULL, NULL) < 0); CU_ASSERT(odp_packet_extend_head(&max_pkt, 1, NULL, NULL) < 0); } @@ -2598,6 +2560,13 @@ static int packet_parse_suite_init(void) uint32_t max_len; odp_pool_param_t param;
+ memset(&pool_capa, 0, sizeof(odp_pool_capability_t)); + + if (odp_pool_capability(&pool_capa) < 0) { + printf("pool_capability failed\n"); + return -1; + } + num_test_pkt = sizeof(parse_test_pkt_len) / sizeof(uint32_t); max_len = 0;
commit 4063f3df1a50ef2d41270eef7a1426f0fb451b8b Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 15:26:18 2019 +0200
validation: packet: remove reset test packet from suite init
This packet is only used in packet reset test case. Moved packet alloc and free inside the test case.
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index d9fbc867d..777ea0dc7 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -31,7 +31,7 @@ static uint32_t packet_len; static uint32_t segmented_packet_len; static odp_bool_t segmentation_supported = true;
-odp_packet_t test_packet, segmented_test_packet, test_reset_packet; +odp_packet_t test_packet, segmented_test_packet;
static struct udata_struct { uint64_t u64; @@ -208,13 +208,6 @@ static int packet_suite_init(void) data++; }
- test_reset_packet = odp_packet_alloc(default_pool, packet_len); - - if (test_reset_packet == ODP_PACKET_INVALID) { - printf("test_reset_packet alloc failed\n"); - return -1; - } - /* Try to allocate PACKET_POOL_NUM_SEG largest possible packets to see * if segmentation is supported */ do { @@ -275,7 +268,6 @@ static int packet_suite_init(void) static int packet_suite_term(void) { odp_packet_free(test_packet); - odp_packet_free(test_reset_packet); odp_packet_free(segmented_test_packet);
if (odp_pool_destroy(default_pool) != 0) @@ -662,11 +654,15 @@ static void packet_test_reset(void) uint32_t len, headroom; uintptr_t ptr_len; void *data, *new_data, *tail, *new_tail; - odp_packet_t pkt = test_reset_packet; + odp_packet_t pkt; + + pkt = odp_packet_alloc(default_pool, packet_len); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
len = odp_packet_len(pkt); + CU_ASSERT(len == packet_len); + headroom = odp_packet_headroom(pkt); - CU_ASSERT(len > 1);
if (headroom) { data = odp_packet_data(pkt); @@ -719,6 +715,8 @@ static void packet_test_reset(void) len = len - len / 2; CU_ASSERT(odp_packet_reset(pkt, len) == 0); CU_ASSERT(odp_packet_len(pkt) == len); + + odp_packet_free(pkt); }
static void packet_test_prefetch(void)
commit ad57370a0cb158aa87acb85e5004a42d73a82f06 Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 15:12:59 2019 +0200
validation: packet: rename default pool
Rename the default (global) packet pool. This improves code readability. Also, couple of buggy pool handle checks were corrected (checked global pool handle vs newly created local one).
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index 8a42d9e08..d9fbc867d 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -25,7 +25,7 @@ ODP_STATIC_ASSERT(PACKET_POOL_NUM_SEG > 1 && #define PARSE_TEST_NUM_PKT 10
static odp_pool_param_t default_param; -static odp_pool_t packet_pool; +static odp_pool_t default_pool; static uint32_t packet_len;
static uint32_t segmented_packet_len; @@ -190,13 +190,13 @@ static int packet_suite_init(void)
memcpy(&default_param, ¶ms, sizeof(odp_pool_param_t));
- packet_pool = odp_pool_create("packet_pool", ¶ms); - if (packet_pool == ODP_POOL_INVALID) { - printf("pool_create failed: 1\n"); + default_pool = odp_pool_create("default_pool", ¶ms); + if (default_pool == ODP_POOL_INVALID) { + printf("default pool create failed\n"); return -1; }
- test_packet = odp_packet_alloc(packet_pool, packet_len); + test_packet = odp_packet_alloc(default_pool, packet_len);
if (test_packet == ODP_PACKET_INVALID) { printf("test_packet alloc failed\n"); @@ -208,7 +208,7 @@ static int packet_suite_init(void) data++; }
- test_reset_packet = odp_packet_alloc(packet_pool, packet_len); + test_reset_packet = odp_packet_alloc(default_pool, packet_len);
if (test_reset_packet == ODP_PACKET_INVALID) { printf("test_reset_packet alloc failed\n"); @@ -218,7 +218,7 @@ static int packet_suite_init(void) /* Try to allocate PACKET_POOL_NUM_SEG largest possible packets to see * if segmentation is supported */ do { - ret = odp_packet_alloc_multi(packet_pool, segmented_packet_len, + ret = odp_packet_alloc_multi(default_pool, segmented_packet_len, pkt_tbl, PACKET_POOL_NUM_SEG); if (ret != PACKET_POOL_NUM_SEG) { if (ret > 0) @@ -257,7 +257,7 @@ static int packet_suite_init(void) return -1; }
- odp_pool_print(packet_pool); + odp_pool_print(default_pool); memcpy(udat, &test_packet_udata, sizeof(struct udata_struct));
udat = odp_packet_user_area(segmented_test_packet); @@ -278,7 +278,7 @@ static int packet_suite_term(void) odp_packet_free(test_reset_packet); odp_packet_free(segmented_test_packet);
- if (odp_pool_destroy(packet_pool) != 0) + if (odp_pool_destroy(default_pool) != 0) return -1;
return 0; @@ -1206,7 +1206,7 @@ static void packet_test_add_rem_data(void)
min_seg_len = capa.pkt.min_seg_len;
- pkt = odp_packet_alloc(packet_pool, packet_len); + pkt = odp_packet_alloc(default_pool, packet_len); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
pkt_len = odp_packet_len(pkt); @@ -1633,7 +1633,7 @@ static void packet_test_concat_small(void) param.pkt.num = PACKET_POOL_NUM;
pool = odp_pool_create("packet_pool_concat", ¶m); - CU_ASSERT(packet_pool != ODP_POOL_INVALID); + CU_ASSERT(pool != ODP_POOL_INVALID);
pkt = odp_packet_alloc(pool, 1); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); @@ -1698,7 +1698,7 @@ static void packet_test_concat_extend_trunc(void) param.pkt.num = PACKET_POOL_NUM;
pool = odp_pool_create("packet_pool_concat", ¶m); - CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
pkt = odp_packet_alloc(pool, alloc_len); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); @@ -1785,7 +1785,7 @@ static void packet_test_extend_small(void) param.pkt.num = PACKET_POOL_NUM;
pool = odp_pool_create("packet_pool_extend", ¶m); - CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
for (round = 0; round < 2; round++) { pkt = odp_packet_alloc(pool, 1); @@ -1879,7 +1879,7 @@ static void packet_test_extend_large(void) param.pkt.num = PACKET_POOL_NUM;
pool = odp_pool_create("packet_pool_extend", ¶m); - CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
for (round = 0; round < 2 * num_div; round++) { ext_len = len / div; @@ -1998,7 +1998,7 @@ static void packet_test_extend_mix(void) param.pkt.num = PACKET_POOL_NUM;
pool = odp_pool_create("packet_pool_extend", ¶m); - CU_ASSERT_FATAL(packet_pool != ODP_POOL_INVALID); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
for (round = 0; round < 2; round++) { small_count = 30;
commit 44431af475b89d16b81dfcb92db27b03b7475b74 Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 15:03:48 2019 +0200
validation: packet: remove pools from suite init
Moved two pool creates from suite init into the test case that uses those.
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index b3001693c..8a42d9e08 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -24,7 +24,8 @@ ODP_STATIC_ASSERT(PACKET_POOL_NUM_SEG > 1 && /* Number of packets in parse test */ #define PARSE_TEST_NUM_PKT 10
-static odp_pool_t packet_pool, packet_pool_no_uarea, packet_pool_double_uarea; +static odp_pool_param_t default_param; +static odp_pool_t packet_pool; static uint32_t packet_len;
static uint32_t segmented_packet_len; @@ -187,32 +188,14 @@ static int packet_suite_init(void) params.pkt.num = num; params.pkt.uarea_size = sizeof(struct udata_struct);
+ memcpy(&default_param, ¶ms, sizeof(odp_pool_param_t)); + packet_pool = odp_pool_create("packet_pool", ¶ms); if (packet_pool == ODP_POOL_INVALID) { printf("pool_create failed: 1\n"); return -1; }
- params.pkt.uarea_size = 0; - packet_pool_no_uarea = odp_pool_create("packet_pool_no_uarea", - ¶ms); - if (packet_pool_no_uarea == ODP_POOL_INVALID) { - odp_pool_destroy(packet_pool); - printf("pool_create failed: 2\n"); - return -1; - } - - params.pkt.uarea_size = 2 * sizeof(struct udata_struct); - packet_pool_double_uarea = odp_pool_create("packet_pool_double_uarea", - ¶ms); - - if (packet_pool_double_uarea == ODP_POOL_INVALID) { - odp_pool_destroy(packet_pool_no_uarea); - odp_pool_destroy(packet_pool); - printf("pool_create failed: 3\n"); - return -1; - } - test_packet = odp_packet_alloc(packet_pool, packet_len);
if (test_packet == ODP_PACKET_INVALID) { @@ -295,9 +278,7 @@ static int packet_suite_term(void) odp_packet_free(test_reset_packet); odp_packet_free(segmented_test_packet);
- if (odp_pool_destroy(packet_pool_double_uarea) != 0 || - odp_pool_destroy(packet_pool_no_uarea) != 0 || - odp_pool_destroy(packet_pool) != 0) + if (odp_pool_destroy(packet_pool) != 0) return -1;
return 0; @@ -1383,12 +1364,23 @@ static void packet_test_copy(void) { odp_packet_t pkt; odp_packet_t pkt_copy, pkt_part; - odp_pool_t pool; + odp_pool_param_t param; + odp_pool_t pool, pool_double_uarea, pool_no_uarea; uint32_t i, plen, src_offset, dst_offset; uint32_t seg_len = 0; void *pkt_data;
- pkt = odp_packet_copy(test_packet, packet_pool_no_uarea); + memcpy(¶m, &default_param, sizeof(odp_pool_param_t)); + + param.pkt.uarea_size = 0; + pool_no_uarea = odp_pool_create("no_uarea", ¶m); + CU_ASSERT_FATAL(pool_no_uarea != ODP_POOL_INVALID); + + param.pkt.uarea_size = 2 * sizeof(struct udata_struct); + pool_double_uarea = odp_pool_create("double_uarea", ¶m); + CU_ASSERT_FATAL(pool_double_uarea != ODP_POOL_INVALID); + + pkt = odp_packet_copy(test_packet, pool_no_uarea); CU_ASSERT(pkt == ODP_PACKET_INVALID); if (pkt != ODP_PACKET_INVALID) odp_packet_free(pkt); @@ -1413,7 +1405,7 @@ static void packet_test_copy(void) odp_packet_free(pkt_copy); odp_packet_free(pkt);
- pkt = odp_packet_copy(test_packet, packet_pool_double_uarea); + pkt = odp_packet_copy(test_packet, pool_double_uarea); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); packet_compare_data(pkt, test_packet); pool = odp_packet_pool(pkt); @@ -1480,6 +1472,9 @@ static void packet_test_copy(void)
odp_packet_free(pkt_part); odp_packet_free(pkt); + + CU_ASSERT(odp_pool_destroy(pool_no_uarea) == 0); + CU_ASSERT(odp_pool_destroy(pool_double_uarea) == 0); }
static void packet_test_copydata(void)
commit f55749bb0598ba9447a9ed312782821c057ef3a4 Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 13:59:35 2019 +0200
validation: buffer: rewrite buffer tests
Improved buffer test coverage by checking more APIs, and creating max num pools and more events per pool.
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/test/validation/api/buffer/buffer.c b/test/validation/api/buffer/buffer.c index 2d665279a..54a834dd2 100644 --- a/test/validation/api/buffer/buffer.c +++ b/test/validation/api/buffer/buffer.c @@ -1,4 +1,5 @@ /* Copyright (c) 2014-2018, Linaro Limited + * Copyright (c) 2019, Nokia * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -9,68 +10,79 @@
#define BUF_ALIGN ODP_CACHE_LINE_SIZE #define BUF_SIZE 1500 +#define BUF_NUM 100 +#define BURST 8
-static odp_pool_t raw_pool; -static odp_buffer_t raw_buffer = ODP_BUFFER_INVALID; +static odp_pool_capability_t pool_capa; +static odp_pool_param_t default_param;
static int buffer_suite_init(void) { - odp_pool_param_t params; + uint32_t size, num, align;
- odp_pool_param_init(¶ms); - params.type = ODP_POOL_BUFFER; - params.buf.size = BUF_SIZE; - params.buf.align = BUF_ALIGN; - params.buf.num = 100; - - raw_pool = odp_pool_create("raw_pool", ¶ms); - if (raw_pool == ODP_POOL_INVALID) - return -1; - raw_buffer = odp_buffer_alloc(raw_pool); - if (raw_buffer == ODP_BUFFER_INVALID) + if (odp_pool_capability(&pool_capa)) { + printf("pool capability failed\n"); return -1; - return 0; -} + } + + size = BUF_SIZE; + if (pool_capa.buf.max_size && size > pool_capa.buf.max_size) + size = pool_capa.buf.max_size; + + num = BUF_NUM; + if (pool_capa.buf.max_num && num > pool_capa.buf.max_num) + num = pool_capa.buf.max_num; + + align = BUF_ALIGN; + if (align > pool_capa.buf.max_align) + align = pool_capa.buf.max_align; + + odp_pool_param_init(&default_param); + default_param.type = ODP_POOL_BUFFER; + default_param.buf.size = size; + default_param.buf.num = num; + default_param.buf.align = align; + + printf("Default buffer pool\n"); + printf(" size %u\n", size); + printf(" num %u\n", num); + printf(" align %u\n\n", align);
-static int buffer_suite_term(void) -{ - odp_buffer_free(raw_buffer); - if (odp_pool_destroy(raw_pool) != 0) - return -1; return 0; }
-static void buffer_test_pool_alloc(void) +static void buffer_test_pool_alloc_free(void) { odp_pool_t pool; - const int num = 3; - odp_buffer_t buffer[num]; odp_event_t ev; - int index; + uint32_t i; + void *addr; + odp_event_subtype_t subtype; + uint32_t num = default_param.buf.num; + uint32_t size = default_param.buf.size; + uint32_t align = default_param.buf.align; + odp_buffer_t buffer[num]; odp_bool_t wrong_type = false, wrong_subtype = false; odp_bool_t wrong_size = false, wrong_align = false; - odp_pool_param_t params;
- odp_pool_param_init(¶ms); - params.type = ODP_POOL_BUFFER; - params.buf.size = BUF_SIZE; - params.buf.align = BUF_ALIGN; - params.buf.num = num; + pool = odp_pool_create("default pool", &default_param); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- pool = odp_pool_create("buffer_pool_alloc", ¶ms); odp_pool_print(pool);
- /* Try to allocate num items from the pool */ - for (index = 0; index < num; index++) { - uintptr_t addr; - odp_event_subtype_t subtype; - - buffer[index] = odp_buffer_alloc(pool); + for (i = 0; i < num; i++) { + buffer[i] = odp_buffer_alloc(pool);
- if (buffer[index] == ODP_BUFFER_INVALID) + if (buffer[i] == ODP_BUFFER_INVALID) break;
- ev = odp_buffer_to_event(buffer[index]); + CU_ASSERT(odp_buffer_is_valid(buffer[i]) == 1) + + CU_ASSERT(odp_buffer_pool(buffer[i]) == pool); + + ev = odp_buffer_to_event(buffer[i]); + CU_ASSERT(odp_buffer_from_event(ev) == buffer[i]); + if (odp_event_type(ev) != ODP_EVENT_BUFFER) wrong_type = true; if (odp_event_subtype(ev) != ODP_EVENT_NO_SUBTYPE) @@ -79,82 +91,78 @@ static void buffer_test_pool_alloc(void) wrong_type = true; if (subtype != ODP_EVENT_NO_SUBTYPE) wrong_subtype = true; - if (odp_buffer_size(buffer[index]) < BUF_SIZE) + if (odp_buffer_size(buffer[i]) != size) wrong_size = true;
- addr = (uintptr_t)odp_buffer_addr(buffer[index]); + addr = odp_buffer_addr(buffer[i]);
- if ((addr % BUF_ALIGN) != 0) + if (((uintptr_t)addr % align) != 0) wrong_align = true;
- if (wrong_type || wrong_size || wrong_align) - odp_buffer_print(buffer[index]); - } + if (wrong_type || wrong_subtype || wrong_size || wrong_align) { + printf("Buffer has error\n"); + odp_buffer_print(buffer[i]); + break; + }
- /* Check that the pool had at least num items */ - CU_ASSERT(index == num); - /* index points out of buffer[] or it point to an invalid buffer */ - index--; + /* Write buffer data */ + memset(addr, 0, size); + }
- /* Check that the pool had correct buffers */ + CU_ASSERT(i == num); CU_ASSERT(!wrong_type); CU_ASSERT(!wrong_subtype); CU_ASSERT(!wrong_size); CU_ASSERT(!wrong_align);
- for (; index >= 0; index--) - odp_buffer_free(buffer[index]); + for (i = 0; i < num; i++) + odp_buffer_free(buffer[i]);
CU_ASSERT(odp_pool_destroy(pool) == 0); }
-/* Wrapper to call odp_buffer_alloc_multi multiple times until - * either no mure buffers are returned, or num buffers were alloced */ -static int buffer_alloc_multi(odp_pool_t pool, odp_buffer_t buffer[], int num) -{ - int ret, total = 0; - - do { - ret = odp_buffer_alloc_multi(pool, buffer + total, num - total); - CU_ASSERT(ret >= 0); - CU_ASSERT(ret <= num - total); - total += ret; - } while (total < num && ret); - - return total; -} - -static void buffer_test_pool_alloc_multi(void) +static void buffer_test_pool_alloc_free_multi(void) { odp_pool_t pool; - const int num = 3; - odp_buffer_t buffer[num + 1]; + uint32_t i, num_buf; + int ret; odp_event_t ev; - int index; + void *addr; + odp_event_subtype_t subtype; + uint32_t num = default_param.buf.num; + uint32_t size = default_param.buf.size; + uint32_t align = default_param.buf.align; + odp_buffer_t buffer[num + BURST]; odp_bool_t wrong_type = false, wrong_subtype = false; odp_bool_t wrong_size = false, wrong_align = false; - odp_pool_param_t params;
- odp_pool_param_init(¶ms); - params.type = ODP_POOL_BUFFER; - params.buf.size = BUF_SIZE; - params.buf.align = BUF_ALIGN; - params.buf.num = num; + pool = odp_pool_create("default pool", &default_param); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
- pool = odp_pool_create("buffer_pool_alloc_multi", ¶ms); - odp_pool_print(pool); + ret = 0; + for (i = 0; i < num; i += ret) { + ret = odp_buffer_alloc_multi(pool, &buffer[i], BURST); + CU_ASSERT(ret >= 0); + CU_ASSERT(ret <= BURST);
- /* Try to allocate num + 1 items from the pool */ - CU_ASSERT_FATAL(buffer_alloc_multi(pool, buffer, num + 1) == num); + if (ret <= 0) + break; + }
- for (index = 0; index < num; index++) { - uintptr_t addr; - odp_event_subtype_t subtype; + num_buf = i; + CU_ASSERT(num_buf == num);
- if (buffer[index] == ODP_BUFFER_INVALID) + for (i = 0; i < num_buf; i++) { + if (buffer[i] == ODP_BUFFER_INVALID) break;
- ev = odp_buffer_to_event(buffer[index]); + CU_ASSERT(odp_buffer_is_valid(buffer[i]) == 1) + + CU_ASSERT(odp_buffer_pool(buffer[i]) == pool); + + ev = odp_buffer_to_event(buffer[i]); + CU_ASSERT(odp_buffer_from_event(ev) == buffer[i]); + if (odp_event_type(ev) != ODP_EVENT_BUFFER) wrong_type = true; if (odp_event_subtype(ev) != ODP_EVENT_NO_SUBTYPE) @@ -163,131 +171,214 @@ static void buffer_test_pool_alloc_multi(void) wrong_type = true; if (subtype != ODP_EVENT_NO_SUBTYPE) wrong_subtype = true; - if (odp_buffer_size(buffer[index]) < BUF_SIZE) + if (odp_buffer_size(buffer[i]) != size) wrong_size = true;
- addr = (uintptr_t)odp_buffer_addr(buffer[index]); + addr = odp_buffer_addr(buffer[i]);
- if ((addr % BUF_ALIGN) != 0) + if (((uintptr_t)addr % align) != 0) wrong_align = true;
- if (wrong_type || wrong_size || wrong_align) - odp_buffer_print(buffer[index]); - } + if (wrong_type || wrong_subtype || wrong_size || wrong_align) { + printf("Buffer has error\n"); + odp_buffer_print(buffer[i]); + break; + }
- /* Check that the pool had at least num items */ - CU_ASSERT(index == num); + /* Write buffer data */ + memset(addr, 0, size); + }
- /* Check that the pool had correct buffers */ + CU_ASSERT(i == num_buf); CU_ASSERT(!wrong_type); CU_ASSERT(!wrong_subtype); CU_ASSERT(!wrong_size); CU_ASSERT(!wrong_align);
- odp_buffer_free_multi(buffer, num); + if (num_buf) + odp_buffer_free_multi(buffer, num_buf);
CU_ASSERT(odp_pool_destroy(pool) == 0); }
-static void buffer_test_pool_free(void) +static void buffer_test_pool_single_pool(void) { odp_pool_t pool; odp_buffer_t buffer; - odp_pool_param_t params; + odp_pool_param_t param;
- odp_pool_param_init(¶ms); - params.type = ODP_POOL_BUFFER; - params.buf.size = 64; - params.buf.align = BUF_ALIGN; - params.buf.num = 1; + memcpy(¶m, &default_param, sizeof(odp_pool_param_t)); + param.buf.num = 1;
- pool = odp_pool_create("buffer_pool_free", ¶ms); + pool = odp_pool_create("pool 0", ¶m); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + + odp_pool_print(pool);
/* Allocate the only buffer from the pool */ buffer = odp_buffer_alloc(pool); - CU_ASSERT_FATAL(buffer != ODP_BUFFER_INVALID); + CU_ASSERT(buffer != ODP_BUFFER_INVALID);
- /* Pool should have only one buffer */ - CU_ASSERT_FATAL(odp_buffer_alloc(pool) == ODP_BUFFER_INVALID) + /* Pool should be empty */ + CU_ASSERT(odp_buffer_alloc(pool) == ODP_BUFFER_INVALID)
- odp_buffer_free(buffer); + if (buffer != ODP_BUFFER_INVALID) { + odp_event_t ev = odp_buffer_to_event(buffer); + + CU_ASSERT(odp_buffer_to_u64(buffer) != + odp_buffer_to_u64(ODP_BUFFER_INVALID)); + CU_ASSERT(odp_event_to_u64(ev) != + odp_event_to_u64(ODP_EVENT_INVALID)); + CU_ASSERT(odp_buffer_pool(buffer) == pool); + odp_buffer_print(buffer); + odp_buffer_free(buffer); + }
/* Check that the buffer was returned back to the pool */ buffer = odp_buffer_alloc(pool); - CU_ASSERT_FATAL(buffer != ODP_BUFFER_INVALID); + CU_ASSERT(buffer != ODP_BUFFER_INVALID); + + if (buffer != ODP_BUFFER_INVALID) + odp_buffer_free(buffer);
- odp_buffer_free(buffer); CU_ASSERT(odp_pool_destroy(pool) == 0); }
-static void buffer_test_pool_free_multi(void) +static void buffer_test_pool_two_pools(void) { - odp_pool_t pool[2]; - odp_buffer_t buffer[4]; - odp_buffer_t buf_inval[2]; - odp_pool_param_t params; - - odp_pool_param_init(¶ms); - params.type = ODP_POOL_BUFFER; - params.buf.size = 64; - params.buf.align = BUF_ALIGN; - params.buf.num = 2; - - pool[0] = odp_pool_create("buffer_pool_free_multi_0", ¶ms); - pool[1] = odp_pool_create("buffer_pool_free_multi_1", ¶ms); - CU_ASSERT_FATAL(pool[0] != ODP_POOL_INVALID); - CU_ASSERT_FATAL(pool[1] != ODP_POOL_INVALID); - - /* Allocate all the buffers from the pools */ - CU_ASSERT_FATAL(buffer_alloc_multi(pool[0], &buffer[0], 2) == 2); - CU_ASSERT_FATAL(buffer_alloc_multi(pool[1], &buffer[2], 2) == 2); - - /* Pools should have no more buffer */ - CU_ASSERT(odp_buffer_alloc_multi(pool[0], buf_inval, 2) == 0); - CU_ASSERT(odp_buffer_alloc_multi(pool[1], buf_inval, 2) == 0); - - /* Try to free both buffers from both pools at once */ - odp_buffer_free_multi(buffer, 4); - - /* Check that all buffers were returned back to the pools */ - CU_ASSERT_FATAL(buffer_alloc_multi(pool[0], &buffer[0], 2) == 2); - CU_ASSERT_FATAL(buffer_alloc_multi(pool[1], &buffer[2], 2) == 2); - - odp_buffer_free_multi(buffer, 4); - CU_ASSERT(odp_pool_destroy(pool[0]) == 0); - CU_ASSERT(odp_pool_destroy(pool[1]) == 0); + odp_pool_t pool0, pool1; + odp_buffer_t buf, buffer[2]; + odp_pool_param_t param; + int num = 0; + + if (pool_capa.buf.max_pools < 2) + return; + + memcpy(¶m, &default_param, sizeof(odp_pool_param_t)); + param.buf.num = 1; + + pool0 = odp_pool_create("pool 0", ¶m); + CU_ASSERT_FATAL(pool0 != ODP_POOL_INVALID); + + pool1 = odp_pool_create("pool 1", ¶m); + CU_ASSERT_FATAL(pool1 != ODP_POOL_INVALID); + + buffer[0] = odp_buffer_alloc(pool0); + CU_ASSERT(buffer[0] != ODP_BUFFER_INVALID); + + buffer[1] = odp_buffer_alloc(pool1); + CU_ASSERT(buffer[1] != ODP_BUFFER_INVALID); + + if (buffer[0] != ODP_BUFFER_INVALID) { + CU_ASSERT(odp_buffer_pool(buffer[0]) == pool0); + num++; + } + if (buffer[1] != ODP_BUFFER_INVALID) { + CU_ASSERT(odp_buffer_pool(buffer[1]) == pool1); + num++; + } + + CU_ASSERT(odp_buffer_alloc(pool0) == ODP_BUFFER_INVALID); + CU_ASSERT(odp_buffer_alloc(pool1) == ODP_BUFFER_INVALID); + + /* free buffers from two different pools */ + if (num) + odp_buffer_free_multi(buffer, num); + + /* Check that buffers were returned back into pools */ + buf = odp_buffer_alloc(pool0); + CU_ASSERT(buf != ODP_BUFFER_INVALID); + + if (buf != ODP_BUFFER_INVALID) { + CU_ASSERT(odp_buffer_pool(buf) == pool0); + odp_buffer_free(buf); + } + + CU_ASSERT(odp_pool_destroy(pool0) == 0); + + buf = odp_buffer_alloc(pool1); + CU_ASSERT(buf != ODP_BUFFER_INVALID); + + if (buf != ODP_BUFFER_INVALID) { + CU_ASSERT(odp_buffer_pool(buf) == pool1); + odp_buffer_free(buf); + } + + CU_ASSERT(odp_pool_destroy(pool1) == 0); }
-static void buffer_test_management_basic(void) +static void buffer_test_pool_max_pools(void) { - odp_event_t ev = odp_buffer_to_event(raw_buffer); - odp_event_subtype_t subtype; + odp_pool_param_t param; + uint32_t i, num_pool, num_buf; + void *addr; + odp_event_t ev; + uint32_t max_pools = pool_capa.buf.max_pools; + uint32_t size = default_param.buf.size; + uint32_t align = default_param.buf.align; + odp_pool_t pool[max_pools]; + odp_buffer_t buffer[max_pools]; + + CU_ASSERT_FATAL(max_pools != 0); + + printf("\n Creating %u pools\n", max_pools); + + memcpy(¶m, &default_param, sizeof(odp_pool_param_t)); + param.buf.num = 1; + + for (i = 0; i < max_pools; i++) { + pool[i] = odp_pool_create(NULL, ¶m); + + if (pool[i] == ODP_POOL_INVALID) + break; + } + + num_pool = i; + + CU_ASSERT(num_pool == max_pools); + if (num_pool != max_pools) + printf("Error: created only %u pools\n", num_pool); + + for (i = 0; i < num_pool; i++) { + buffer[i] = odp_buffer_alloc(pool[i]); + + if (buffer[i] == ODP_BUFFER_INVALID) + break; + + CU_ASSERT_FATAL(odp_buffer_pool(buffer[i]) == pool[i]); + + ev = odp_buffer_to_event(buffer[i]); + CU_ASSERT(odp_buffer_from_event(ev) == buffer[i]); + CU_ASSERT(odp_event_type(ev) == ODP_EVENT_BUFFER); + + addr = odp_buffer_addr(buffer[i]); + CU_ASSERT(((uintptr_t)addr % align) == 0); + + /* Write buffer data */ + memset(addr, 0, size); + } + + num_buf = i; + CU_ASSERT(num_buf == num_pool); + + if (num_buf) + odp_buffer_free_multi(buffer, num_buf);
- CU_ASSERT(odp_buffer_is_valid(raw_buffer) == 1); - CU_ASSERT(odp_buffer_pool(raw_buffer) != ODP_POOL_INVALID); - CU_ASSERT(odp_event_type(ev) == ODP_EVENT_BUFFER); - CU_ASSERT(odp_event_subtype(ev) == ODP_EVENT_NO_SUBTYPE); - CU_ASSERT(odp_event_types(ev, &subtype) == ODP_EVENT_BUFFER); - CU_ASSERT(subtype == ODP_EVENT_NO_SUBTYPE); - CU_ASSERT(odp_buffer_size(raw_buffer) >= BUF_SIZE); - CU_ASSERT(odp_buffer_addr(raw_buffer) != NULL); - odp_buffer_print(raw_buffer); - CU_ASSERT(odp_buffer_to_u64(raw_buffer) != - odp_buffer_to_u64(ODP_BUFFER_INVALID)); - CU_ASSERT(odp_event_to_u64(ev) != odp_event_to_u64(ODP_EVENT_INVALID)); + for (i = 0; i < num_pool; i++) + CU_ASSERT(odp_pool_destroy(pool[i]) == 0); }
odp_testinfo_t buffer_suite[] = { - ODP_TEST_INFO(buffer_test_pool_alloc), - ODP_TEST_INFO(buffer_test_pool_free), - ODP_TEST_INFO(buffer_test_pool_alloc_multi), - ODP_TEST_INFO(buffer_test_pool_free_multi), - ODP_TEST_INFO(buffer_test_management_basic), + ODP_TEST_INFO(buffer_test_pool_alloc_free), + ODP_TEST_INFO(buffer_test_pool_alloc_free_multi), + ODP_TEST_INFO(buffer_test_pool_single_pool), + ODP_TEST_INFO(buffer_test_pool_two_pools), + ODP_TEST_INFO(buffer_test_pool_max_pools), ODP_TEST_INFO_NULL, };
odp_suiteinfo_t buffer_suites[] = { - {"buffer tests", buffer_suite_init, buffer_suite_term, buffer_suite}, + {"buffer tests", buffer_suite_init, NULL, buffer_suite}, ODP_SUITE_INFO_NULL, };
commit 76cf03d62e77c6eea7e67f66cde729e8f64a618f Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 14:08:33 2019 +0200
linux-gen: pool: decrease number of pools capa
At least one pool needs to be reserved from ODP_CONFIG_POOLS for internal usage.
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/platform/linux-generic/odp_pool.c b/platform/linux-generic/odp_pool.c index fcd3e3a0e..95dcb6884 100644 --- a/platform/linux-generic/odp_pool.c +++ b/platform/linux-generic/odp_pool.c @@ -1048,19 +1048,21 @@ void odp_buffer_free_multi(const odp_buffer_t buf[], int num) int odp_pool_capability(odp_pool_capability_t *capa) { uint32_t max_seg_len = CONFIG_PACKET_MAX_SEG_LEN; + /* Reserve one for internal usage */ + int max_pools = ODP_CONFIG_POOLS - 1;
memset(capa, 0, sizeof(odp_pool_capability_t));
- capa->max_pools = ODP_CONFIG_POOLS; + capa->max_pools = max_pools;
/* Buffer pools */ - capa->buf.max_pools = ODP_CONFIG_POOLS; + capa->buf.max_pools = max_pools; capa->buf.max_align = ODP_CONFIG_BUFFER_ALIGN_MAX; capa->buf.max_size = MAX_SIZE; capa->buf.max_num = CONFIG_POOL_MAX_NUM;
/* Packet pools */ - capa->pkt.max_pools = ODP_CONFIG_POOLS; + capa->pkt.max_pools = max_pools; capa->pkt.max_len = CONFIG_PACKET_MAX_LEN; capa->pkt.max_num = pool_tbl->config.pkt_max_num; capa->pkt.min_headroom = CONFIG_PACKET_HEADROOM; @@ -1072,7 +1074,7 @@ int odp_pool_capability(odp_pool_capability_t *capa) capa->pkt.max_uarea_size = MAX_SIZE;
/* Timeout pools */ - capa->tmo.max_pools = ODP_CONFIG_POOLS; + capa->tmo.max_pools = max_pools; capa->tmo.max_num = CONFIG_POOL_MAX_NUM;
return 0;
commit df93cd4cdf73df1bc9d63161bab18db611041a5c Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 13:48:06 2019 +0200
linux-gen: config: decrease max number of pools
The max number of pools is limited by the number of ISHM blocks. Reduced max pool count to match this limit.
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/platform/linux-generic/include/odp_config_internal.h b/platform/linux-generic/include/odp_config_internal.h index e283472a0..67011b0d4 100644 --- a/platform/linux-generic/include/odp_config_internal.h +++ b/platform/linux-generic/include/odp_config_internal.h @@ -18,9 +18,9 @@ extern "C" { #define CONFIG_NUM_CPU 256
/* - * Maximum number of pools + * Maximum number of pools. Limited by ISHM_MAX_NB_BLOCKS. */ -#define ODP_CONFIG_POOLS 64 +#define ODP_CONFIG_POOLS 55
/* * Queues reserved for ODP internal use
commit 4898f2ff2054c2365588baef44f64e4c67003a57 Author: Petri Savolainen petri.savolainen@nokia.com Date: Thu Nov 14 14:07:38 2019 +0200
linux-gen: pool: add line feed to error prints
Signed-off-by: Petri Savolainen petri.savolainen@nokia.com Reviewed-by: Matias Elo matias.elo@nokia.com
diff --git a/platform/linux-generic/odp_pool.c b/platform/linux-generic/odp_pool.c index e98027eb6..fcd3e3a0e 100644 --- a/platform/linux-generic/odp_pool.c +++ b/platform/linux-generic/odp_pool.c @@ -266,7 +266,7 @@ int _odp_pool_term_global(void)
ret = odp_shm_free(pool_tbl->shm); if (ret < 0) { - ODP_ERR("shm free failed"); + ODP_ERR("SHM free failed\n"); rc = -1; }
@@ -474,7 +474,7 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params, /* Validate requested buffer alignment */ if (align > ODP_CONFIG_BUFFER_ALIGN_MAX || align != ROUNDDOWN_POWER2(align, align)) { - ODP_ERR("Bad align requirement"); + ODP_ERR("Bad align requirement\n"); return ODP_POOL_INVALID; }
@@ -492,7 +492,7 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params,
case ODP_POOL_PACKET: if (params->pkt.headroom > CONFIG_PACKET_HEADROOM) { - ODP_ERR("Packet headroom size not supported."); + ODP_ERR("Packet headroom size not supported\n"); return ODP_POOL_INVALID; }
@@ -514,7 +514,7 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params, if ((max_len + seg_len - 1) / seg_len > PKT_MAX_SEGS) seg_len = (max_len + PKT_MAX_SEGS - 1) / PKT_MAX_SEGS; if (seg_len > CONFIG_PACKET_MAX_SEG_LEN) { - ODP_ERR("Pool unable to store 'max_len' packet"); + ODP_ERR("Pool unable to store 'max_len' packet\n"); return ODP_POOL_INVALID; }
@@ -529,7 +529,7 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params, break;
default: - ODP_ERR("Bad pool type"); + ODP_ERR("Bad pool type\n"); return ODP_POOL_INVALID; }
@@ -539,7 +539,7 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params, pool = reserve_pool(shmflags);
if (pool == NULL) { - ODP_ERR("No more free pools"); + ODP_ERR("No more free pools\n"); return ODP_POOL_INVALID; }
@@ -627,7 +627,7 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params, pool->shm = shm;
if (shm == ODP_SHM_INVALID) { - ODP_ERR("Shm reserve failed"); + ODP_ERR("SHM reserve failed\n"); goto error; }
@@ -643,7 +643,7 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params, pool->uarea_shm = shm;
if (shm == ODP_SHM_INVALID) { - ODP_ERR("Shm reserve failed (uarea)"); + ODP_ERR("SHM reserve failed (uarea)\n"); goto error; }
-----------------------------------------------------------------------
Summary of changes: .../linux-generic/include/odp_config_internal.h | 4 +- platform/linux-generic/odp_pool.c | 26 +- test/validation/api/buffer/buffer.c | 427 +++++++++++++-------- test/validation/api/packet/packet.c | 297 +++++++------- 4 files changed, 437 insertions(+), 317 deletions(-)
hooks/post-receive