aboutsummaryrefslogtreecommitdiff
path: root/test/validation/api
diff options
context:
space:
mode:
Diffstat (limited to 'test/validation/api')
-rw-r--r--test/validation/api/barrier/barrier.c11
-rw-r--r--test/validation/api/buffer/buffer.c3
-rw-r--r--test/validation/api/crypto/crypto_op_test.c94
-rw-r--r--test/validation/api/crypto/crypto_op_test.h10
-rw-r--r--test/validation/api/crypto/odp_crypto_test_inp.c233
-rw-r--r--test/validation/api/dma/dma.c76
-rw-r--r--test/validation/api/event/event.c46
-rw-r--r--test/validation/api/ipsec/ipsec.c3
-rw-r--r--test/validation/api/packet/packet.c11
-rw-r--r--test/validation/api/pktio/pktio.c6
-rw-r--r--test/validation/api/pool/pool.c293
-rw-r--r--test/validation/api/shmem/shmem.c2
-rw-r--r--test/validation/api/time/time.c145
-rw-r--r--test/validation/api/timer/timer.c398
14 files changed, 1003 insertions, 328 deletions
diff --git a/test/validation/api/barrier/barrier.c b/test/validation/api/barrier/barrier.c
index 610b5db70..e4fba770f 100644
--- a/test/validation/api/barrier/barrier.c
+++ b/test/validation/api/barrier/barrier.c
@@ -283,6 +283,9 @@ static void barrier_test_memory_barrier(void)
volatile int b = 0;
volatile int c = 0;
volatile int d = 0;
+ volatile int e = 0;
+ volatile int f = 0;
+ volatile int g = 0;
/* Call all memory barriers to verify that those are implemented */
a = 1;
@@ -292,9 +295,15 @@ static void barrier_test_memory_barrier(void)
c = 1;
odp_mb_full();
d = 1;
+ odp_mb_sync();
+ e = 1;
+ odp_mb_sync_load();
+ f = 1;
+ odp_mb_sync_store();
+ g = 1;
/* Avoid "variable set but not used" warning */
- temp_result = a + b + c + d;
+ temp_result = a + b + c + d + e + f + g;
}
static int barrier_init(odp_instance_t *inst)
diff --git a/test/validation/api/buffer/buffer.c b/test/validation/api/buffer/buffer.c
index ef26ea6e0..1d0cc9d01 100644
--- a/test/validation/api/buffer/buffer.c
+++ b/test/validation/api/buffer/buffer.c
@@ -537,6 +537,7 @@ static void buffer_test_user_area(void)
for (i = 0; i < num; i++) {
odp_event_t ev;
+ int flag;
buffer[i] = odp_buffer_alloc(pool);
@@ -550,6 +551,8 @@ static void buffer_test_user_area(void)
ev = odp_buffer_to_event(buffer[i]);
CU_ASSERT(odp_event_user_area(ev) == addr);
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr);
+ CU_ASSERT(flag < 0);
prev = addr;
memset(addr, 0, size);
diff --git a/test/validation/api/crypto/crypto_op_test.c b/test/validation/api/crypto/crypto_op_test.c
index 4ad333488..1d883f6b8 100644
--- a/test/validation/api/crypto/crypto_op_test.c
+++ b/test/validation/api/crypto/crypto_op_test.c
@@ -178,19 +178,13 @@ static void prepare_crypto_ranges(const crypto_op_test_param_t *param,
odp_packet_data_range_t *cipher_range,
odp_packet_data_range_t *auth_range)
{
- odp_packet_data_range_t zero_range = {.offset = 0, .length = 0};
- uint32_t c_scale = param->is_bit_mode_cipher ? 8 : 1;
- uint32_t a_scale = param->is_bit_mode_auth ? 8 : 1;
+ uint32_t c_scale = param->session.cipher_range_in_bits ? 8 : 1;
+ uint32_t a_scale = param->session.auth_range_in_bits ? 8 : 1;
*cipher_range = param->cipher_range;
*auth_range = param->auth_range;
cipher_range->offset += c_scale * param->header_len;
auth_range->offset += a_scale * param->header_len;
-
- if (param->ref->cipher == ODP_CIPHER_ALG_NULL)
- *cipher_range = zero_range;
- if (param->ref->auth == ODP_AUTH_ALG_NULL)
- *auth_range = zero_range;
}
static int prepare_input_packet(const crypto_op_test_param_t *param,
@@ -217,7 +211,7 @@ static int prepare_input_packet(const crypto_op_test_param_t *param,
write_header_and_trailer(pkt, param->header_len, param->trailer_len);
- if (param->op == ODP_CRYPTO_OP_ENCODE) {
+ if (param->session.op == ODP_CRYPTO_OP_ENCODE) {
odp_packet_copy_from_mem(pkt, param->header_len,
reflength, ref->plaintext);
} else {
@@ -322,7 +316,7 @@ static void prepare_ignore_info(const crypto_op_test_param_t *param,
* Leftover bits in the last byte of the cipher range of bit mode
* ciphers have undefined values.
*/
- if (param->is_bit_mode_cipher &&
+ if (param->session.cipher_range_in_bits &&
param->ref->cipher != ODP_CIPHER_ALG_NULL) {
uint8_t leftover_bits = ref_length_in_bits(param->ref) % 8;
@@ -338,10 +332,10 @@ static void prepare_ignore_info(const crypto_op_test_param_t *param,
* undefined values.
*/
if (param->ref->auth != ODP_AUTH_ALG_NULL &&
- param->op == ODP_CRYPTO_OP_DECODE) {
+ param->session.op == ODP_CRYPTO_OP_DECODE) {
uint32_t offs = param->digest_offset;
- if (param->op_type != ODP_CRYPTO_OP_TYPE_OOP ||
+ if (param->session.op_type != ODP_CRYPTO_OP_TYPE_OOP ||
is_in_range(offs, cipher_offset, cipher_len) ||
is_in_range(offs, auth_offset, auth_len)) {
add_ignored_range(ignore,
@@ -351,11 +345,11 @@ static void prepare_ignore_info(const crypto_op_test_param_t *param,
}
/* Decrypted bytes are undefined if authentication fails. */
- if (param->op == ODP_CRYPTO_OP_DECODE &&
+ if (param->session.op == ODP_CRYPTO_OP_DECODE &&
param->wrong_digest) {
add_ignored_range(ignore, cipher_offset + shift, cipher_len);
/* In OOP case, auth range may not get copied */
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP)
+ if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP)
add_ignored_range(ignore, auth_offset + shift, auth_len);
}
}
@@ -372,30 +366,29 @@ static void prepare_expected_data(const crypto_op_test_param_t *param,
uint32_t cipher_len = cipher_range->length;
uint32_t auth_offset = auth_range->offset;
uint32_t auth_len = auth_range->length;
- const int32_t shift = param->op_type == ODP_CRYPTO_OP_TYPE_OOP ? param->oop_shift : 0;
- const odp_packet_t base_pkt = param->op_type == ODP_CRYPTO_OP_TYPE_OOP ? pkt_out : pkt_in;
+ const int32_t shift = param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP ? param->oop_shift
+ : 0;
+ const odp_packet_t base_pkt = param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP ? pkt_out
+ : pkt_in;
int rc;
uint32_t cipher_offset_in_ref = param->cipher_range.offset;
- if (param->op == ODP_CRYPTO_OP_ENCODE)
+ if (param->session.op == ODP_CRYPTO_OP_ENCODE)
digest_offset += shift;
- if (param->is_bit_mode_cipher) {
+ if (param->session.cipher_range_in_bits) {
cipher_offset_in_ref /= 8;
cipher_offset /= 8;
cipher_len = (cipher_len + 7) / 8;
}
- if (param->is_bit_mode_auth) {
+ if (param->session.auth_range_in_bits) {
auth_offset /= 8;
auth_len = (auth_len + 7) / 8;
}
- if (param->ref->cipher == ODP_CIPHER_ALG_NULL)
- cipher_len = 0;
- if (param->ref->auth == ODP_AUTH_ALG_NULL ||
- param->ref->auth == ODP_AUTH_ALG_AES_GCM ||
+ if (param->ref->auth == ODP_AUTH_ALG_AES_GCM ||
param->ref->auth == ODP_AUTH_ALG_AES_CCM ||
param->ref->auth == ODP_AUTH_ALG_CHACHA20_POLY1305) {
- /* auth range is ignored with null and AEAD algorithms */
+ /* auth range is ignored with AEAD algorithms */
auth_len = 0;
}
@@ -405,14 +398,14 @@ static void prepare_expected_data(const crypto_op_test_param_t *param,
rc = odp_packet_copy_to_mem(base_pkt, 0, ex->len, ex->data);
CU_ASSERT(rc == 0);
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP && auth_len > 0) {
+ if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP && auth_len > 0) {
/* copy auth range from input packet */
rc = odp_packet_copy_to_mem(pkt_in, auth_offset, auth_len,
ex->data + auth_offset + shift);
CU_ASSERT(rc == 0);
}
- if (param->op == ODP_CRYPTO_OP_ENCODE) {
+ if (param->session.op == ODP_CRYPTO_OP_ENCODE) {
/* copy hash first */
memcpy(ex->data + digest_offset,
param->ref->digest,
@@ -472,6 +465,23 @@ static void check_output_packet_data(odp_packet_t pkt, expected_t *ex)
}
}
+static int is_digest_in_cipher_range(const crypto_op_test_param_t *param,
+ const odp_crypto_packet_op_param_t *op_params)
+{
+ /*
+ * Do not use op_params.hash_result_offset here as it refers to
+ * the output packet which (in the OOP case) might be shifted
+ * relative to the input packet.
+ */
+ uint32_t d_offset = param->digest_offset;
+
+ if (param->session.cipher_range_in_bits)
+ d_offset *= 8;
+
+ return d_offset >= op_params->cipher_range.offset &&
+ d_offset < op_params->cipher_range.offset + op_params->cipher_range.length;
+}
+
void test_crypto_op(const crypto_op_test_param_t *param)
{
odp_bool_t ok = false;
@@ -481,13 +491,14 @@ void test_crypto_op(const crypto_op_test_param_t *param)
test_packet_md_t md_in, md_out, md_out_orig;
expected_t expected;
odp_crypto_packet_op_param_t op_params = {
- .session = param->session,
+ .session = param->session.session,
.cipher_iv_ptr = param->ref->cipher_iv,
.auth_iv_ptr = param->ref->auth_iv,
.hash_result_offset = param->digest_offset,
.aad_ptr = param->ref->aad,
.dst_offset_shift = param->oop_shift,
};
+ odp_bool_t failure_allowed = false;
/*
* Test detection of wrong digest value in input packet
@@ -495,26 +506,34 @@ void test_crypto_op(const crypto_op_test_param_t *param)
*/
if (param->wrong_digest &&
(param->ref->auth == ODP_AUTH_ALG_NULL ||
- param->op == ODP_CRYPTO_OP_ENCODE))
+ param->session.op == ODP_CRYPTO_OP_ENCODE))
return;
prepare_crypto_ranges(param, &op_params.cipher_range, &op_params.auth_range);
if (prepare_input_packet(param, &pkt))
return;
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP) {
+ if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP) {
prepare_oop_output_packet(param, &pkt_out, odp_packet_len(pkt));
pkt_copy = odp_packet_copy(pkt, suite_context.pool);
CU_ASSERT_FATAL(pkt_copy != ODP_PACKET_INVALID);
test_packet_get_md(pkt_out, &md_out_orig);
+
+ /* Non-zero-length ranges do not have to be supported. */
+ if ((param->ref->cipher == ODP_CIPHER_ALG_NULL &&
+ op_params.cipher_range.length != 0))
+ failure_allowed = true;
+ if ((param->ref->auth == ODP_AUTH_ALG_NULL &&
+ op_params.auth_range.length != 0))
+ failure_allowed = true;
}
prepare_expected_data(param, &op_params.cipher_range, &op_params.auth_range,
pkt, pkt_out, &expected);
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP &&
- param->op == ODP_CRYPTO_OP_ENCODE) {
+ if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP &&
+ param->session.op == ODP_CRYPTO_OP_ENCODE) {
/*
* In this type of sessions digest offset is an offset to the output
* packet, so apply the shift.
@@ -525,12 +544,12 @@ void test_crypto_op(const crypto_op_test_param_t *param)
test_packet_set_md(pkt);
test_packet_get_md(pkt, &md_in);
- if (crypto_op(pkt, &pkt_out, &ok, &op_params, param->op_type))
+ if (crypto_op(pkt, &pkt_out, &ok, &op_params, param->session.op_type))
return;
test_packet_get_md(pkt_out, &md_out);
- if (param->op_type == ODP_CRYPTO_OP_TYPE_OOP) {
+ if (param->session.op_type == ODP_CRYPTO_OP_TYPE_OOP) {
test_packet_md_t md;
/* check that input packet has not changed */
@@ -548,17 +567,18 @@ void test_crypto_op(const crypto_op_test_param_t *param)
if (param->ref->cipher != ODP_CIPHER_ALG_NULL &&
param->ref->auth != ODP_AUTH_ALG_NULL &&
- param->digest_offset >= op_params.cipher_range.offset &&
- param->digest_offset < op_params.cipher_range.offset + op_params.cipher_range.length) {
+ is_digest_in_cipher_range(param, &op_params)) {
/*
* Not all implementations support digest offset in cipher
* range, so allow crypto op failure without further checks
* in this case.
*/
- if (!ok)
- goto out;
+ failure_allowed = true;
}
+ if (!ok && failure_allowed)
+ goto out;
+
if (param->wrong_digest) {
CU_ASSERT(!ok);
} else {
diff --git a/test/validation/api/crypto/crypto_op_test.h b/test/validation/api/crypto/crypto_op_test.h
index 4b2f66c47..4f5957820 100644
--- a/test/validation/api/crypto/crypto_op_test.h
+++ b/test/validation/api/crypto/crypto_op_test.h
@@ -12,17 +12,21 @@
#include <stdint.h>
#include "test_vectors.h"
-typedef struct crypto_op_test_param_t {
+typedef struct crypto_session_t {
odp_crypto_session_t session;
odp_crypto_op_t op;
odp_crypto_op_type_t op_type;
+ odp_bool_t cipher_range_in_bits;
+ odp_bool_t auth_range_in_bits;
+} crypto_session_t;
+
+typedef struct crypto_op_test_param_t {
+ crypto_session_t session;
int32_t oop_shift;
crypto_test_reference_t *ref;
odp_packet_data_range_t cipher_range;
odp_packet_data_range_t auth_range;
uint32_t digest_offset;
- odp_bool_t is_bit_mode_cipher;
- odp_bool_t is_bit_mode_auth;
odp_bool_t adjust_segmentation;
odp_bool_t wrong_digest;
uint32_t first_seg_len;
diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c
index d7e2bd16b..0cc01b8e4 100644
--- a/test/validation/api/crypto/odp_crypto_test_inp.c
+++ b/test/validation/api/crypto/odp_crypto_test_inp.c
@@ -36,6 +36,8 @@ static void test_defaults(uint8_t fill)
CU_ASSERT_EQUAL(param.op, ODP_CRYPTO_OP_ENCODE);
CU_ASSERT_EQUAL(param.op_type, ODP_CRYPTO_OP_TYPE_LEGACY);
+ CU_ASSERT_EQUAL(param.cipher_range_in_bits, false);
+ CU_ASSERT_EQUAL(param.auth_range_in_bits, false);
CU_ASSERT_EQUAL(param.auth_cipher_text, false);
CU_ASSERT_EQUAL(param.op_mode, ODP_CRYPTO_SYNC);
CU_ASSERT_EQUAL(param.cipher_alg, ODP_CIPHER_ALG_NULL);
@@ -53,15 +55,10 @@ static void test_default_values(void)
static void print_alg_test_param(const crypto_op_test_param_t *p)
{
- const char *cipher_mode = p->is_bit_mode_cipher ? "bit" : "byte";
+ const char *cipher_mode = p->session.cipher_range_in_bits ? "bit" : "byte";
+ const char *auth_mode = p->session.auth_range_in_bits ? "bit" : "byte";
-
-
-
-
- const char *auth_mode = p->is_bit_mode_auth ? "bit" : "byte";
-
- switch (p->op_type) {
+ switch (p->session.op_type) {
case ODP_CRYPTO_OP_TYPE_LEGACY:
printf("legacy ");
break;
@@ -72,7 +69,7 @@ static void print_alg_test_param(const crypto_op_test_param_t *p)
printf("out-of-place ");
break;
}
- printf("%s\n", p->op == ODP_CRYPTO_OP_ENCODE ? "encode" : "decode");
+ printf("%s\n", p->session.op == ODP_CRYPTO_OP_ENCODE ? "encode" : "decode");
printf("cipher: %s, %s mode\n", cipher_alg_name(p->ref->cipher), cipher_mode);
printf(" key length: %d, iv length: %d\n",
@@ -93,7 +90,7 @@ static void print_alg_test_param(const crypto_op_test_param_t *p)
printf("header length: %d, trailer length: %d\n", p->header_len, p->trailer_len);
if (p->adjust_segmentation)
printf("segmentation adjusted, first_seg_len: %d\n", p->first_seg_len);
- if (p->op_type == ODP_CRYPTO_OP_TYPE_OOP)
+ if (p->session.op_type == ODP_CRYPTO_OP_TYPE_OOP)
printf("oop_shift: %d\n", p->oop_shift);
}
@@ -122,7 +119,7 @@ static void alg_test_op(crypto_op_test_param_t *param)
for (uint32_t n = 0; n < ARRAY_SIZE(oop_shifts); n++) {
if (oop_shifts[n] != 0 &&
- param->op_type != ODP_CRYPTO_OP_TYPE_OOP)
+ param->session.op_type != ODP_CRYPTO_OP_TYPE_OOP)
continue;
if ((int32_t)param->header_len + oop_shifts[n] < 0)
continue;
@@ -150,13 +147,11 @@ typedef enum {
AUTH_PLAINTEXT
} alg_order_t;
-static odp_crypto_session_t session_create(odp_crypto_op_t op,
- odp_crypto_op_type_t op_type,
- alg_order_t order,
- crypto_test_reference_t *ref,
- hash_test_mode_t hash_mode)
+static int session_create(crypto_session_t *session,
+ alg_order_t order,
+ crypto_test_reference_t *ref,
+ hash_test_mode_t hash_mode)
{
- odp_crypto_session_t session = ODP_CRYPTO_SESSION_INVALID;
int rc;
odp_crypto_ses_create_err_t status;
odp_crypto_session_param_t ses_params;
@@ -176,8 +171,10 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
/* Create a crypto session */
odp_crypto_session_param_init(&ses_params);
- ses_params.op = op;
- ses_params.op_type = op_type;
+ ses_params.op = session->op;
+ ses_params.op_type = session->op_type;
+ ses_params.cipher_range_in_bits = session->cipher_range_in_bits;
+ ses_params.auth_range_in_bits = session->auth_range_in_bits;
ses_params.auth_cipher_text = (order == AUTH_CIPHERTEXT);
ses_params.op_mode = suite_context.op_mode;
ses_params.cipher_alg = ref->cipher;
@@ -191,7 +188,7 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
ses_params.auth_digest_len = ref->digest_length;
ses_params.auth_aad_len = ref->aad_length;
ses_params.hash_result_in_auth_range = (hash_mode == HASH_OVERLAP);
- rc = odp_crypto_session_create(&ses_params, &session, &status);
+ rc = odp_crypto_session_create(&ses_params, &session->session, &status);
if (rc < 0 && status == ODP_CRYPTO_SES_ERR_ALG_COMBO) {
if (!combo_warning_shown) {
@@ -200,7 +197,7 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
cipher_alg_name(ref->cipher),
auth_alg_name(ref->auth));
}
- return ODP_CRYPTO_SESSION_INVALID;
+ return -1;
}
/*
@@ -214,21 +211,21 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
cipher_alg_name(ref->cipher),
auth_alg_name(ref->auth),
ses_params.auth_cipher_text);
- return ODP_CRYPTO_SESSION_INVALID;
+ return -1;
}
/* For now, allow out-of-place sessions not to be supported. */
if (rc < 0 && status == ODP_CRYPTO_SES_ERR_PARAMS &&
- op_type == ODP_CRYPTO_OP_TYPE_OOP) {
+ ses_params.op_type == ODP_CRYPTO_OP_TYPE_OOP) {
if (!oop_warning_shown)
printf("\n Skipping ODP_CRYPTO_OP_TYPE_OOP tests\n");
oop_warning_shown = 1;
- return ODP_CRYPTO_SESSION_INVALID;
+ return -1;
}
CU_ASSERT_FATAL(!rc);
CU_ASSERT(status == ODP_CRYPTO_SES_ERR_NONE);
- CU_ASSERT(odp_crypto_session_to_u64(session) !=
+ CU_ASSERT(odp_crypto_session_to_u64(session->session) !=
odp_crypto_session_to_u64(ODP_CRYPTO_SESSION_INVALID));
/*
@@ -239,7 +236,7 @@ static odp_crypto_session_t session_create(odp_crypto_op_t op,
memset(auth_key_data, 0, sizeof(auth_key_data));
memset(&ses_params, 0, sizeof(ses_params));
- return session;
+ return 0;
}
static void alg_test_ses(odp_crypto_op_t op,
@@ -249,35 +246,32 @@ static void alg_test_ses(odp_crypto_op_t op,
odp_packet_data_range_t cipher_range,
odp_packet_data_range_t auth_range,
uint32_t digest_offset,
- odp_bool_t is_bit_mode_cipher,
- odp_bool_t is_bit_mode_auth)
+ odp_bool_t cipher_range_in_bits,
+ odp_bool_t auth_range_in_bits)
{
unsigned int initial_num_failures = CU_get_number_of_failures();
const uint32_t reflength = ref_length_in_bytes(ref);
+ const uint32_t auth_scale = auth_range_in_bits ? 8 : 1;
hash_test_mode_t hash_mode = HASH_NO_OVERLAP;
- odp_crypto_session_t session;
int rc;
uint32_t seg_len;
uint32_t max_shift;
crypto_op_test_param_t test_param;
- if (digest_offset >= auth_range.offset &&
- digest_offset < auth_range.offset + auth_range.length)
+ if (digest_offset * auth_scale >= auth_range.offset &&
+ digest_offset * auth_scale < auth_range.offset + auth_range.length)
hash_mode = HASH_OVERLAP;
- session = session_create(op, op_type, order, ref, hash_mode);
- if (session == ODP_CRYPTO_SESSION_INVALID)
- return;
-
memset(&test_param, 0, sizeof(test_param));
- test_param.session = session;
- test_param.op = op;
- test_param.op_type = op_type;
+ test_param.session.op = op;
+ test_param.session.op_type = op_type;
+ test_param.session.cipher_range_in_bits = cipher_range_in_bits;
+ test_param.session.auth_range_in_bits = auth_range_in_bits;
+ if (session_create(&test_param.session, order, ref, hash_mode))
+ return;
test_param.ref = ref;
test_param.cipher_range = cipher_range;
test_param.auth_range = auth_range;
- test_param.is_bit_mode_cipher = is_bit_mode_cipher;
- test_param.is_bit_mode_auth = is_bit_mode_auth;
test_param.digest_offset = digest_offset;
alg_test_op(&test_param);
@@ -319,18 +313,18 @@ static void alg_test_ses(odp_crypto_op_t op,
alg_test_op(&test_param);
}
- rc = odp_crypto_session_destroy(session);
+ rc = odp_crypto_session_destroy(test_param.session.session);
CU_ASSERT(!rc);
}
-static void alg_test(odp_crypto_op_t op,
- alg_order_t order,
- crypto_test_reference_t *ref,
- odp_packet_data_range_t cipher_range,
- odp_packet_data_range_t auth_range,
- uint32_t digest_offset,
- odp_bool_t is_bit_mode_cipher,
- odp_bool_t is_bit_mode_auth)
+static void alg_test_op_types(odp_crypto_op_t op,
+ alg_order_t order,
+ crypto_test_reference_t *ref,
+ odp_packet_data_range_t cipher_range,
+ odp_packet_data_range_t auth_range,
+ uint32_t digest_offset,
+ odp_bool_t cipher_range_in_bits,
+ odp_bool_t auth_range_in_bits)
{
odp_crypto_op_type_t op_types[] = {
ODP_CRYPTO_OP_TYPE_LEGACY,
@@ -346,8 +340,47 @@ static void alg_test(odp_crypto_op_t op,
cipher_range,
auth_range,
digest_offset,
- is_bit_mode_cipher,
- is_bit_mode_auth);
+ cipher_range_in_bits,
+ auth_range_in_bits);
+ }
+}
+
+static void alg_test(odp_crypto_op_t op,
+ alg_order_t order,
+ crypto_test_reference_t *ref,
+ odp_packet_data_range_t cipher_bit_range,
+ odp_packet_data_range_t auth_bit_range,
+ uint32_t digest_offset,
+ odp_bool_t is_bit_mode_cipher,
+ odp_bool_t is_bit_mode_auth)
+{
+ odp_packet_data_range_t cipher_range;
+ odp_packet_data_range_t auth_range;
+
+ for (int cr_in_bits = 0; cr_in_bits <= 1; cr_in_bits++) {
+ if (!cr_in_bits && cipher_bit_range.length % 8 != 0)
+ continue;
+ if (cr_in_bits && !is_bit_mode_cipher)
+ continue;
+ for (int ar_in_bits = 0; ar_in_bits <= 1; ar_in_bits++) {
+ if (!ar_in_bits && auth_bit_range.length % 8 != 0)
+ continue;
+ if (ar_in_bits && !is_bit_mode_auth)
+ continue;
+
+ cipher_range = cipher_bit_range;
+ auth_range = auth_bit_range;
+ if (!cr_in_bits) {
+ cipher_range.offset /= 8;
+ cipher_range.length /= 8;
+ }
+ if (!ar_in_bits) {
+ auth_range.offset /= 8;
+ auth_range.length /= 8;
+ }
+ alg_test_op_types(op, order, ref, cipher_range, auth_range,
+ digest_offset, cr_in_bits, ar_in_bits);
+ }
}
}
@@ -404,8 +437,8 @@ static void check_alg(odp_crypto_op_t op,
odp_bool_t is_bit_mode_cipher = false;
odp_bool_t is_bit_mode_auth = false;
uint32_t digest_offs = ref_length_in_bytes(&ref[idx]);
- odp_packet_data_range_t cipher_range = {.offset = 0};
- odp_packet_data_range_t auth_range = {.offset = 0};
+ odp_packet_data_range_t cipher_bit_range = {.offset = 0};
+ odp_packet_data_range_t auth_bit_range = {.offset = 0};
if (ref_length_in_bits(&ref[idx]) % 8 != 0)
bit_mode_needed = true;
@@ -465,18 +498,14 @@ static void check_alg(odp_crypto_op_t op,
continue;
}
- cipher_range.length = is_bit_mode_cipher ?
- ref_length_in_bits(&ref[idx]) :
- ref_length_in_bytes(&ref[idx]);
- auth_range.length = is_bit_mode_auth ?
- ref_length_in_bits(&ref[idx]) :
- ref_length_in_bytes(&ref[idx]);
+ cipher_bit_range.length = ref_length_in_bits(&ref[idx]);
+ auth_bit_range.length = ref_length_in_bits(&ref[idx]);
alg_test(op, AUTH_PLAINTEXT, &ref[idx],
- cipher_range, auth_range, digest_offs,
+ cipher_bit_range, auth_bit_range, digest_offs,
is_bit_mode_cipher, is_bit_mode_auth);
alg_test(op, AUTH_CIPHERTEXT, &ref[idx],
- cipher_range, auth_range, digest_offs,
+ cipher_bit_range, auth_bit_range, digest_offs,
is_bit_mode_cipher, is_bit_mode_auth);
cipher_tested[cipher_idx] = true;
@@ -537,7 +566,7 @@ static int create_hash_test_reference(odp_auth_alg_t auth,
uint32_t digest_offset,
uint8_t digest_fill)
{
- odp_crypto_session_t session;
+ crypto_session_t session;
int rc;
odp_packet_t pkt;
odp_bool_t ok;
@@ -570,33 +599,33 @@ static int create_hash_test_reference(odp_auth_alg_t auth,
rc = odp_packet_copy_from_mem(pkt, 0, auth_bytes, ref->plaintext);
CU_ASSERT(rc == 0);
- session = session_create(ODP_CRYPTO_OP_ENCODE,
- ODP_CRYPTO_OP_TYPE_LEGACY,
- AUTH_PLAINTEXT, ref, HASH_NO_OVERLAP);
- if (session == ODP_CRYPTO_SESSION_INVALID)
+ session.op = ODP_CRYPTO_OP_ENCODE;
+ session.op_type = ODP_CRYPTO_OP_TYPE_LEGACY;
+ session.cipher_range_in_bits = false;
+ session.auth_range_in_bits = false;
+ if (session_create(&session, AUTH_PLAINTEXT, ref, HASH_NO_OVERLAP))
return -1;
odp_crypto_packet_op_param_t op_params = {
- .session = session,
+ .session = session.session,
.cipher_iv_ptr = ref->cipher_iv,
.auth_iv_ptr = ref->auth_iv,
.hash_result_offset = enc_digest_offset,
.aad_ptr = ref->aad,
.cipher_range = {.offset = 0, .length = 0},
- .auth_range = { .offset = 0,
- .length = capa->bit_mode ? auth_bytes * 8 : auth_bytes },
+ .auth_range = { .offset = 0, .length = auth_bytes },
.dst_offset_shift = 0,
};
rc = crypto_op(pkt, &pkt, &ok, &op_params, ODP_CRYPTO_OP_TYPE_LEGACY);
CU_ASSERT(rc == 0);
if (rc) {
- (void)odp_crypto_session_destroy(session);
+ (void)odp_crypto_session_destroy(session.session);
return -1;
}
CU_ASSERT(ok);
- rc = odp_crypto_session_destroy(session);
+ rc = odp_crypto_session_destroy(session.session);
CU_ASSERT(rc == 0);
/* copy the processed packet to the ciphertext packet in ref */
@@ -624,8 +653,8 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
{
static crypto_test_reference_t ref = {.length = 0};
uint32_t digest_offset = 13;
- const odp_packet_data_range_t cipher_range = {.offset = 0, .length = 0};
- odp_packet_data_range_t auth_range;
+ const odp_packet_data_range_t cipher_bit_range = {.offset = 0, .length = 0};
+ odp_packet_data_range_t auth_bit_range;
if (!full_test && capa->digest_len % 4 != 0)
return;
@@ -637,10 +666,8 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
if (create_hash_test_reference(auth, capa, &ref, digest_offset, 0))
return;
- auth_range.offset = 0;
- auth_range.length = capa->bit_mode ?
- ref_length_in_bits(&ref) :
- ref_length_in_bytes(&ref);
+ auth_bit_range.offset = 0;
+ auth_bit_range.length = ref_length_in_bits(&ref);
/*
* Decode the ciphertext packet.
@@ -652,7 +679,7 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
alg_test(ODP_CRYPTO_OP_DECODE,
order,
&ref,
- cipher_range, auth_range,
+ cipher_bit_range, auth_bit_range,
digest_offset,
false,
capa->bit_mode);
@@ -664,10 +691,8 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
if (create_hash_test_reference(auth, capa, &ref, digest_offset, 1))
return;
- auth_range.offset = 0;
- auth_range.length = capa->bit_mode ?
- ref_length_in_bits(&ref) :
- ref_length_in_bytes(&ref);
+ auth_bit_range.offset = 0;
+ auth_bit_range.length = ref_length_in_bits(&ref);
/*
* Encode the plaintext packet.
@@ -679,7 +704,7 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
alg_test(ODP_CRYPTO_OP_ENCODE,
order,
&ref,
- cipher_range, auth_range,
+ cipher_bit_range, auth_bit_range,
digest_offset,
false,
capa->bit_mode);
@@ -689,6 +714,7 @@ static void test_auth_hash_in_auth_range(odp_auth_alg_t auth,
* Cipher algorithms that are not AEAD algorithms
*/
static odp_cipher_alg_t cipher_algs[] = {
+ ODP_CIPHER_ALG_NULL,
ODP_CIPHER_ALG_DES,
ODP_CIPHER_ALG_3DES_CBC,
ODP_CIPHER_ALG_3DES_ECB,
@@ -704,10 +730,11 @@ static odp_cipher_alg_t cipher_algs[] = {
};
/*
- * Authentication algorithms and hashes that use auth_range
+ * Authentication algorithms and hashes that may use auth_range
* parameter. AEAD algorithms are excluded.
*/
static odp_auth_alg_t auth_algs[] = {
+ ODP_AUTH_ALG_NULL,
ODP_AUTH_ALG_MD5_HMAC,
ODP_AUTH_ALG_SHA1_HMAC,
ODP_AUTH_ALG_SHA224_HMAC,
@@ -763,7 +790,7 @@ static int crypto_encode_ref(crypto_test_reference_t *ref,
odp_packet_data_range_t zero_range = {.offset = 0, .length = 0};
odp_packet_t pkt;
int rc;
- odp_crypto_session_t session;
+ crypto_session_t session;
odp_bool_t ok;
pkt = odp_packet_alloc(suite_context.pool, ref->length);
@@ -772,13 +799,11 @@ static int crypto_encode_ref(crypto_test_reference_t *ref,
rc = odp_packet_copy_from_mem(pkt, 0, ref->length, ref->plaintext);
CU_ASSERT(rc == 0);
- session = session_create(ODP_CRYPTO_OP_ENCODE,
- ODP_CRYPTO_OP_TYPE_LEGACY,
- AUTH_PLAINTEXT,
- ref,
- HASH_OVERLAP);
-
- if (session == ODP_CRYPTO_SESSION_INVALID) {
+ session.op = ODP_CRYPTO_OP_ENCODE;
+ session.op_type = ODP_CRYPTO_OP_TYPE_LEGACY;
+ session.cipher_range_in_bits = false;
+ session.auth_range_in_bits = false;
+ if (session_create(&session, AUTH_PLAINTEXT, ref, HASH_OVERLAP)) {
odp_packet_free(pkt);
return 1;
}
@@ -793,7 +818,7 @@ static int crypto_encode_ref(crypto_test_reference_t *ref,
CU_ASSERT_FATAL(hash_result_offset + ref->digest_length <= ref->length);
odp_crypto_packet_op_param_t op_params = {
- .session = session,
+ .session = session.session,
.cipher_iv_ptr = ref->cipher_iv,
.auth_iv_ptr = ref->auth_iv,
.hash_result_offset = hash_result_offset,
@@ -805,12 +830,12 @@ static int crypto_encode_ref(crypto_test_reference_t *ref,
rc = crypto_op(pkt, &pkt, &ok, &op_params, ODP_CRYPTO_OP_TYPE_LEGACY);
CU_ASSERT(rc == 0);
if (rc) {
- (void)odp_crypto_session_destroy(session);
+ (void)odp_crypto_session_destroy(session.session);
return -1;
}
CU_ASSERT(ok);
- rc = odp_crypto_session_destroy(session);
+ rc = odp_crypto_session_destroy(session.session);
CU_ASSERT(rc == 0);
rc = odp_packet_copy_to_mem(pkt, 0, ref->length, ref->ciphertext);
@@ -834,8 +859,8 @@ typedef struct crypto_suite_t {
*/
static int create_combined_ref(const crypto_suite_t *suite,
crypto_test_reference_t *ref,
- odp_packet_data_range_t *cipher_range,
- odp_packet_data_range_t *auth_range,
+ const odp_packet_data_range_t *cipher_range,
+ const odp_packet_data_range_t *auth_range,
uint32_t digest_offset)
{
uint32_t total_len;
@@ -861,15 +886,6 @@ static int create_combined_ref(const crypto_suite_t *suite,
ref->is_length_in_bits = false;
ref->length = total_len;
- if (suite->cipher_capa->bit_mode) {
- cipher_range->offset *= 8;
- cipher_range->length *= 8;
- }
- if (suite->auth_capa->bit_mode) {
- auth_range->offset *= 8;
- auth_range->length *= 8;
- }
-
if (ref->auth_key_length > MAX_KEY_LEN ||
ref->auth_iv_length > MAX_IV_LEN ||
total_len > MAX_DATA_LEN ||
@@ -1189,6 +1205,11 @@ static void test_combo(const crypto_suite_t *suite,
if (rc)
return;
+ cipher_range.offset *= 8;
+ cipher_range.length *= 8;
+ auth_range.offset *= 8;
+ auth_range.length *= 8;
+
alg_test(ODP_CRYPTO_OP_ENCODE,
suite->order,
&ref,
diff --git a/test/validation/api/dma/dma.c b/test/validation/api/dma/dma.c
index 6c8eeb00c..05771e3cb 100644
--- a/test/validation/api/dma/dma.c
+++ b/test/validation/api/dma/dma.c
@@ -19,6 +19,8 @@
#define MULTI 1
#define RESULT 1
#define USER_DATA 0xdeadbeef
+#define ELEM_NUM 10
+#define UAREA 0xaa
#define MIN(a, b) (a < b ? a : b)
@@ -39,6 +41,11 @@ typedef struct global_t {
} global_t;
+typedef struct {
+ uint32_t count;
+ uint8_t mark[ELEM_NUM];
+} uarea_init_t;
+
static global_t global;
static int dma_suite_init(void)
@@ -234,6 +241,8 @@ static void test_dma_param(uint8_t fill)
memset(&dma_pool_param, fill, sizeof(dma_pool_param));
odp_dma_pool_param_init(&dma_pool_param);
+ CU_ASSERT(dma_pool_param.uarea_init.init_fn == NULL);
+ CU_ASSERT(dma_pool_param.uarea_init.args == NULL);
CU_ASSERT(dma_pool_param.uarea_size == 0);
CU_ASSERT(dma_pool_param.cache_size <= global.dma_capa.pool.max_cache_size);
CU_ASSERT(dma_pool_param.cache_size >= global.dma_capa.pool.min_cache_size);
@@ -417,7 +426,7 @@ static void test_dma_compl_pool_max_pools(void)
static void test_dma_compl_user_area(void)
{
odp_dma_pool_param_t dma_pool_param;
- uint32_t num = MIN(10, global.dma_capa.pool.max_num),
+ uint32_t num = MIN(ELEM_NUM, global.dma_capa.pool.max_num),
size = global.dma_capa.pool.max_uarea_size, i;
odp_pool_t pool;
odp_dma_compl_t compl_evs[num];
@@ -432,6 +441,7 @@ static void test_dma_compl_user_area(void)
for (i = 0; i < num; i++) {
odp_event_t ev;
+ int flag;
compl_evs[i] = odp_dma_compl_alloc(pool);
@@ -445,6 +455,8 @@ static void test_dma_compl_user_area(void)
ev = odp_dma_compl_to_event(compl_evs[i]);
CU_ASSERT(odp_event_user_area(ev) == addr);
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr);
+ CU_ASSERT(flag < 0);
prev = addr;
memset(addr, 0, size);
@@ -458,6 +470,56 @@ static void test_dma_compl_user_area(void)
CU_ASSERT(odp_pool_destroy(pool) == 0);
}
+static void init_event_uarea(void *uarea, uint32_t size, void *args, uint32_t index)
+{
+ uarea_init_t *data = args;
+
+ data->count++;
+ data->mark[index] = 1;
+ memset(uarea, UAREA, size);
+}
+
+static void test_dma_compl_user_area_init(void)
+{
+ odp_dma_pool_param_t dma_pool_param;
+ uint32_t num = MIN(ELEM_NUM, global.dma_capa.pool.max_num), i;
+ odp_pool_t pool;
+ uarea_init_t data;
+ odp_dma_compl_t compl_evs[num];
+ uint8_t *uarea;
+
+ memset(&data, 0, sizeof(uarea_init_t));
+ odp_dma_pool_param_init(&dma_pool_param);
+ dma_pool_param.uarea_init.init_fn = init_event_uarea;
+ dma_pool_param.uarea_init.args = &data;
+ dma_pool_param.num = num;
+ dma_pool_param.uarea_size = 1;
+ pool = odp_dma_pool_create(NULL, &dma_pool_param);
+
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+ CU_ASSERT(data.count == num);
+
+ for (i = 0; i < num; i++) {
+ CU_ASSERT(data.mark[i] == 1);
+
+ compl_evs[i] = odp_dma_compl_alloc(pool);
+
+ CU_ASSERT(compl_evs[i] != ODP_DMA_COMPL_INVALID);
+
+ if (compl_evs[i] == ODP_DMA_COMPL_INVALID)
+ break;
+
+ uarea = odp_dma_compl_user_area(compl_evs[i]);
+
+ CU_ASSERT(*uarea == UAREA);
+ }
+
+ for (uint32_t j = 0; j < i; j++)
+ odp_dma_compl_free(compl_evs[j]);
+
+ odp_pool_destroy(pool);
+}
+
static void init_source(uint8_t *src, uint32_t len)
{
uint32_t i;
@@ -1171,6 +1233,17 @@ static int check_event_user_area(void)
return ODP_TEST_INACTIVE;
}
+static int check_event_user_area_init(void)
+{
+ if (global.disabled)
+ return ODP_TEST_INACTIVE;
+
+ if (global.dma_capa.pool.max_uarea_size > 0 && global.dma_capa.pool.uarea_persistence)
+ return ODP_TEST_ACTIVE;
+
+ return ODP_TEST_INACTIVE;
+}
+
static int check_scheduled(void)
{
if (global.disabled)
@@ -1568,6 +1641,7 @@ odp_testinfo_t dma_suite[] = {
ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool_same_name, check_event),
ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool_max_pools, check_event),
ODP_TEST_INFO_CONDITIONAL(test_dma_compl_user_area, check_event_user_area),
+ ODP_TEST_INFO_CONDITIONAL(test_dma_compl_user_area_init, check_event_user_area_init),
ODP_TEST_INFO_CONDITIONAL(test_dma_addr_to_addr_sync, check_sync),
ODP_TEST_INFO_CONDITIONAL(test_dma_addr_to_addr_sync_mtrs, check_sync),
ODP_TEST_INFO_CONDITIONAL(test_dma_addr_to_addr_sync_mseg, check_sync),
diff --git a/test/validation/api/event/event.c b/test/validation/api/event/event.c
index 1d6422f96..f6ad86365 100644
--- a/test/validation/api/event/event.c
+++ b/test/validation/api/event/event.c
@@ -1,4 +1,5 @@
/* Copyright (c) 2017-2018, Linaro Limited
+ * Copyright (c) 2023, Nokia
* All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
@@ -349,6 +350,50 @@ static void event_test_type_multi(void)
CU_ASSERT(odp_pool_destroy(pkt_pool) == 0);
}
+static void event_test_types_multi(void)
+{
+ odp_pool_t buf_pool, pkt_pool;
+ odp_event_t buf_event[NUM_TYPE_TEST];
+ odp_event_t pkt_event[NUM_TYPE_TEST];
+ odp_event_t event[2 * NUM_TYPE_TEST];
+ odp_event_type_t event_types[2 * NUM_TYPE_TEST];
+ odp_event_subtype_t event_subtypes[2 * NUM_TYPE_TEST];
+ int i;
+
+ type_test_init(&buf_pool, &pkt_pool, buf_event, pkt_event, event);
+
+ /* Only buffers */
+ odp_event_types_multi(buf_event, event_types, event_subtypes, NUM_TYPE_TEST);
+ for (i = 0; i < NUM_TYPE_TEST; i++) {
+ CU_ASSERT(event_types[i] == ODP_EVENT_BUFFER);
+ CU_ASSERT(event_subtypes[i] == ODP_EVENT_NO_SUBTYPE);
+ }
+
+ /* Only packets */
+ odp_event_types_multi(pkt_event, event_types, event_subtypes, NUM_TYPE_TEST);
+ for (i = 0; i < NUM_TYPE_TEST; i++) {
+ CU_ASSERT(event_types[i] == ODP_EVENT_PACKET);
+ CU_ASSERT(event_subtypes[i] == ODP_EVENT_PACKET_BASIC);
+ }
+
+ /* Mixed events: B P BB PP BBB PPP */
+ odp_event_types_multi(event, event_types, NULL, 2 * NUM_TYPE_TEST);
+ for (i = 0; i < 2 * NUM_TYPE_TEST; i++) {
+ if (i == 0 || i == 2 || i == 3 || i == 6 || i == 7 || i == 8) {
+ /* CU_ASSERT requires extra brackets */
+ CU_ASSERT(event_types[i] == ODP_EVENT_BUFFER);
+ } else {
+ CU_ASSERT(event_types[i] == ODP_EVENT_PACKET);
+ }
+ }
+
+ odp_event_free_multi(buf_event, NUM_TYPE_TEST);
+ odp_event_free_multi(pkt_event, NUM_TYPE_TEST);
+
+ CU_ASSERT(odp_pool_destroy(buf_pool) == 0);
+ CU_ASSERT(odp_pool_destroy(pkt_pool) == 0);
+}
+
static void event_test_filter_packet(void)
{
odp_pool_t buf_pool, pkt_pool;
@@ -400,6 +445,7 @@ odp_testinfo_t event_suite[] = {
ODP_TEST_INFO(event_test_free_multi),
ODP_TEST_INFO(event_test_free_multi_mixed),
ODP_TEST_INFO(event_test_type_multi),
+ ODP_TEST_INFO(event_test_types_multi),
ODP_TEST_INFO(event_test_filter_packet),
ODP_TEST_INFO(event_test_is_valid),
ODP_TEST_INFO_NULL,
diff --git a/test/validation/api/ipsec/ipsec.c b/test/validation/api/ipsec/ipsec.c
index ea2685666..87688838b 100644
--- a/test/validation/api/ipsec/ipsec.c
+++ b/test/validation/api/ipsec/ipsec.c
@@ -447,6 +447,7 @@ static void ipsec_status_event_handle(odp_event_t ev_status,
odp_ipsec_sa_t sa,
enum ipsec_test_sa_expiry sa_expiry)
{
+ int flag;
odp_ipsec_status_t status = {
.id = 0,
.sa = ODP_IPSEC_SA_INVALID,
@@ -460,6 +461,8 @@ static void ipsec_status_event_handle(odp_event_t ev_status,
/* No user area for IPsec status events */
CU_ASSERT(odp_event_user_area(ev_status) == NULL);
+ CU_ASSERT(odp_event_user_area_and_flag(ev_status, &flag) == NULL);
+ CU_ASSERT(flag < 0);
CU_ASSERT_EQUAL(0, odp_ipsec_status(&status, ev_status));
CU_ASSERT_EQUAL(ODP_IPSEC_STATUS_WARN, status.id);
diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c
index a7631d47c..43530220e 100644
--- a/test/validation/api/packet/packet.c
+++ b/test/validation/api/packet/packet.c
@@ -3262,6 +3262,7 @@ static void packet_vector_test_user_area(void)
for (i = 0; i < num; i++) {
odp_event_t ev;
+ int flag;
pktv[i] = odp_packet_vector_alloc(pool);
@@ -3275,6 +3276,8 @@ static void packet_vector_test_user_area(void)
ev = odp_packet_vector_to_event(pktv[i]);
CU_ASSERT(odp_event_user_area(ev) == addr);
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr);
+ CU_ASSERT(flag == 0);
prev = addr;
memset(addr, 0, size);
@@ -3448,6 +3451,7 @@ static void packet_test_user_area(void)
odp_packet_t pkt;
odp_pool_t pool;
odp_event_t ev;
+ int flag;
memcpy(&param, &default_param, sizeof(odp_pool_param_t));
@@ -3465,6 +3469,8 @@ static void packet_test_user_area(void)
}
ev = odp_packet_to_event(pkt);
CU_ASSERT(odp_event_user_area(ev) == odp_packet_user_area(pkt));
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt));
+ CU_ASSERT(flag == 0);
odp_packet_free(pkt);
CU_ASSERT(odp_pool_destroy(pool) == 0);
@@ -3480,6 +3486,8 @@ static void packet_test_user_area(void)
CU_ASSERT_FATAL(odp_packet_user_area(pkt) != NULL);
ev = odp_packet_to_event(pkt);
CU_ASSERT(odp_event_user_area(ev) == odp_packet_user_area(pkt));
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt));
+ CU_ASSERT(flag == 0);
CU_ASSERT(odp_packet_user_area_size(pkt) >= 1);
*(char *)odp_packet_user_area(pkt) = 0;
CU_ASSERT_FATAL(odp_packet_is_valid(pkt) == 1);
@@ -3491,9 +3499,12 @@ static void packet_test_user_area(void)
CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
pkt = odp_packet_alloc(pool, param.pkt.len);
CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
+ odp_packet_user_flag_set(pkt, 1);
CU_ASSERT_FATAL(odp_packet_user_area(pkt) != NULL);
ev = odp_packet_to_event(pkt);
CU_ASSERT(odp_event_user_area(ev) == odp_packet_user_area(pkt));
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt));
+ CU_ASSERT(flag > 0);
CU_ASSERT(odp_packet_user_area_size(pkt) == param.pkt.uarea_size);
memset(odp_packet_user_area(pkt), 0, param.pkt.uarea_size);
CU_ASSERT_FATAL(odp_packet_is_valid(pkt) == 1);
diff --git a/test/validation/api/pktio/pktio.c b/test/validation/api/pktio/pktio.c
index f412a01c4..fa752c0a2 100644
--- a/test/validation/api/pktio/pktio.c
+++ b/test/validation/api/pktio/pktio.c
@@ -3513,7 +3513,7 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue)
pktio_info_t pktio_rx_info;
odp_pktio_config_t config;
odp_queue_param_t qparam;
- int ret, i, num_rx = 0;
+ int flag, ret, i, num_rx = 0;
odp_event_t ev;
uint64_t wait;
@@ -3647,6 +3647,8 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue)
/* No user area for TX completion events */
CU_ASSERT(odp_event_user_area(ev) == NULL);
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == NULL);
+ CU_ASSERT(flag < 0);
/* Alternatively call event free / compl free */
if (i % 2)
@@ -3685,6 +3687,8 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue)
/* No user area for TX completion events */
CU_ASSERT(odp_event_user_area(ev) == NULL);
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == NULL);
+ CU_ASSERT(flag < 0);
/* Check that sequence number is found */
CU_ASSERT(j < TX_BATCH_LEN);
diff --git a/test/validation/api/pool/pool.c b/test/validation/api/pool/pool.c
index b335f194c..5176bb96f 100644
--- a/test/validation/api/pool/pool.c
+++ b/test/validation/api/pool/pool.c
@@ -20,8 +20,11 @@
#define VEC_LEN 32
#define PKT_LEN 400
#define PKT_NUM 500
+#define ELEM_NUM 10
+#define ELEM_SIZE 128
#define CACHE_SIZE 32
#define MAX_NUM_DEFAULT (10 * 1024 * 1024)
+#define UAREA 0xaa
#define EXT_NUM_BUF 10
#define EXT_BUF_SIZE 2048
@@ -31,6 +34,8 @@
#define EXT_HEADROOM 16
#define MAGIC_U8 0x7a
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+
typedef struct {
odp_barrier_t init_barrier;
odp_atomic_u32_t index;
@@ -38,6 +43,11 @@ typedef struct {
odp_pool_t pool;
} global_shared_mem_t;
+typedef struct {
+ uint32_t count;
+ uint8_t mark[ELEM_NUM];
+} uarea_init_t;
+
static global_shared_mem_t *global_mem;
static odp_pool_capability_t global_pool_capa;
@@ -51,6 +61,9 @@ static void test_param_init(uint8_t fill)
memset(&param, fill, sizeof(param));
odp_pool_param_init(&param);
+ CU_ASSERT(param.uarea_init.init_fn == NULL);
+ CU_ASSERT(param.uarea_init.args == NULL);
+
CU_ASSERT(param.buf.uarea_size == 0);
CU_ASSERT(param.buf.cache_size >= global_pool_capa.buf.min_cache_size &&
param.buf.cache_size <= global_pool_capa.buf.max_cache_size);
@@ -146,6 +159,218 @@ static void pool_test_create_destroy_vector(void)
pool_create_destroy(&param);
}
+static int pool_check_buffer_uarea_init(void)
+{
+ if (global_pool_capa.buf.max_uarea_size == 0 || !global_pool_capa.buf.uarea_persistence)
+ return ODP_TEST_INACTIVE;
+
+ return ODP_TEST_ACTIVE;
+}
+
+static int pool_check_packet_uarea_init(void)
+{
+ if (global_pool_capa.pkt.max_uarea_size == 0 || !global_pool_capa.pkt.uarea_persistence)
+ return ODP_TEST_INACTIVE;
+
+ return ODP_TEST_ACTIVE;
+}
+
+static int pool_check_vector_uarea_init(void)
+{
+ if (global_pool_capa.vector.max_uarea_size == 0 ||
+ !global_pool_capa.vector.uarea_persistence)
+ return ODP_TEST_INACTIVE;
+
+ return ODP_TEST_ACTIVE;
+}
+
+static int pool_check_timeout_uarea_init(void)
+{
+ if (global_pool_capa.tmo.max_uarea_size == 0 || !global_pool_capa.tmo.uarea_persistence)
+ return ODP_TEST_INACTIVE;
+
+ return ODP_TEST_ACTIVE;
+}
+
+static void init_event_uarea(void *uarea, uint32_t size, void *args, uint32_t index)
+{
+ uarea_init_t *data = args;
+
+ data->count++;
+ data->mark[index] = 1;
+ memset(uarea, UAREA, size);
+}
+
+static void pool_test_buffer_uarea_init(void)
+{
+ odp_pool_param_t param;
+ uint32_t num = MIN(global_pool_capa.buf.max_num, ELEM_NUM),
+ size = MIN(global_pool_capa.buf.max_size, ELEM_SIZE), i;
+ odp_pool_t pool;
+ uarea_init_t data;
+ odp_buffer_t bufs[num];
+ uint8_t *uarea;
+
+ memset(&data, 0, sizeof(uarea_init_t));
+ odp_pool_param_init(&param);
+ param.type = ODP_POOL_BUFFER;
+ param.uarea_init.init_fn = init_event_uarea;
+ param.uarea_init.args = &data;
+ param.buf.num = num;
+ param.buf.size = size;
+ param.buf.uarea_size = 1;
+ pool = odp_pool_create(NULL, &param);
+
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+ CU_ASSERT(data.count == num);
+
+ for (i = 0; i < num; i++) {
+ CU_ASSERT(data.mark[i] == 1);
+
+ bufs[i] = odp_buffer_alloc(pool);
+
+ CU_ASSERT(bufs[i] != ODP_BUFFER_INVALID);
+
+ if (bufs[i] == ODP_BUFFER_INVALID)
+ break;
+
+ uarea = odp_buffer_user_area(bufs[i]);
+
+ CU_ASSERT(*uarea == UAREA);
+ }
+
+ odp_buffer_free_multi(bufs, i);
+ odp_pool_destroy(pool);
+}
+
+static void pool_test_packet_uarea_init(void)
+{
+ odp_pool_param_t param;
+ uint32_t num = MIN(global_pool_capa.pkt.max_num, ELEM_NUM),
+ size = MIN(global_pool_capa.pkt.max_len, ELEM_SIZE), i;
+ odp_pool_t pool;
+ uarea_init_t data;
+ odp_packet_t pkts[num];
+ uint8_t *uarea;
+
+ memset(&data, 0, sizeof(uarea_init_t));
+ odp_pool_param_init(&param);
+ param.type = ODP_POOL_PACKET;
+ param.uarea_init.init_fn = init_event_uarea;
+ param.uarea_init.args = &data;
+ param.pkt.num = num;
+ param.pkt.len = size;
+ param.pkt.uarea_size = 1;
+ pool = odp_pool_create(NULL, &param);
+
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+ CU_ASSERT(data.count == num);
+
+ for (i = 0; i < num; i++) {
+ CU_ASSERT(data.mark[i] == 1);
+
+ pkts[i] = odp_packet_alloc(pool, ELEM_SIZE);
+
+ CU_ASSERT(pkts[i] != ODP_PACKET_INVALID);
+
+ if (pkts[i] == ODP_PACKET_INVALID)
+ break;
+
+ uarea = odp_packet_user_area(pkts[i]);
+
+ CU_ASSERT(*uarea == UAREA);
+ }
+
+ odp_packet_free_multi(pkts, i);
+ odp_pool_destroy(pool);
+}
+
+static void pool_test_vector_uarea_init(void)
+{
+ odp_pool_param_t param;
+ uint32_t num = MIN(global_pool_capa.vector.max_num, ELEM_NUM),
+ size = MIN(global_pool_capa.vector.max_size, ELEM_NUM), i;
+ odp_pool_t pool;
+ uarea_init_t data;
+ odp_packet_vector_t vecs[num];
+ uint8_t *uarea;
+
+ memset(&data, 0, sizeof(uarea_init_t));
+ odp_pool_param_init(&param);
+ param.type = ODP_POOL_VECTOR;
+ param.uarea_init.init_fn = init_event_uarea;
+ param.uarea_init.args = &data;
+ param.vector.num = num;
+ param.vector.max_size = size;
+ param.vector.uarea_size = 1;
+ pool = odp_pool_create(NULL, &param);
+
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+ CU_ASSERT(data.count == num);
+
+ for (i = 0; i < num; i++) {
+ CU_ASSERT(data.mark[i] == 1);
+
+ vecs[i] = odp_packet_vector_alloc(pool);
+
+ CU_ASSERT(vecs[i] != ODP_PACKET_VECTOR_INVALID);
+
+ if (vecs[i] == ODP_PACKET_VECTOR_INVALID)
+ break;
+
+ uarea = odp_packet_vector_user_area(vecs[i]);
+
+ CU_ASSERT(*uarea == UAREA);
+ }
+
+ for (uint32_t j = 0; j < i; j++)
+ odp_packet_vector_free(vecs[j]);
+
+ odp_pool_destroy(pool);
+}
+
+static void pool_test_timeout_uarea_init(void)
+{
+ odp_pool_param_t param;
+ uint32_t num = MIN(global_pool_capa.tmo.max_num, ELEM_NUM), i;
+ odp_pool_t pool;
+ uarea_init_t data;
+ odp_timeout_t tmos[num];
+ uint8_t *uarea;
+
+ memset(&data, 0, sizeof(uarea_init_t));
+ odp_pool_param_init(&param);
+ param.type = ODP_POOL_TIMEOUT;
+ param.uarea_init.init_fn = init_event_uarea;
+ param.uarea_init.args = &data;
+ param.tmo.num = num;
+ param.tmo.uarea_size = 1;
+ pool = odp_pool_create(NULL, &param);
+
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+ CU_ASSERT(data.count == num);
+
+ for (i = 0; i < num; i++) {
+ CU_ASSERT(data.mark[i] == 1);
+
+ tmos[i] = odp_timeout_alloc(pool);
+
+ CU_ASSERT(tmos[i] != ODP_TIMEOUT_INVALID);
+
+ if (tmos[i] == ODP_TIMEOUT_INVALID)
+ break;
+
+ uarea = odp_timeout_user_area(tmos[i]);
+
+ CU_ASSERT(*uarea == UAREA);
+ }
+
+ for (uint32_t j = 0; j < i; j++)
+ odp_timeout_free(tmos[j]);
+
+ odp_pool_destroy(pool);
+}
+
static void pool_test_lookup_info_print(void)
{
odp_pool_t pool;
@@ -1505,6 +1730,8 @@ static void test_ext_param_init(uint8_t fill)
odp_pool_ext_param_init(ODP_POOL_PACKET, &param);
CU_ASSERT(param.type == ODP_POOL_PACKET);
+ CU_ASSERT(param.uarea_init.init_fn == NULL);
+ CU_ASSERT(param.uarea_init.args == NULL);
CU_ASSERT(param.cache_size >= global_pool_ext_capa.min_cache_size &&
param.cache_size <= global_pool_ext_capa.max_cache_size);
CU_ASSERT(param.stats.all == 0);
@@ -1791,6 +2018,57 @@ static void test_packet_pool_ext_alloc(void)
packet_pool_ext_alloc(PKT_LEN_NORMAL);
}
+static void test_packet_pool_ext_uarea_init(void)
+{
+ odp_pool_ext_capability_t capa;
+ odp_pool_ext_param_t param;
+ uint32_t num = ELEM_NUM, i;
+ odp_pool_t pool;
+ uarea_init_t data;
+ odp_shm_t shm;
+ uint8_t *uarea;
+
+ CU_ASSERT_FATAL(odp_pool_ext_capability(ODP_POOL_PACKET, &capa) == 0);
+
+ memset(&data, 0, sizeof(uarea_init_t));
+ pool_ext_init_packet_pool_param(&param);
+ param.uarea_init.init_fn = init_event_uarea;
+ param.uarea_init.args = &data;
+ num = MIN(num, param.pkt.num_buf);
+ param.pkt.num_buf = num;
+ param.pkt.uarea_size = 1;
+ pool = odp_pool_ext_create(NULL, &param);
+
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ void *buf[num];
+ odp_packet_t pkts[num];
+
+ shm = populate_pool(pool, &capa, buf, num, param.pkt.buf_size);
+
+ CU_ASSERT_FATAL(shm != ODP_SHM_INVALID);
+ CU_ASSERT(data.count == num);
+
+ for (i = 0; i < num; i++) {
+ CU_ASSERT(data.mark[i] == 1);
+
+ pkts[i] = odp_packet_alloc(pool, (param.pkt.buf_size - param.pkt.headroom) / 2);
+
+ CU_ASSERT(pkts[i] != ODP_PACKET_INVALID);
+
+ if (pkts[i] == ODP_PACKET_INVALID)
+ break;
+
+ uarea = odp_packet_user_area(pkts[i]);
+
+ CU_ASSERT(*uarea == UAREA);
+ }
+
+ odp_packet_free_multi(pkts, i);
+ odp_pool_destroy(pool);
+ odp_shm_free(shm);
+}
+
static void test_packet_pool_ext_alloc_max(void)
{
packet_pool_ext_alloc(PKT_LEN_MAX);
@@ -1961,6 +2239,15 @@ static int check_pool_ext_support(void)
return ODP_TEST_ACTIVE;
}
+static int check_pool_ext_uarea_init_support(void)
+{
+ if (global_pool_ext_capa.max_pools == 0 || !global_pool_ext_capa.pkt.uarea_persistence ||
+ global_pool_ext_capa.pkt.max_uarea_size == 0)
+ return ODP_TEST_INACTIVE;
+
+ return ODP_TEST_ACTIVE;
+}
+
static int check_pool_ext_segment_support(void)
{
if (global_pool_ext_capa.max_pools == 0 || global_pool_ext_capa.pkt.max_segs_per_pkt < 2)
@@ -1975,6 +2262,10 @@ odp_testinfo_t pool_suite[] = {
ODP_TEST_INFO(pool_test_create_destroy_packet),
ODP_TEST_INFO(pool_test_create_destroy_timeout),
ODP_TEST_INFO(pool_test_create_destroy_vector),
+ ODP_TEST_INFO_CONDITIONAL(pool_test_buffer_uarea_init, pool_check_buffer_uarea_init),
+ ODP_TEST_INFO_CONDITIONAL(pool_test_packet_uarea_init, pool_check_packet_uarea_init),
+ ODP_TEST_INFO_CONDITIONAL(pool_test_vector_uarea_init, pool_check_vector_uarea_init),
+ ODP_TEST_INFO_CONDITIONAL(pool_test_timeout_uarea_init, pool_check_timeout_uarea_init),
ODP_TEST_INFO(pool_test_lookup_info_print),
ODP_TEST_INFO(pool_test_same_name_buf),
ODP_TEST_INFO(pool_test_same_name_pkt),
@@ -2022,6 +2313,8 @@ odp_testinfo_t pool_ext_suite[] = {
ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_info, check_pool_ext_support),
ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_populate, check_pool_ext_support),
ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_alloc, check_pool_ext_support),
+ ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_uarea_init,
+ check_pool_ext_uarea_init_support),
ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_alloc_max, check_pool_ext_support),
ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_alloc_seg, check_pool_ext_segment_support),
ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_disassemble, check_pool_ext_segment_support),
diff --git a/test/validation/api/shmem/shmem.c b/test/validation/api/shmem/shmem.c
index 86d070a4a..257e0214e 100644
--- a/test/validation/api/shmem/shmem.c
+++ b/test/validation/api/shmem/shmem.c
@@ -99,7 +99,7 @@ static int run_test_basic_thread(void *arg ODP_UNUSED)
odp_shm_print_all();
CU_ASSERT(TEST_SHARE_FOO == shared_test_data->foo);
CU_ASSERT(TEST_SHARE_BAR == shared_test_data->bar);
- CU_ASSERT(0 == odp_shm_info(shm, &info));
+ CU_ASSERT_FATAL(0 == odp_shm_info(shm, &info));
CU_ASSERT(0 == strcmp(MEM_NAME, info.name));
CU_ASSERT(0 == info.flags);
CU_ASSERT(shared_test_data == info.addr);
diff --git a/test/validation/api/time/time.c b/test/validation/api/time/time.c
index 22189ce03..7664ec542 100644
--- a/test/validation/api/time/time.c
+++ b/test/validation/api/time/time.c
@@ -216,58 +216,157 @@ static void time_test_monotony(void)
{
volatile uint64_t count = 0;
odp_time_t l_t1, l_t2, l_t3;
+ odp_time_t ls_t1, ls_t2, ls_t3;
odp_time_t g_t1, g_t2, g_t3;
- uint64_t lns_t1, lns_t2, lns_t3;
- uint64_t gns_t1, gns_t2, gns_t3;
+ odp_time_t gs_t1, gs_t2, gs_t3;
+ uint64_t l_ns1, l_ns2, l_ns3;
+ uint64_t ls_ns1, ls_ns2, ls_ns3;
+ uint64_t g_ns1, g_ns2, g_ns3;
+ uint64_t gs_ns1, gs_ns2, gs_ns3;
uint64_t ns1, ns2, ns3;
+ uint64_t s_ns1, s_ns2, s_ns3;
- l_t1 = odp_time_local();
- g_t1 = odp_time_global();
- lns_t1 = odp_time_local_ns();
- gns_t1 = odp_time_global_ns();
+ l_t1 = odp_time_local();
+ ls_t1 = odp_time_local_strict();
+ l_ns1 = odp_time_local_ns();
+ ls_ns1 = odp_time_local_strict_ns();
+
+ g_t1 = odp_time_global();
+ gs_t1 = odp_time_global_strict();
+ g_ns1 = odp_time_global_ns();
+ gs_ns1 = odp_time_global_strict_ns();
while (count < BUSY_LOOP_CNT) {
count++;
};
- l_t2 = odp_time_local();
- g_t2 = odp_time_global();
- lns_t2 = odp_time_local_ns();
- gns_t2 = odp_time_global_ns();
+ l_t2 = odp_time_local();
+ ls_t2 = odp_time_local_strict();
+ l_ns2 = odp_time_local_ns();
+ ls_ns2 = odp_time_local_strict_ns();
+
+ g_t2 = odp_time_global();
+ gs_t2 = odp_time_global_strict();
+ g_ns2 = odp_time_global_ns();
+ gs_ns2 = odp_time_global_strict_ns();
count = 0;
while (count < BUSY_LOOP_CNT) {
count++;
};
- l_t3 = odp_time_local();
- g_t3 = odp_time_global();
- lns_t3 = odp_time_local_ns();
- gns_t3 = odp_time_global_ns();
+ l_t3 = odp_time_local();
+ ls_t3 = odp_time_local_strict();
+ l_ns3 = odp_time_local_ns();
+ ls_ns3 = odp_time_local_strict_ns();
+
+ g_t3 = odp_time_global();
+ gs_t3 = odp_time_global_strict();
+ g_ns3 = odp_time_global_ns();
+ gs_ns3 = odp_time_global_strict_ns();
+
+ /* Local time tests
+ * ---------------- */
ns1 = odp_time_to_ns(l_t1);
ns2 = odp_time_to_ns(l_t2);
ns3 = odp_time_to_ns(l_t3);
- /* Local time assertions */
+ s_ns1 = odp_time_to_ns(ls_t1);
+ s_ns2 = odp_time_to_ns(ls_t2);
+ s_ns3 = odp_time_to_ns(ls_t3);
+
+ /* Time counting starts from zero. Assuming that the ODP instance has run
+ * less than 10 minutes before running this test case. */
+ CU_ASSERT(ns1 < 10 * ODP_TIME_MIN_IN_NS);
+ CU_ASSERT(s_ns1 < 10 * ODP_TIME_MIN_IN_NS);
+ CU_ASSERT(l_ns1 < 10 * ODP_TIME_MIN_IN_NS);
+ CU_ASSERT(ls_ns1 < 10 * ODP_TIME_MIN_IN_NS);
+
+ /* Time stamp */
CU_ASSERT(ns2 > ns1);
CU_ASSERT(ns3 > ns2);
+ /* Strict time stamp */
+ CU_ASSERT(s_ns2 > s_ns1);
+ CU_ASSERT(s_ns3 > s_ns2);
+
+ /* Nsec time */
+ CU_ASSERT(l_ns2 > l_ns1);
+ CU_ASSERT(l_ns3 > l_ns2);
+
+ /* Strict nsec time */
+ CU_ASSERT(ls_ns2 > ls_ns1);
+ CU_ASSERT(ls_ns3 > ls_ns2);
+
+ /* Strict time stamp order is maintained */
+ CU_ASSERT(ls_ns1 >= s_ns1);
+ CU_ASSERT(ls_ns2 >= s_ns2);
+ CU_ASSERT(ls_ns3 >= s_ns3);
+
+ /* Time in nanoseconds have the same time base. Allow less than 100 msec error
+ * between time stamp converted to nsec and nsec time. */
+ CU_ASSERT((ls_ns1 - s_ns1) < (100 * ODP_TIME_MSEC_IN_NS));
+ CU_ASSERT((ls_ns2 - s_ns2) < (100 * ODP_TIME_MSEC_IN_NS));
+ CU_ASSERT((ls_ns3 - s_ns3) < (100 * ODP_TIME_MSEC_IN_NS));
+
+ /* Global time tests
+ * ----------------- */
+
ns1 = odp_time_to_ns(g_t1);
ns2 = odp_time_to_ns(g_t2);
ns3 = odp_time_to_ns(g_t3);
- /* Global time assertions */
+ s_ns1 = odp_time_to_ns(gs_t1);
+ s_ns2 = odp_time_to_ns(gs_t2);
+ s_ns3 = odp_time_to_ns(gs_t3);
+
+ /* Time counting starts from zero. Assuming that the ODP instance has run
+ * less than 10 minutes before running this test case. */
+ CU_ASSERT(ns1 < 10 * ODP_TIME_MIN_IN_NS);
+ CU_ASSERT(s_ns1 < 10 * ODP_TIME_MIN_IN_NS);
+ CU_ASSERT(g_ns1 < 10 * ODP_TIME_MIN_IN_NS);
+ CU_ASSERT(gs_ns1 < 10 * ODP_TIME_MIN_IN_NS);
+
+ /* Time stamp */
CU_ASSERT(ns2 > ns1);
CU_ASSERT(ns3 > ns2);
- /* Local time in nsec */
- CU_ASSERT(lns_t2 > lns_t1);
- CU_ASSERT(lns_t3 > lns_t2);
-
- /* Global time in nsec */
- CU_ASSERT(gns_t2 > gns_t1);
- CU_ASSERT(gns_t3 > gns_t2);
+ /* Strict time stamp */
+ CU_ASSERT(s_ns2 > s_ns1);
+ CU_ASSERT(s_ns3 > s_ns2);
+
+ /* Nsec time */
+ CU_ASSERT(g_ns2 > g_ns1);
+ CU_ASSERT(g_ns3 > g_ns2);
+
+ /* Strict nsec time */
+ CU_ASSERT(gs_ns2 > gs_ns1);
+ CU_ASSERT(gs_ns3 > gs_ns2);
+
+ /* Strict time stamp order is maintained */
+ CU_ASSERT(gs_ns1 >= s_ns1);
+ CU_ASSERT(gs_ns2 >= s_ns2);
+ CU_ASSERT(gs_ns3 >= s_ns3);
+
+ /* Time in nanoseconds have the same time base. Allow less than 100 msec error
+ * between time stamp converted to nsec and nsec time. */
+ CU_ASSERT((gs_ns1 - s_ns1) < (100 * ODP_TIME_MSEC_IN_NS));
+ CU_ASSERT((gs_ns2 - s_ns2) < (100 * ODP_TIME_MSEC_IN_NS));
+ CU_ASSERT((gs_ns3 - s_ns3) < (100 * ODP_TIME_MSEC_IN_NS));
+
+ /* Tight error margin cannot be used due to possible OS interrupts during the test.
+ * Record all time stamp values into the log to help debugging their relative order and
+ * accuracy. */
+ printf("\n Time stamp values in nsec:\n");
+ printf(" odp_time_local(): %" PRIu64 "\n", odp_time_to_ns(l_t1));
+ printf(" odp_time_local_strict(): %" PRIu64 "\n", odp_time_to_ns(ls_t1));
+ printf(" odp_time_local_ns(): %" PRIu64 "\n", l_ns1);
+ printf(" odp_time_local_strict_ns(): %" PRIu64 "\n", ls_ns1);
+ printf(" odp_time_global(): %" PRIu64 "\n", odp_time_to_ns(g_t1));
+ printf(" odp_time_global_strict(): %" PRIu64 "\n", odp_time_to_ns(gs_t1));
+ printf(" odp_time_global_ns(): %" PRIu64 "\n", g_ns1);
+ printf(" odp_time_global_strict_ns(): %" PRIu64 "\n\n", gs_ns1);
}
static void time_test_cmp(time_cb time_cur, time_from_ns_cb time_from_ns)
diff --git a/test/validation/api/timer/timer.c b/test/validation/api/timer/timer.c
index dad99ab41..1927156ba 100644
--- a/test/validation/api/timer/timer.c
+++ b/test/validation/api/timer/timer.c
@@ -453,6 +453,50 @@ static void timer_test_timeout_pool_alloc(void)
CU_ASSERT(odp_pool_destroy(pool) == 0);
}
+static void timer_test_timeout_from_event(void)
+{
+ odp_pool_t pool;
+ odp_pool_param_t param;
+ uint32_t i;
+ const uint32_t num = 10;
+ uint32_t num_alloc = 0;
+ odp_timeout_t tmo_tbl[num];
+ odp_timeout_t tmo2_tbl[num];
+ odp_event_t ev_tbl[num];
+
+ odp_pool_param_init(&param);
+ param.type = ODP_POOL_TIMEOUT;
+ param.tmo.num = num;
+
+ pool = odp_pool_create("test_timeout_from_event", &param);
+ CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+ for (i = 0; i < num; i++) {
+ tmo_tbl[i] = odp_timeout_alloc(pool);
+ if (tmo_tbl[i] == ODP_TIMEOUT_INVALID)
+ break;
+ ev_tbl[i] = odp_timeout_to_event(tmo_tbl[i]);
+ num_alloc++;
+ }
+
+ CU_ASSERT(num_alloc == num);
+
+ for (i = 0; i < num_alloc; i++) {
+ odp_timeout_t tmo = odp_timeout_from_event(ev_tbl[i]);
+
+ CU_ASSERT(odp_timeout_to_u64(tmo) == odp_timeout_to_u64(tmo_tbl[i]));
+ }
+
+ odp_timeout_from_event_multi(tmo2_tbl, ev_tbl, num_alloc);
+ for (i = 0; i < num_alloc; i++)
+ CU_ASSERT(odp_timeout_to_u64(tmo2_tbl[i]) == odp_timeout_to_u64(tmo_tbl[i]));
+
+ for (i = 0; i < num_alloc; i++)
+ odp_timeout_free(tmo_tbl[i]);
+
+ CU_ASSERT_FATAL(odp_pool_destroy(pool) == 0);
+}
+
static void timer_test_timeout_pool_free(void)
{
odp_pool_t pool;
@@ -518,6 +562,7 @@ static void timer_test_timeout_user_area(void)
for (i = 0; i < num; i++) {
odp_event_t ev;
+ int flag;
tmo[i] = odp_timeout_alloc(pool);
@@ -532,6 +577,8 @@ static void timer_test_timeout_user_area(void)
ev = odp_timeout_to_event(tmo[i]);
CU_ASSERT(odp_event_user_area(ev) == addr);
+ CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr);
+ CU_ASSERT(flag < 0);
prev = addr;
memset(addr, 0, size);
@@ -1323,7 +1370,7 @@ static void timer_pool_tick_info(void)
}
static void timer_test_event_type(odp_queue_type_t queue_type,
- odp_event_type_t event_type)
+ odp_event_type_t event_type, int rounds)
{
odp_pool_t pool;
odp_pool_param_t pool_param;
@@ -1401,79 +1448,83 @@ static void timer_test_event_type(odp_queue_type_t queue_type,
ODPH_DBG(" user_ptr %p\n\n", (const void *)user_ctx);
for (i = 0; i < num; i++) {
- if (event_type == ODP_EVENT_BUFFER) {
- buf = odp_buffer_alloc(pool);
- ev = odp_buffer_to_event(buf);
- } else if (event_type == ODP_EVENT_PACKET) {
- pkt = odp_packet_alloc(pool, 10);
- ev = odp_packet_to_event(pkt);
- } else {
- tmo = odp_timeout_alloc(pool);
- ev = odp_timeout_to_event(tmo);
- }
-
- CU_ASSERT(ev != ODP_EVENT_INVALID);
-
timer[i] = odp_timer_alloc(timer_pool, queue, user_ctx);
CU_ASSERT_FATAL(timer[i] != ODP_TIMER_INVALID);
-
- start_param.tick_type = ODP_TIMER_TICK_REL;
- start_param.tick = (i + 1) * period_tick;
- start_param.tmo_ev = ev;
-
- ret = odp_timer_start(timer[i], &start_param);
-
- if (ret == ODP_TIMER_TOO_NEAR)
- ODPH_DBG("Timer set failed. Too near %i.\n", i);
- else if (ret == ODP_TIMER_TOO_FAR)
- ODPH_DBG("Timer set failed. Too far %i.\n", i);
- else if (ret == ODP_TIMER_FAIL)
- ODPH_DBG("Timer set failed %i\n", i);
-
- CU_ASSERT(ret == ODP_TIMER_SUCCESS);
}
- if (test_print) {
- printf("\n");
- odp_timer_pool_print(timer_pool);
- odp_timer_print(timer[0]);
- }
+ for (int round = 0; round < rounds; round++) {
+ for (i = 0; i < num; i++) {
+ if (event_type == ODP_EVENT_BUFFER) {
+ buf = odp_buffer_alloc(pool);
+ ev = odp_buffer_to_event(buf);
+ } else if (event_type == ODP_EVENT_PACKET) {
+ pkt = odp_packet_alloc(pool, 10);
+ ev = odp_packet_to_event(pkt);
+ } else {
+ tmo = odp_timeout_alloc(pool);
+ ev = odp_timeout_to_event(tmo);
+ }
- ev = ODP_EVENT_INVALID;
- num_tmo = 0;
- t1 = odp_time_local();
+ CU_ASSERT(ev != ODP_EVENT_INVALID);
- /* Wait for timers. Make sure that scheduler context is not held when
- * exiting the loop. */
- do {
- if (queue_type == ODP_QUEUE_TYPE_SCHED)
- ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
- else
- ev = odp_queue_deq(queue);
+ start_param.tick_type = ODP_TIMER_TICK_REL;
+ start_param.tick = (i + 1) * period_tick;
+ start_param.tmo_ev = ev;
- if (ev == ODP_EVENT_INVALID) {
- t2 = odp_time_local();
- if (odp_time_diff_ns(t2, t1) > (10 * duration_ns))
- break;
+ ret = odp_timer_start(timer[i], &start_param);
- continue;
- }
+ if (ret == ODP_TIMER_TOO_NEAR)
+ ODPH_DBG("Timer set failed. Too near %i.\n", i);
+ else if (ret == ODP_TIMER_TOO_FAR)
+ ODPH_DBG("Timer set failed. Too far %i.\n", i);
+ else if (ret == ODP_TIMER_FAIL)
+ ODPH_DBG("Timer set failed %i\n", i);
- CU_ASSERT(odp_event_type(ev) == event_type);
+ CU_ASSERT(ret == ODP_TIMER_SUCCESS);
+ }
if (test_print) {
- test_print = 0;
- tmo = odp_timeout_from_event(ev);
- odp_timeout_print(tmo);
printf("\n");
+ odp_timer_pool_print(timer_pool);
+ odp_timer_print(timer[0]);
}
- odp_event_free(ev);
- num_tmo++;
+ ev = ODP_EVENT_INVALID;
+ num_tmo = 0;
+ t1 = odp_time_local();
- } while (num_tmo < num || ev != ODP_EVENT_INVALID);
+ /* Wait for timers. Make sure that scheduler context is not held when
+ * exiting the loop. */
+ do {
+ if (queue_type == ODP_QUEUE_TYPE_SCHED)
+ ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
+ else
+ ev = odp_queue_deq(queue);
- CU_ASSERT(num_tmo == num);
+ if (ev == ODP_EVENT_INVALID) {
+ t2 = odp_time_local();
+ if (odp_time_diff_ns(t2, t1) > (10 * duration_ns))
+ break;
+
+ continue;
+ }
+
+ CU_ASSERT(odp_event_type(ev) == event_type);
+
+ if (test_print) {
+ test_print = 0;
+ tmo = odp_timeout_from_event(ev);
+ odp_timeout_print(tmo);
+ printf("\n");
+ }
+
+ odp_event_free(ev);
+ num_tmo++;
+
+ } while (num_tmo < num || ev != ODP_EVENT_INVALID);
+
+ CU_ASSERT(num_tmo == num);
+ }
for (i = 0; i < num; i++)
CU_ASSERT(odp_timer_free(timer[i]) == ODP_EVENT_INVALID);
@@ -1485,32 +1536,47 @@ static void timer_test_event_type(odp_queue_type_t queue_type,
static void timer_test_tmo_event_plain(void)
{
- timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_TIMEOUT);
+ timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_TIMEOUT, 1);
}
static void timer_test_tmo_event_sched(void)
{
- timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_TIMEOUT);
+ timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_TIMEOUT, 1);
}
static void timer_test_buf_event_plain(void)
{
- timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_BUFFER);
+ timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_BUFFER, 1);
}
static void timer_test_buf_event_sched(void)
{
- timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_BUFFER);
+ timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_BUFFER, 1);
}
static void timer_test_pkt_event_plain(void)
{
- timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_PACKET);
+ timer_test_event_type(ODP_QUEUE_TYPE_PLAIN, ODP_EVENT_PACKET, 1);
}
static void timer_test_pkt_event_sched(void)
{
- timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_PACKET);
+ timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_PACKET, 1);
+}
+
+static void timer_test_tmo_event_reuse(void)
+{
+ timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_TIMEOUT, 2);
+}
+
+static void timer_test_buf_event_reuse(void)
+{
+ timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_BUFFER, 2);
+}
+
+static void timer_test_pkt_event_reuse(void)
+{
+ timer_test_event_type(ODP_QUEUE_TYPE_SCHED, ODP_EVENT_PACKET, 2);
}
static void timer_test_queue_type(odp_queue_type_t queue_type, int priv, int exp_relax)
@@ -2701,7 +2767,7 @@ static void timer_test_periodic_capa(void)
}
}
-static void timer_test_periodic(odp_queue_type_t queue_type, int use_first)
+static void timer_test_periodic(odp_queue_type_t queue_type, int use_first, int rounds)
{
odp_timer_capability_t timer_capa;
odp_timer_periodic_capability_t periodic_capa;
@@ -2720,8 +2786,8 @@ static void timer_test_periodic(odp_queue_type_t queue_type, int use_first)
double freq, freq_out, min_freq, max_freq;
int ret;
const char *user_ctx = "User context";
- int num_tmo = 0;
- int done = 0;
+ int num_tmo;
+ int done;
const int num = 200;
/* Test frequency: 1x 100Hz, or 1x min/max_base_freq */
const uint64_t multiplier = 1;
@@ -2829,127 +2895,135 @@ static void timer_test_periodic(odp_queue_type_t queue_type, int use_first)
queue = odp_queue_create("timeout_queue", &queue_param);
CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
- tmo = odp_timeout_alloc(pool);
- ev = odp_timeout_to_event(tmo);
- CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
-
timer = odp_timer_alloc(timer_pool, queue, user_ctx);
CU_ASSERT_FATAL(timer != ODP_TIMER_INVALID);
memset(&start_param, 0, sizeof(odp_timer_periodic_start_t));
- cur_tick = odp_timer_current_tick(timer_pool);
offset_ns = period_ns / 2;
- tick = cur_tick + odp_timer_ns_to_tick(timer_pool, offset_ns);
if (use_first) {
/* First tick moves timer to start before the first period */
duration_ns -= (period_ns - offset_ns);
- start_param.first_tick = tick;
}
- start_param.freq_multiplier = multiplier;
- start_param.tmo_ev = ev;
+ for (int round = 0; round < rounds; round++) {
+ num_tmo = 0;
+ done = 0;
- ODPH_DBG("Periodic timer start:\n");
- ODPH_DBG(" Current tick: %" PRIu64 "\n", cur_tick);
- ODPH_DBG(" First tick: %" PRIu64 "\n", start_param.first_tick);
- ODPH_DBG(" Multiplier: %" PRIu64 "\n", start_param.freq_multiplier);
- ODPH_DBG(" Period: %" PRIu64 " nsec\n", period_ns);
- ODPH_DBG("Expected duration: %" PRIu64 " nsec\n", duration_ns);
+ tmo = odp_timeout_alloc(pool);
+ ev = odp_timeout_to_event(tmo);
+ CU_ASSERT_FATAL(ev != ODP_EVENT_INVALID);
- ret = odp_timer_periodic_start(timer, &start_param);
+ cur_tick = odp_timer_current_tick(timer_pool);
+ tick = cur_tick + odp_timer_ns_to_tick(timer_pool, offset_ns);
- if (ret == ODP_TIMER_TOO_NEAR)
- ODPH_ERR("First tick too near\n");
- else if (ret == ODP_TIMER_TOO_FAR)
- ODPH_ERR("First tick too far\n");
- else if (ret == ODP_TIMER_FAIL)
- ODPH_ERR("Periodic timer start failed\n");
+ if (use_first)
+ start_param.first_tick = tick;
- CU_ASSERT_FATAL(ret == ODP_TIMER_SUCCESS);
+ start_param.freq_multiplier = multiplier;
+ start_param.tmo_ev = ev;
- t1 = odp_time_local();
+ ODPH_DBG("Periodic timer start:\n");
+ ODPH_DBG(" Current tick: %" PRIu64 "\n", cur_tick);
+ ODPH_DBG(" First tick: %" PRIu64 "\n", start_param.first_tick);
+ ODPH_DBG(" Multiplier: %" PRIu64 "\n", start_param.freq_multiplier);
+ ODPH_DBG(" Period: %" PRIu64 " nsec\n", period_ns);
+ ODPH_DBG("Expected duration: %" PRIu64 " nsec\n", duration_ns);
- /* Wait for timeouts. Make sure that scheduler context is not held when
- * exiting the loop. */
- while (1) {
- if (queue_type == ODP_QUEUE_TYPE_SCHED)
- ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
- else
- ev = odp_queue_deq(queue);
+ ret = odp_timer_periodic_start(timer, &start_param);
- if (ev == ODP_EVENT_INVALID) {
- t2 = odp_time_local();
- diff_ns = odp_time_diff_ns(t2, t1);
- if (diff_ns > (10 * duration_ns))
- break;
+ if (ret == ODP_TIMER_TOO_NEAR)
+ ODPH_ERR("First tick too near\n");
+ else if (ret == ODP_TIMER_TOO_FAR)
+ ODPH_ERR("First tick too far\n");
+ else if (ret == ODP_TIMER_FAIL)
+ ODPH_ERR("Periodic timer start failed\n");
- if (num_tmo >= num)
- break;
+ CU_ASSERT_FATAL(ret == ODP_TIMER_SUCCESS);
- continue;
- }
+ t1 = odp_time_local();
- CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT);
+ /* Wait for timeouts. Make sure that scheduler context is not held when
+ * exiting the loop. */
+ while (1) {
+ if (queue_type == ODP_QUEUE_TYPE_SCHED)
+ ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
+ else
+ ev = odp_queue_deq(queue);
- if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) {
- odp_event_free(ev);
- continue;
- }
+ if (ev == ODP_EVENT_INVALID) {
+ t2 = odp_time_local();
+ diff_ns = odp_time_diff_ns(t2, t1);
+ if (diff_ns > (10 * duration_ns))
+ break;
- CU_ASSERT(odp_timer_periodic_ack(timer, ev) == 0);
- num_tmo++;
- }
+ if (num_tmo >= num)
+ break;
- CU_ASSERT(num_tmo == num);
+ continue;
+ }
- /* Allow +-30% error on test duration */
- CU_ASSERT((diff_ns > 0.7 * duration_ns) && (diff_ns < 1.3 * duration_ns));
+ CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT);
- /* Stop periodic timer */
- ret = odp_timer_periodic_cancel(timer);
- CU_ASSERT_FATAL(ret == 0);
+ if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) {
+ odp_event_free(ev);
+ continue;
+ }
- ODPH_DBG("Measured duration: %" PRIu64 " nsec\n", diff_ns);
+ CU_ASSERT(odp_timer_periodic_ack(timer, ev) == 0);
+ num_tmo++;
+ }
- t1 = odp_time_local();
- while (1) {
- if (queue_type == ODP_QUEUE_TYPE_SCHED)
- ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
- else
- ev = odp_queue_deq(queue);
+ CU_ASSERT(num_tmo == num);
- if (ev == ODP_EVENT_INVALID) {
- t2 = odp_time_local();
- diff_ns = odp_time_diff_ns(t2, t1);
- if (diff_ns > (10 * duration_ns))
- break;
+ /* Allow +-30% error on test duration */
+ CU_ASSERT((diff_ns > 0.7 * duration_ns) && (diff_ns < 1.3 * duration_ns));
- if (done)
- break;
+ /* Stop periodic timer */
+ ret = odp_timer_periodic_cancel(timer);
+ CU_ASSERT_FATAL(ret == 0);
- continue;
- }
+ ODPH_DBG("Measured duration: %" PRIu64 " nsec\n", diff_ns);
- CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT);
+ t1 = odp_time_local();
+ while (1) {
+ if (queue_type == ODP_QUEUE_TYPE_SCHED)
+ ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT);
+ else
+ ev = odp_queue_deq(queue);
- if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) {
- odp_event_free(ev);
- continue;
- }
+ if (ev == ODP_EVENT_INVALID) {
+ t2 = odp_time_local();
+ diff_ns = odp_time_diff_ns(t2, t1);
+ if (diff_ns > (10 * duration_ns))
+ break;
+
+ if (done)
+ break;
- ret = odp_timer_periodic_ack(timer, ev);
- CU_ASSERT(ret == 1 || ret == 2);
+ continue;
+ }
- if (ret == 2) {
- odp_event_free(ev);
- done = 1;
+ CU_ASSERT(odp_event_type(ev) == ODP_EVENT_TIMEOUT);
+
+ if (odp_event_type(ev) != ODP_EVENT_TIMEOUT) {
+ odp_event_free(ev);
+ continue;
+ }
+
+ ret = odp_timer_periodic_ack(timer, ev);
+ CU_ASSERT(ret == 1 || ret == 2);
+
+ if (ret == 2) {
+ odp_event_free(ev);
+ done = 1;
+ }
}
- }
- /* Check that ack() returned 2 on the last event */
- CU_ASSERT(done);
- CU_ASSERT(ret == 2);
+ /* Check that ack() returned 2 on the last event */
+ CU_ASSERT(done);
+ CU_ASSERT(ret == 2);
+ }
CU_ASSERT(odp_timer_free(timer) == ODP_EVENT_INVALID);
odp_timer_pool_destroy(timer_pool);
@@ -2959,28 +3033,34 @@ static void timer_test_periodic(odp_queue_type_t queue_type, int use_first)
static void timer_test_periodic_sched(void)
{
- timer_test_periodic(ODP_QUEUE_TYPE_SCHED, 0);
+ timer_test_periodic(ODP_QUEUE_TYPE_SCHED, 0, 1);
}
static void timer_test_periodic_plain(void)
{
- timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, 0);
+ timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, 0, 1);
}
static void timer_test_periodic_sched_first(void)
{
- timer_test_periodic(ODP_QUEUE_TYPE_SCHED, FIRST_TICK);
+ timer_test_periodic(ODP_QUEUE_TYPE_SCHED, FIRST_TICK, 1);
}
static void timer_test_periodic_plain_first(void)
{
- timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, FIRST_TICK);
+ timer_test_periodic(ODP_QUEUE_TYPE_PLAIN, FIRST_TICK, 1);
+}
+
+static void timer_test_periodic_reuse(void)
+{
+ timer_test_periodic(ODP_QUEUE_TYPE_SCHED, 0, 2);
}
odp_testinfo_t timer_suite[] = {
ODP_TEST_INFO(timer_test_capa),
ODP_TEST_INFO(timer_test_param_init),
ODP_TEST_INFO(timer_test_timeout_pool_alloc),
+ ODP_TEST_INFO(timer_test_timeout_from_event),
ODP_TEST_INFO(timer_test_timeout_pool_free),
ODP_TEST_INFO(timer_test_timeout_user_area),
ODP_TEST_INFO(timer_pool_create_destroy),
@@ -3019,6 +3099,12 @@ odp_testinfo_t timer_suite[] = {
check_plain_queue_support),
ODP_TEST_INFO_CONDITIONAL(timer_test_pkt_event_sched,
check_sched_queue_support),
+ ODP_TEST_INFO_CONDITIONAL(timer_test_tmo_event_reuse,
+ check_sched_queue_support),
+ ODP_TEST_INFO_CONDITIONAL(timer_test_buf_event_reuse,
+ check_sched_queue_support),
+ ODP_TEST_INFO_CONDITIONAL(timer_test_pkt_event_reuse,
+ check_sched_queue_support),
ODP_TEST_INFO(timer_test_cancel),
ODP_TEST_INFO_CONDITIONAL(timer_test_max_res_min_tmo_plain,
check_plain_queue_support),
@@ -3062,6 +3148,8 @@ odp_testinfo_t timer_suite[] = {
check_periodic_plain_support),
ODP_TEST_INFO_CONDITIONAL(timer_test_periodic_plain_first,
check_periodic_plain_support),
+ ODP_TEST_INFO_CONDITIONAL(timer_test_periodic_reuse,
+ check_periodic_sched_support),
ODP_TEST_INFO_NULL,
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-05 16:00:55 +0000