[COMMIT] branch api-next updated. v1.19.0.2_tigermoth-27-g9b2b5a96
by git＠git-us.linaro.org
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, api-next has been updated
via 9b2b5a9695ad66977c964c83691cd2fef4c45b85 (commit)
via 067a7054ba44a2c754f1382daf6469c495085639 (commit)
via f5b1a18c53cec7203b4f94541af4b112c459ab74 (commit)
via 09da8929a55e31b5005a3bb1c2c1184c435612cf (commit)
from 7c629241f07aa7509d996c0560a20c5b0c7b371d (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 9b2b5a9695ad66977c964c83691cd2fef4c45b85
Author: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Date: Tue Dec 26 01:27:07 2017 +0300
validation: crypto: 3GPP crypto algorightms support
Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c
index a551be55..07f1d1fa 100644
--- a/test/validation/api/crypto/odp_crypto_test_inp.c
+++ b/test/validation/api/crypto/odp_crypto_test_inp.c
@@ -61,6 +61,12 @@ static const char *auth_alg_name(odp_auth_alg_t auth)
return "ODP_AUTH_ALG_AES_CMAC";
case ODP_AUTH_ALG_CHACHA20_POLY1305:
return "ODP_AUTH_ALG_CHACHA20_POLY1305";
+ case ODP_AUTH_ALG_KASUMI_F9:
+ return "ODP_AUTH_ALG_KASUMI_F9";
+ case ODP_AUTH_ALG_SNOW3G_UIA2:
+ return "ODP_AUTH_ALG_SNOW3G_UIA2";
+ case ODP_AUTH_ALG_ZUC_EIA3:
+ return "ODP_AUTH_ALG_ZUC_EIA3";
default:
return "Unknown";
}
@@ -85,6 +91,12 @@ static const char *cipher_alg_name(odp_cipher_alg_t cipher)
return "ODP_CIPHER_ALG_AES_CCM";
case ODP_CIPHER_ALG_CHACHA20_POLY1305:
return "ODP_CIPHER_ALG_CHACHA20_POLY1305";
+ case ODP_CIPHER_ALG_KASUMI_F8:
+ return "ODP_CIPHER_ALG_KASUMI_F8";
+ case ODP_CIPHER_ALG_SNOW3G_UEA2:
+ return "ODP_CIPHER_ALG_SNOW3G_UEA2";
+ case ODP_CIPHER_ALG_ZUC_EEA3:
+ return "ODP_CIPHER_ALG_ZUC_EEA3";
default:
return "Unknown";
}
@@ -507,6 +519,15 @@ static void check_alg(odp_crypto_op_t op,
if (cipher_alg == ODP_CIPHER_ALG_CHACHA20_POLY1305 &&
!(capa.ciphers.bit.chacha20_poly1305))
rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_KASUMI_F8 &&
+ !(capa.ciphers.bit.kasumi_f8))
+ rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_SNOW3G_UEA2 &&
+ !(capa.ciphers.bit.snow3g_uea2))
+ rc = -1;
+ if (cipher_alg == ODP_CIPHER_ALG_ZUC_EEA3 &&
+ !(capa.ciphers.bit.zuc_eea3))
+ rc = -1;
if (cipher_alg == ODP_CIPHER_ALG_DES &&
!(capa.ciphers.bit.des))
rc = -1;
@@ -532,6 +553,15 @@ static void check_alg(odp_crypto_op_t op,
if (auth_alg == ODP_AUTH_ALG_CHACHA20_POLY1305 &&
!(capa.auths.bit.chacha20_poly1305))
rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_KASUMI_F9 &&
+ !(capa.auths.bit.kasumi_f9))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_SNOW3G_UIA2 &&
+ !(capa.auths.bit.snow3g_uia2))
+ rc = -1;
+ if (auth_alg == ODP_AUTH_ALG_ZUC_EIA3 &&
+ !(capa.auths.bit.zuc_eia3))
+ rc = -1;
if (auth_alg == ODP_AUTH_ALG_MD5_HMAC &&
!(capa.auths.bit.md5_hmac))
rc = -1;
@@ -709,6 +739,18 @@ static int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth)
if (!capability.ciphers.bit.chacha20_poly1305)
return ODP_TEST_INACTIVE;
break;
+ case ODP_CIPHER_ALG_KASUMI_F8:
+ if (!capability.ciphers.bit.kasumi_f8)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_CIPHER_ALG_SNOW3G_UEA2:
+ if (!capability.ciphers.bit.snow3g_uea2)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_CIPHER_ALG_ZUC_EEA3:
+ if (!capability.ciphers.bit.zuc_eea3)
+ return ODP_TEST_INACTIVE;
+ break;
default:
fprintf(stderr, "Unsupported cipher algorithm\n");
return ODP_TEST_INACTIVE;
@@ -764,6 +806,18 @@ static int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth)
if (!capability.auths.bit.chacha20_poly1305)
return ODP_TEST_INACTIVE;
break;
+ case ODP_AUTH_ALG_KASUMI_F9:
+ if (!capability.auths.bit.kasumi_f9)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_SNOW3G_UIA2:
+ if (!capability.auths.bit.snow3g_uia2)
+ return ODP_TEST_INACTIVE;
+ break;
+ case ODP_AUTH_ALG_ZUC_EIA3:
+ if (!capability.auths.bit.zuc_eia3)
+ return ODP_TEST_INACTIVE;
+ break;
default:
fprintf(stderr, "Unsupported authentication algorithm\n");
return ODP_TEST_INACTIVE;
@@ -1164,6 +1218,153 @@ static void crypto_test_dec_alg_aes_ctr_ovr_iv(void)
false);
}
+static int check_alg_kasumi_f8(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_KASUMI_F8, ODP_AUTH_ALG_NULL);
+}
+
+static void crypto_test_enc_alg_kasumi_f8(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_KASUMI_F8,
+ ODP_AUTH_ALG_NULL,
+ kasumi_f8_reference,
+ ARRAY_SIZE(kasumi_f8_reference),
+ false,
+ true);
+}
+
+static void crypto_test_enc_alg_kasumi_f8_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_KASUMI_F8,
+ ODP_AUTH_ALG_NULL,
+ kasumi_f8_reference,
+ ARRAY_SIZE(kasumi_f8_reference),
+ true,
+ true);
+}
+
+static void crypto_test_dec_alg_kasumi_f8(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_KASUMI_F8,
+ ODP_AUTH_ALG_NULL,
+ kasumi_f8_reference,
+ ARRAY_SIZE(kasumi_f8_reference),
+ false,
+ true);
+}
+
+static void crypto_test_dec_alg_kasumi_f8_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_KASUMI_F8,
+ ODP_AUTH_ALG_NULL,
+ kasumi_f8_reference,
+ ARRAY_SIZE(kasumi_f8_reference),
+ true,
+ true);
+}
+
+static int check_alg_snow3g_uea2(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_SNOW3G_UEA2, ODP_AUTH_ALG_NULL);
+}
+
+static void crypto_test_enc_alg_snow3g_uea2(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_SNOW3G_UEA2,
+ ODP_AUTH_ALG_NULL,
+ snow3g_uea2_reference,
+ ARRAY_SIZE(snow3g_uea2_reference),
+ false,
+ true);
+}
+
+static void crypto_test_enc_alg_snow3g_uea2_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_SNOW3G_UEA2,
+ ODP_AUTH_ALG_NULL,
+ snow3g_uea2_reference,
+ ARRAY_SIZE(snow3g_uea2_reference),
+ true,
+ true);
+}
+
+static void crypto_test_dec_alg_snow3g_uea2(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_SNOW3G_UEA2,
+ ODP_AUTH_ALG_NULL,
+ snow3g_uea2_reference,
+ ARRAY_SIZE(snow3g_uea2_reference),
+ false,
+ true);
+}
+
+static void crypto_test_dec_alg_snow3g_uea2_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_SNOW3G_UEA2,
+ ODP_AUTH_ALG_NULL,
+ snow3g_uea2_reference,
+ ARRAY_SIZE(snow3g_uea2_reference),
+ true,
+ true);
+}
+
+static int check_alg_zuc_eea3(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_ZUC_EEA3, ODP_AUTH_ALG_NULL);
+}
+
+static void crypto_test_enc_alg_zuc_eea3(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_ZUC_EEA3,
+ ODP_AUTH_ALG_NULL,
+ zuc_eea3_reference,
+ ARRAY_SIZE(zuc_eea3_reference),
+ false,
+ true);
+}
+
+static void crypto_test_enc_alg_zuc_eea3_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_ZUC_EEA3,
+ ODP_AUTH_ALG_NULL,
+ zuc_eea3_reference,
+ ARRAY_SIZE(zuc_eea3_reference),
+ true,
+ true);
+}
+
+static void crypto_test_dec_alg_zuc_eea3(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_ZUC_EEA3,
+ ODP_AUTH_ALG_NULL,
+ zuc_eea3_reference,
+ ARRAY_SIZE(zuc_eea3_reference),
+ false,
+ true);
+}
+
+static void crypto_test_dec_alg_zuc_eea3_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_ZUC_EEA3,
+ ODP_AUTH_ALG_NULL,
+ zuc_eea3_reference,
+ ARRAY_SIZE(zuc_eea3_reference),
+ true,
+ true);
+}
+
static int check_alg_hmac_md5(void)
{
return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_MD5_HMAC);
@@ -1445,6 +1646,153 @@ static void crypto_test_check_alg_aes_cmac(void)
false);
}
+static int check_alg_kasumi_f9(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_KASUMI_F9);
+}
+
+static void crypto_test_gen_alg_kasumi_f9(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_KASUMI_F9,
+ kasumi_f9_reference,
+ ARRAY_SIZE(kasumi_f9_reference),
+ false,
+ true);
+}
+
+static void crypto_test_gen_alg_kasumi_f9_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_KASUMI_F9,
+ kasumi_f9_reference,
+ ARRAY_SIZE(kasumi_f9_reference),
+ true,
+ true);
+}
+
+static void crypto_test_check_alg_kasumi_f9(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_KASUMI_F9,
+ kasumi_f9_reference,
+ ARRAY_SIZE(kasumi_f9_reference),
+ false,
+ true);
+}
+
+static void crypto_test_check_alg_kasumi_f9_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_KASUMI_F9,
+ kasumi_f9_reference,
+ ARRAY_SIZE(kasumi_f9_reference),
+ true,
+ true);
+}
+
+static int check_alg_snow3g_uia2(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_SNOW3G_UIA2);
+}
+
+static void crypto_test_gen_alg_snow3g_uia2(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SNOW3G_UIA2,
+ snow3g_uia2_reference,
+ ARRAY_SIZE(snow3g_uia2_reference),
+ false,
+ true);
+}
+
+static void crypto_test_gen_alg_snow3g_uia2_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SNOW3G_UIA2,
+ snow3g_uia2_reference,
+ ARRAY_SIZE(snow3g_uia2_reference),
+ true,
+ true);
+}
+
+static void crypto_test_check_alg_snow3g_uia2(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SNOW3G_UIA2,
+ snow3g_uia2_reference,
+ ARRAY_SIZE(snow3g_uia2_reference),
+ false,
+ true);
+}
+
+static void crypto_test_check_alg_snow3g_uia2_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_SNOW3G_UIA2,
+ snow3g_uia2_reference,
+ ARRAY_SIZE(snow3g_uia2_reference),
+ true,
+ true);
+}
+
+static int check_alg_zuc_eia3(void)
+{
+ return check_alg_support(ODP_CIPHER_ALG_NULL, ODP_AUTH_ALG_ZUC_EIA3);
+}
+
+static void crypto_test_gen_alg_zuc_eia3(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_ZUC_EIA3,
+ zuc_eia3_reference,
+ ARRAY_SIZE(zuc_eia3_reference),
+ false,
+ true);
+}
+
+static void crypto_test_gen_alg_zuc_eia3_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_ENCODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_ZUC_EIA3,
+ zuc_eia3_reference,
+ ARRAY_SIZE(zuc_eia3_reference),
+ true,
+ true);
+}
+
+static void crypto_test_check_alg_zuc_eia3(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_ZUC_EIA3,
+ zuc_eia3_reference,
+ ARRAY_SIZE(zuc_eia3_reference),
+ false,
+ true);
+}
+
+static void crypto_test_check_alg_zuc_eia3_ovr_iv(void)
+{
+ check_alg(ODP_CRYPTO_OP_DECODE,
+ ODP_CIPHER_ALG_NULL,
+ ODP_AUTH_ALG_ZUC_EIA3,
+ zuc_eia3_reference,
+ ARRAY_SIZE(zuc_eia3_reference),
+ true,
+ true);
+}
+
static int crypto_suite_sync_init(void)
{
suite_context.pool = odp_pool_lookup("packet_pool");
@@ -1526,6 +1874,30 @@ odp_testinfo_t crypto_suite[] = {
check_alg_aes_ctr),
ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_aes_ctr_ovr_iv,
check_alg_aes_ctr),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_kasumi_f8,
+ check_alg_kasumi_f8),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_kasumi_f8,
+ check_alg_kasumi_f8),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_kasumi_f8_ovr_iv,
+ check_alg_kasumi_f8),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_kasumi_f8_ovr_iv,
+ check_alg_kasumi_f8),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_snow3g_uea2,
+ check_alg_snow3g_uea2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_snow3g_uea2,
+ check_alg_snow3g_uea2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_snow3g_uea2_ovr_iv,
+ check_alg_snow3g_uea2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_snow3g_uea2_ovr_iv,
+ check_alg_snow3g_uea2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_zuc_eea3,
+ check_alg_zuc_eea3),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_zuc_eea3,
+ check_alg_zuc_eea3),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_zuc_eea3_ovr_iv,
+ check_alg_zuc_eea3),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_dec_alg_zuc_eea3_ovr_iv,
+ check_alg_zuc_eea3),
ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm,
check_alg_aes_gcm),
ODP_TEST_INFO_CONDITIONAL(crypto_test_enc_alg_aes_gcm_ovr_iv,
@@ -1586,6 +1958,30 @@ odp_testinfo_t crypto_suite[] = {
check_alg_aes_cmac),
ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_aes_cmac,
check_alg_aes_cmac),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_kasumi_f9,
+ check_alg_kasumi_f9),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_kasumi_f9,
+ check_alg_kasumi_f9),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_kasumi_f9_ovr_iv,
+ check_alg_kasumi_f9),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_kasumi_f9_ovr_iv,
+ check_alg_kasumi_f9),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_snow3g_uia2,
+ check_alg_snow3g_uia2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_snow3g_uia2,
+ check_alg_snow3g_uia2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_snow3g_uia2_ovr_iv,
+ check_alg_snow3g_uia2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_snow3g_uia2_ovr_iv,
+ check_alg_snow3g_uia2),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_zuc_eia3,
+ check_alg_zuc_eia3),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_zuc_eia3,
+ check_alg_zuc_eia3),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_gen_alg_zuc_eia3_ovr_iv,
+ check_alg_zuc_eia3),
+ ODP_TEST_INFO_CONDITIONAL(crypto_test_check_alg_zuc_eia3_ovr_iv,
+ check_alg_zuc_eia3),
ODP_TEST_INFO_NULL,
};
diff --git a/test/validation/api/crypto/test_vectors.h b/test/validation/api/crypto/test_vectors.h
index 9adb4332..3e40d708 100644
--- a/test/validation/api/crypto/test_vectors.h
+++ b/test/validation/api/crypto/test_vectors.h
@@ -1534,4 +1534,186 @@ static crypto_test_reference_t aes_xcbc_reference[] = {
}
};
+/*
+ * Kasumi F8 and F9 test vectors are taken from
+ * 3GPP TS 35.203 V9.0.0 (2009-12)
+ * 3rd Generation Partnership Project;
+ * Technical Specification Group Services and System Aspects;
+ * 3G Security;
+ * Specification of the 3GPP Confidentiality
+ * and Integrity Algorithms;
+ * Document 3: Implementors' Test Data
+ * (Release 9)
+ */
+static crypto_test_reference_t kasumi_f8_reference[] = {
+ {
+ .cipher_key_length = KASUMI_F8_KEY_LEN,
+ .cipher_key = { 0x5a, 0xcb, 0x1d, 0x64, 0x4c, 0x0d, 0x51, 0x20,
+ 0x4e, 0xa5, 0xf1, 0x45, 0x10, 0x10, 0xd8, 0x52},
+ .cipher_iv_length = KASUMI_F8_IV_LEN,
+ .cipher_iv = { 0xfa, 0x55, 0x6b, 0x26, 0x1c, 0x00, 0x00, 0x00},
+ .length = 120, /* 15 bytes */
+ .plaintext = { 0xad, 0x9c, 0x44, 0x1f, 0x89, 0x0b, 0x38, 0xc4,
+ 0x57, 0xa4, 0x9d, 0x42, 0x14, 0x07, 0xe8 },
+ .ciphertext = { 0x9b, 0xc9, 0x2c, 0xa8, 0x03, 0xc6, 0x7b, 0x28,
+ 0xa1, 0x1a, 0x4b, 0xee, 0x5a, 0x0c, 0x25 }
+ }
+};
+
+static crypto_test_reference_t kasumi_f9_reference[] = {
+ {
+ .auth_key_length = KASUMI_F9_KEY_LEN,
+ .auth_key = { 0xc7, 0x36, 0xc6, 0xaa, 0xb2, 0x2b, 0xff, 0xf9,
+ 0x1e, 0x26, 0x98, 0xd2, 0xe2, 0x2a, 0xd5, 0x7e },
+ .auth_iv_length = KASUMI_F9_IV_LEN,
+ .auth_iv = { 0x14, 0x79, 0x3e, 0x41, 0x03, 0x97, 0xe8, 0xfd,
+ 0x01, },
+ .length = 384, /* 48 bytes */
+ .plaintext = { 0xd0, 0xa7, 0xd4, 0x63, 0xdf, 0x9f, 0xb2, 0xb2,
+ 0x78, 0x83, 0x3f, 0xa0, 0x2e, 0x23, 0x5a, 0xa1,
+ 0x72, 0xbd, 0x97, 0x0c, 0x14, 0x73, 0xe1, 0x29,
+ 0x07, 0xfb, 0x64, 0x8b, 0x65, 0x99, 0xaa, 0xa0,
+ 0xb2, 0x4a, 0x03, 0x86, 0x65, 0x42, 0x2b, 0x20,
+ 0xa4, 0x99, 0x27, 0x6a, 0x50, 0x42, 0x70, 0x09},
+ .ciphertext = { 0xd0, 0xa7, 0xd4, 0x63, 0xdf, 0x9f, 0xb2, 0xb2,
+ 0x78, 0x83, 0x3f, 0xa0, 0x2e, 0x23, 0x5a, 0xa1,
+ 0x72, 0xbd, 0x97, 0x0c, 0x14, 0x73, 0xe1, 0x29,
+ 0x07, 0xfb, 0x64, 0x8b, 0x65, 0x99, 0xaa, 0xa0,
+ 0xb2, 0x4a, 0x03, 0x86, 0x65, 0x42, 0x2b, 0x20,
+ 0xa4, 0x99, 0x27, 0x6a, 0x50, 0x42, 0x70, 0x09},
+ .digest_length = KASUMI_F9_DIGEST_LEN,
+ .digest = { 0xdd, 0x7d, 0xfa, 0xdd },
+ }
+};
+
+/*
+ * Snow3G UEA2 & UIA2 test vectors are taken from
+ * Specification of the 3GPP Confidentiality and
+ * Integrity Algorithms UEA2 & UIA2
+ * Document 3: Implementors’ Test Data
+ * Version: 1.1
+ * Date: 25 th October 2012
+ */
+static crypto_test_reference_t snow3g_uea2_reference[] = {
+ {
+ .cipher_key_length = SNOW3G_UEA2_KEY_LEN,
+ .cipher_key = { 0x5a, 0xcb, 0x1d, 0x64, 0x4c, 0x0d, 0x51, 0x20,
+ 0x4e, 0xa5, 0xf1, 0x45, 0x10, 0x10, 0xd8, 0x52},
+ .cipher_iv_length = SNOW3G_UEA2_IV_LEN,
+ .cipher_iv = { 0xfa, 0x55, 0x6b, 0x26, 0x1c, 0x00, 0x00, 0x00,
+ 0xfa, 0x55, 0x6b, 0x26, 0x1c, 0x00, 0x00, 0x00},
+ .length = 120, /* 15 bytes */
+ .plaintext = { 0xad, 0x9c, 0x44, 0x1f, 0x89, 0x0b, 0x38, 0xc4,
+ 0x57, 0xa4, 0x9d, 0x42, 0x14, 0x07, 0xe8 },
+ .ciphertext = { 0xba, 0x0f, 0x31, 0x30, 0x03, 0x34, 0xc5, 0x6b,
+ 0x52, 0xa7, 0x49, 0x7c, 0xba, 0xc0, 0x46 }
+ }
+};
+
+static crypto_test_reference_t snow3g_uia2_reference[] = {
+ {
+ .auth_key_length = SNOW3G_UIA2_KEY_LEN,
+ .auth_key = { 0xc7, 0x36, 0xc6, 0xaa, 0xb2, 0x2b, 0xff, 0xf9,
+ 0x1e, 0x26, 0x98, 0xd2, 0xe2, 0x2a, 0xd5, 0x7e},
+ .auth_iv_length = SNOW3G_UIA2_IV_LEN,
+ .auth_iv = { 0x14, 0x79, 0x3e, 0x41, 0x03, 0x97, 0xe8, 0xfd,
+ 0x94, 0x79, 0x3e, 0x41, 0x03, 0x97, 0x68, 0xfd },
+ .length = 384, /* 48 bytes */
+ .plaintext = { 0xd0, 0xa7, 0xd4, 0x63, 0xdf, 0x9f, 0xb2, 0xb2,
+ 0x78, 0x83, 0x3f, 0xa0, 0x2e, 0x23, 0x5a, 0xa1,
+ 0x72, 0xbd, 0x97, 0x0c, 0x14, 0x73, 0xe1, 0x29,
+ 0x07, 0xfb, 0x64, 0x8b, 0x65, 0x99, 0xaa, 0xa0,
+ 0xb2, 0x4a, 0x03, 0x86, 0x65, 0x42, 0x2b, 0x20,
+ 0xa4, 0x99, 0x27, 0x6a, 0x50, 0x42, 0x70, 0x09},
+ .ciphertext = { 0xd0, 0xa7, 0xd4, 0x63, 0xdf, 0x9f, 0xb2, 0xb2,
+ 0x78, 0x83, 0x3f, 0xa0, 0x2e, 0x23, 0x5a, 0xa1,
+ 0x72, 0xbd, 0x97, 0x0c, 0x14, 0x73, 0xe1, 0x29,
+ 0x07, 0xfb, 0x64, 0x8b, 0x65, 0x99, 0xaa, 0xa0,
+ 0xb2, 0x4a, 0x03, 0x86, 0x65, 0x42, 0x2b, 0x20,
+ 0xa4, 0x99, 0x27, 0x6a, 0x50, 0x42, 0x70, 0x09},
+ .digest_length = SNOW3G_UIA2_DIGEST_LEN,
+ .digest = { 0x38, 0xb5, 0x54, 0xc0 }
+ }
+};
+
+/*
+ * ZUC EEA3 and EIA3 test vectors from
+ * Specification of the 3GPP Confidentiality and Integrity
+ * Algorithms 128-EEA3 & 128-EIA3
+ * Document 3: Implementor’s Test Data
+ * Version: 1.1
+ * Date: 4 th Jan. 2011
+ */
+static crypto_test_reference_t zuc_eea3_reference[] = {
+ {
+ .cipher_key_length = ZUC_EIA3_KEY_LEN,
+ .cipher_key = { 0xe5, 0xbd, 0x3e, 0xa0, 0xeb, 0x55, 0xad, 0xe8,
+ 0x66, 0xc6, 0xac, 0x58, 0xbd, 0x54, 0x30, 0x2a},
+ .cipher_iv_length = ZUC_EEA3_IV_LEN,
+ .cipher_iv = { 0x00, 0x05, 0x68, 0x23, 0xc4, 0x00, 0x00, 0x00,
+ 0x00, 0x05, 0x68, 0x23, 0xc4, 0x00, 0x00, 0x00 },
+ .length = 800, /* 100 bytes */
+ .plaintext = { 0x14, 0xa8, 0xef, 0x69, 0x3d, 0x67, 0x85, 0x07,
+ 0xbb, 0xe7, 0x27, 0x0a, 0x7f, 0x67, 0xff, 0x50,
+ 0x06, 0xc3, 0x52, 0x5b, 0x98, 0x07, 0xe4, 0x67,
+ 0xc4, 0xe5, 0x60, 0x00, 0xba, 0x33, 0x8f, 0x5d,
+ 0x42, 0x95, 0x59, 0x03, 0x67, 0x51, 0x82, 0x22,
+ 0x46, 0xc8, 0x0d, 0x3b, 0x38, 0xf0, 0x7f, 0x4b,
+ 0xe2, 0xd8, 0xff, 0x58, 0x05, 0xf5, 0x13, 0x22,
+ 0x29, 0xbd, 0xe9, 0x3b, 0xbb, 0xdc, 0xaf, 0x38,
+ 0x2b, 0xf1, 0xee, 0x97, 0x2f, 0xbf, 0x99, 0x77,
+ 0xba, 0xda, 0x89, 0x45, 0x84, 0x7a, 0x2a, 0x6c,
+ 0x9a, 0xd3, 0x4a, 0x66, 0x75, 0x54, 0xe0, 0x4d,
+ 0x1f, 0x7f, 0xa2, 0xc3, 0x32, 0x41, 0xbd, 0x8f,
+ 0x01, 0xba, 0x22, 0x0d },
+ .ciphertext = { 0x13, 0x1d, 0x43, 0xe0, 0xde, 0xa1, 0xbe, 0x5c,
+ 0x5a, 0x1b, 0xfd, 0x97, 0x1d, 0x85, 0x2c, 0xbf,
+ 0x71, 0x2d, 0x7b, 0x4f, 0x57, 0x96, 0x1f, 0xea,
+ 0x32, 0x08, 0xaf, 0xa8, 0xbc, 0xa4, 0x33, 0xf4,
+ 0x56, 0xad, 0x09, 0xc7, 0x41, 0x7e, 0x58, 0xbc,
+ 0x69, 0xcf, 0x88, 0x66, 0xd1, 0x35, 0x3f, 0x74,
+ 0x86, 0x5e, 0x80, 0x78, 0x1d, 0x20, 0x2d, 0xfb,
+ 0x3e, 0xcf, 0xf7, 0xfc, 0xbc, 0x3b, 0x19, 0x0f,
+ 0xe8, 0x2a, 0x20, 0x4e, 0xd0, 0xe3, 0x50, 0xfc,
+ 0x0f, 0x6f, 0x26, 0x13, 0xb2, 0xf2, 0xbc, 0xa6,
+ 0xdf, 0x5a, 0x47, 0x3a, 0x57, 0xa4, 0xa0, 0x0d,
+ 0x98, 0x5e, 0xba, 0xd8, 0x80, 0xd6, 0xf2, 0x38,
+ 0x64, 0xa0, 0x7b, 0x01 }
+ }
+};
+
+static crypto_test_reference_t zuc_eia3_reference[] = {
+ {
+ .auth_key_length = ZUC_EIA3_KEY_LEN,
+ .auth_key = { 0xc9, 0xe6, 0xce, 0xc4, 0x60, 0x7c, 0x72, 0xdb,
+ 0x00, 0x0a, 0xef, 0xa8, 0x83, 0x85, 0xab, 0x0a },
+ .auth_iv_length = ZUC_EIA3_IV_LEN,
+ .auth_iv = { 0xa9, 0x40, 0x59, 0xda, 0x50, 0x00, 0x00, 0x00,
+ 0x29, 0x40, 0x59, 0xda, 0x50, 0x00, 0x80, 0x00 },
+ .length = 584, /* 73 bytes */
+ .plaintext = { 0x98, 0x3b, 0x41, 0xd4, 0x7d, 0x78, 0x0c, 0x9e,
+ 0x1a, 0xd1, 0x1d, 0x7e, 0xb7, 0x03, 0x91, 0xb1,
+ 0xde, 0x0b, 0x35, 0xda, 0x2d, 0xc6, 0x2f, 0x83,
+ 0xe7, 0xb7, 0x8d, 0x63, 0x06, 0xca, 0x0e, 0xa0,
+ 0x7e, 0x94, 0x1b, 0x7b, 0xe9, 0x13, 0x48, 0xf9,
+ 0xfc, 0xb1, 0x70, 0xe2, 0x21, 0x7f, 0xec, 0xd9,
+ 0x7f, 0x9f, 0x68, 0xad, 0xb1, 0x6e, 0x5d, 0x7d,
+ 0x21, 0xe5, 0x69, 0xd2, 0x80, 0xed, 0x77, 0x5c,
+ 0xeb, 0xde, 0x3f, 0x40, 0x93, 0xc5, 0x38, 0x81,
+ 0x00, 0x00, 0x00, 0x00 },
+ .ciphertext = { 0x98, 0x3b, 0x41, 0xd4, 0x7d, 0x78, 0x0c, 0x9e,
+ 0x1a, 0xd1, 0x1d, 0x7e, 0xb7, 0x03, 0x91, 0xb1,
+ 0xde, 0x0b, 0x35, 0xda, 0x2d, 0xc6, 0x2f, 0x83,
+ 0xe7, 0xb7, 0x8d, 0x63, 0x06, 0xca, 0x0e, 0xa0,
+ 0x7e, 0x94, 0x1b, 0x7b, 0xe9, 0x13, 0x48, 0xf9,
+ 0xfc, 0xb1, 0x70, 0xe2, 0x21, 0x7f, 0xec, 0xd9,
+ 0x7f, 0x9f, 0x68, 0xad, 0xb1, 0x6e, 0x5d, 0x7d,
+ 0x21, 0xe5, 0x69, 0xd2, 0x80, 0xed, 0x77, 0x5c,
+ 0xeb, 0xde, 0x3f, 0x40, 0x93, 0xc5, 0x38, 0x81,
+ 0x00, 0x00, 0x00, 0x00 },
+ .digest_length = ZUC_EIA3_DIGEST_LEN,
+ .digest = { 0x24, 0xa8, 0x42, 0xb3 }
+ }
+};
+
#endif
diff --git a/test/validation/api/crypto/test_vectors_len.h b/test/validation/api/crypto/test_vectors_len.h
index 95d202b6..3418ef27 100644
--- a/test/validation/api/crypto/test_vectors_len.h
+++ b/test/validation/api/crypto/test_vectors_len.h
@@ -70,4 +70,31 @@
#define AES_XCBC_MAC_96_CHECK_LEN 12
#define AES_XCBC_MAC_CHECK_LEN 16
+/* KASUMI_F8 */
+#define KASUMI_F8_KEY_LEN 16
+#define KASUMI_F8_IV_LEN 8
+
+/* SNOW3G_UEA2 */
+#define SNOW3G_UEA2_KEY_LEN 16
+#define SNOW3G_UEA2_IV_LEN 16
+
+/* ZUC_EEA3 */
+#define ZUC_EEA3_KEY_LEN 16
+#define ZUC_EEA3_IV_LEN 16
+
+/* KASUMI_F9 */
+#define KASUMI_F9_KEY_LEN 16
+#define KASUMI_F9_IV_LEN 9
+#define KASUMI_F9_DIGEST_LEN 4
+
+/* SNOW3G_UIA2 */
+#define SNOW3G_UIA2_KEY_LEN 16
+#define SNOW3G_UIA2_IV_LEN 16
+#define SNOW3G_UIA2_DIGEST_LEN 4
+
+/* ZUC_EIA3 */
+#define ZUC_EIA3_KEY_LEN 16
+#define ZUC_EIA3_IV_LEN 16
+#define ZUC_EIA3_DIGEST_LEN 4
+
#endif
commit 067a7054ba44a2c754f1382daf6469c495085639
Author: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Date: Mon Jul 16 15:34:54 2018 +0300
validation: crypto: add support for bit mode algorithm testing
Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c
index 1e06761c..a551be55 100644
--- a/test/validation/api/crypto/odp_crypto_test_inp.c
+++ b/test/validation/api/crypto/odp_crypto_test_inp.c
@@ -320,13 +320,15 @@ static void alg_test(odp_crypto_op_t op,
odp_cipher_alg_t cipher_alg,
odp_auth_alg_t auth_alg,
crypto_test_reference_t *ref,
- odp_bool_t ovr_iv)
+ odp_bool_t ovr_iv,
+ odp_bool_t bit_mode)
{
odp_crypto_session_t session;
int rc;
odp_crypto_ses_create_err_t status;
odp_bool_t ok = false;
int iteration;
+ uint32_t reflength;
odp_crypto_session_param_t ses_params;
odp_packet_data_range_t cipher_range;
odp_packet_data_range_t auth_range;
@@ -375,9 +377,14 @@ static void alg_test(odp_crypto_op_t op,
auth_range.offset = 0;
auth_range.length = ref->length;
+ if (bit_mode)
+ reflength = (ref->length + 7) / 8;
+ else
+ reflength = ref->length;
+
/* Prepare input data */
odp_packet_t pkt = odp_packet_alloc(suite_context.pool,
- ref->length + ref->digest_length);
+ reflength + ref->digest_length);
CU_ASSERT(pkt != ODP_PACKET_INVALID);
if (pkt == ODP_PACKET_INVALID)
goto cleanup;
@@ -391,18 +398,18 @@ static void alg_test(odp_crypto_op_t op,
continue;
if (op == ODP_CRYPTO_OP_ENCODE) {
- odp_packet_copy_from_mem(pkt, 0, ref->length,
+ odp_packet_copy_from_mem(pkt, 0, reflength,
ref->plaintext);
} else {
- odp_packet_copy_from_mem(pkt, 0, ref->length,
+ odp_packet_copy_from_mem(pkt, 0, reflength,
ref->ciphertext);
- odp_packet_copy_from_mem(pkt, ref->length,
+ odp_packet_copy_from_mem(pkt, reflength,
ref->digest_length,
ref->digest);
if (iteration == WRONG_DIGEST_TEST) {
uint8_t byte = ~ref->digest[0];
- odp_packet_copy_from_mem(pkt, ref->length,
+ odp_packet_copy_from_mem(pkt, reflength,
1, &byte);
}
}
@@ -412,19 +419,19 @@ static void alg_test(odp_crypto_op_t op,
ovr_iv ? ref->cipher_iv : NULL,
ovr_iv ? ref->auth_iv : NULL,
&cipher_range, &auth_range,
- ref->aad, ref->length);
+ ref->aad, reflength);
else if (ODP_CRYPTO_ASYNC == suite_context.op_mode)
rc = alg_packet_op_enq(pkt, &ok, session,
ovr_iv ? ref->cipher_iv : NULL,
ovr_iv ? ref->auth_iv : NULL,
&cipher_range, &auth_range,
- ref->aad, ref->length);
+ ref->aad, reflength);
else
rc = alg_packet_op(pkt, &ok, session,
ovr_iv ? ref->cipher_iv : NULL,
ovr_iv ? ref->auth_iv : NULL,
&cipher_range, &auth_range,
- ref->aad, ref->length);
+ ref->aad, reflength);
if (rc < 0)
break;
@@ -438,14 +445,14 @@ static void alg_test(odp_crypto_op_t op,
if (op == ODP_CRYPTO_OP_ENCODE) {
CU_ASSERT(!packet_cmp_mem(pkt, 0,
ref->ciphertext,
- ref->length));
- CU_ASSERT(!packet_cmp_mem(pkt, ref->length,
+ reflength));
+ CU_ASSERT(!packet_cmp_mem(pkt, reflength,
ref->digest,
ref->digest_length));
} else {
CU_ASSERT(!packet_cmp_mem(pkt, 0,
ref->plaintext,
- ref->length));
+ reflength));
}
}
@@ -461,7 +468,8 @@ static void check_alg(odp_crypto_op_t op,
odp_auth_alg_t auth_alg,
crypto_test_reference_t *ref,
size_t count,
- odp_bool_t ovr_iv)
+ odp_bool_t ovr_iv,
+ odp_bool_t bit_mode)
{
odp_crypto_capability_t capa;
int rc, i;
@@ -565,7 +573,9 @@ static void check_alg(odp_crypto_op_t op,
if (cipher_capa[i].key_len ==
ref[idx].cipher_key_length &&
cipher_capa[i].iv_len ==
- ref[idx].cipher_iv_length) {
+ ref[idx].cipher_iv_length &&
+ cipher_capa[i].bit_mode ==
+ bit_mode) {
cipher_idx = i;
break;
}
@@ -573,10 +583,11 @@ static void check_alg(odp_crypto_op_t op,
if (cipher_idx < 0) {
printf("\n Unsupported: alg=%s, key_len=%" PRIu32
- ", iv_len=%" PRIu32 "\n",
+ ", iv_len=%" PRIu32 "%s\n",
cipher_alg_name(cipher_alg),
ref[idx].cipher_key_length,
- ref[idx].cipher_iv_length);
+ ref[idx].cipher_iv_length,
+ bit_mode ? " using bits" : "");
continue;
}
@@ -586,7 +597,9 @@ static void check_alg(odp_crypto_op_t op,
auth_capa[i].iv_len ==
ref[idx].auth_iv_length &&
auth_capa[i].key_len ==
- ref[idx].auth_key_length) {
+ ref[idx].auth_key_length &&
+ auth_capa[i].bit_mode ==
+ bit_mode) {
auth_idx = i;
break;
}
@@ -594,15 +607,17 @@ static void check_alg(odp_crypto_op_t op,
if (auth_idx < 0) {
printf("\n Unsupported: alg=%s, key_len=%" PRIu32
- ", iv_len=%" PRIu32 ", digest_len=%" PRIu32 "\n",
+ ", iv_len=%" PRIu32 ", digest_len=%" PRIu32
+ "%s\n",
auth_alg_name(auth_alg),
ref[idx].auth_key_length,
ref[idx].auth_iv_length,
- ref[idx].digest_length);
+ ref[idx].digest_length,
+ bit_mode ? " using bits" : "");
continue;
}
- alg_test(op, cipher_alg, auth_alg, &ref[idx], ovr_iv);
+ alg_test(op, cipher_alg, auth_alg, &ref[idx], ovr_iv, bit_mode);
cipher_tested[cipher_idx] = true;
auth_tested[auth_idx] = true;
@@ -610,23 +625,24 @@ static void check_alg(odp_crypto_op_t op,
for (i = 0; i < cipher_num; i++) {
cipher_ok |= cipher_tested[i];
- if (!cipher_tested[i]) {
+ if (!cipher_tested[i] && cipher_capa[i].bit_mode == bit_mode)
printf("\n Untested: alg=%s, key_len=%" PRIu32 ", "
- "iv_len=%" PRIu32 "\n",
+ "iv_len=%" PRIu32 "%s\n",
cipher_alg_name(cipher_alg),
cipher_capa[i].key_len,
- cipher_capa[i].iv_len);
- }
+ cipher_capa[i].iv_len,
+ cipher_capa[i].bit_mode ? " using bits" : "");
}
for (i = 0; i < auth_num; i++) {
auth_ok |= auth_tested[i];
- if (!auth_tested[i])
+ if (!auth_tested[i] && auth_capa[i].bit_mode == bit_mode)
printf("\n Untested: alg=%s, key_len=%" PRIu32 ", "
- "digest_len=%" PRIu32 "\n",
+ "digest_len=%" PRIu32 "%s\n",
auth_alg_name(auth_alg),
auth_capa[i].key_len,
- auth_capa[i].digest_len);
+ auth_capa[i].digest_len,
+ auth_capa[i].bit_mode ? " using bits" : "");
}
/* Verify that we were able to run at least several tests */
@@ -769,6 +785,7 @@ static void crypto_test_enc_alg_null(void)
ODP_AUTH_ALG_NULL,
null_reference,
ARRAY_SIZE(null_reference),
+ false,
false);
}
@@ -779,6 +796,7 @@ static void crypto_test_dec_alg_null(void)
ODP_AUTH_ALG_NULL,
null_reference,
ARRAY_SIZE(null_reference),
+ false,
false);
}
@@ -798,6 +816,7 @@ static void crypto_test_enc_alg_3des_cbc(void)
ODP_AUTH_ALG_NULL,
tdes_cbc_reference,
ARRAY_SIZE(tdes_cbc_reference),
+ false,
false);
}
@@ -811,7 +830,8 @@ static void crypto_test_enc_alg_3des_cbc_ovr_iv(void)
ODP_AUTH_ALG_NULL,
tdes_cbc_reference,
ARRAY_SIZE(tdes_cbc_reference),
- true);
+ true,
+ false);
}
/* This test verifies the correctness of decode (ciphertext -> plaintext)
@@ -826,6 +846,7 @@ static void crypto_test_dec_alg_3des_cbc(void)
ODP_AUTH_ALG_NULL,
tdes_cbc_reference,
ARRAY_SIZE(tdes_cbc_reference),
+ false,
false);
}
@@ -841,7 +862,8 @@ static void crypto_test_dec_alg_3des_cbc_ovr_iv(void)
ODP_AUTH_ALG_NULL,
tdes_cbc_reference,
ARRAY_SIZE(tdes_cbc_reference),
- true);
+ true,
+ false);
}
static int check_alg_chacha20_poly1305(void)
@@ -857,6 +879,7 @@ static void crypto_test_enc_alg_chacha20_poly1305(void)
ODP_AUTH_ALG_CHACHA20_POLY1305,
chacha20_poly1305_reference,
ARRAY_SIZE(chacha20_poly1305_reference),
+ false,
false);
}
@@ -867,7 +890,8 @@ static void crypto_test_enc_alg_chacha20_poly1305_ovr_iv(void)
ODP_AUTH_ALG_CHACHA20_POLY1305,
chacha20_poly1305_reference,
ARRAY_SIZE(chacha20_poly1305_reference),
- true);
+ true,
+ false);
}
static void crypto_test_dec_alg_chacha20_poly1305(void)
@@ -877,6 +901,7 @@ static void crypto_test_dec_alg_chacha20_poly1305(void)
ODP_AUTH_ALG_CHACHA20_POLY1305,
chacha20_poly1305_reference,
ARRAY_SIZE(chacha20_poly1305_reference),
+ false,
false);
}
@@ -887,7 +912,8 @@ static void crypto_test_dec_alg_chacha20_poly1305_ovr_iv(void)
ODP_AUTH_ALG_CHACHA20_POLY1305,
chacha20_poly1305_reference,
ARRAY_SIZE(chacha20_poly1305_reference),
- true);
+ true,
+ false);
}
static int check_alg_aes_gcm(void)
@@ -906,6 +932,7 @@ static void crypto_test_enc_alg_aes_gcm(void)
ODP_AUTH_ALG_AES_GCM,
aes_gcm_reference,
ARRAY_SIZE(aes_gcm_reference),
+ false,
false);
}
@@ -920,7 +947,8 @@ static void crypto_test_enc_alg_aes_gcm_ovr_iv(void)
ODP_AUTH_ALG_AES_GCM,
aes_gcm_reference,
ARRAY_SIZE(aes_gcm_reference),
- true);
+ true,
+ false);
}
/* This test verifies the correctness of decode (ciphertext -> plaintext)
@@ -935,6 +963,7 @@ static void crypto_test_dec_alg_aes_gcm(void)
ODP_AUTH_ALG_AES_GCM,
aes_gcm_reference,
ARRAY_SIZE(aes_gcm_reference),
+ false,
false);
}
@@ -950,7 +979,8 @@ static void crypto_test_dec_alg_aes_gcm_ovr_iv(void)
ODP_AUTH_ALG_AES_GCM,
aes_gcm_reference,
ARRAY_SIZE(aes_gcm_reference),
- true);
+ true,
+ false);
}
static int check_alg_aes_ccm(void)
@@ -965,6 +995,7 @@ static void crypto_test_enc_alg_aes_ccm(void)
ODP_AUTH_ALG_AES_CCM,
aes_ccm_reference,
ARRAY_SIZE(aes_ccm_reference),
+ false,
false);
}
@@ -975,7 +1006,8 @@ static void crypto_test_enc_alg_aes_ccm_ovr_iv(void)
ODP_AUTH_ALG_AES_CCM,
aes_ccm_reference,
ARRAY_SIZE(aes_ccm_reference),
- true);
+ true,
+ false);
}
static void crypto_test_dec_alg_aes_ccm(void)
@@ -985,6 +1017,7 @@ static void crypto_test_dec_alg_aes_ccm(void)
ODP_AUTH_ALG_AES_CCM,
aes_ccm_reference,
ARRAY_SIZE(aes_ccm_reference),
+ false,
false);
}
@@ -995,7 +1028,8 @@ static void crypto_test_dec_alg_aes_ccm_ovr_iv(void)
ODP_AUTH_ALG_AES_CCM,
aes_ccm_reference,
ARRAY_SIZE(aes_ccm_reference),
- true);
+ true,
+ false);
}
static int check_alg_aes_cbc(void)
@@ -1014,6 +1048,7 @@ static void crypto_test_enc_alg_aes_cbc(void)
ODP_AUTH_ALG_NULL,
aes_cbc_reference,
ARRAY_SIZE(aes_cbc_reference),
+ false,
false);
}
@@ -1027,7 +1062,8 @@ static void crypto_test_enc_alg_aes_cbc_ovr_iv(void)
ODP_AUTH_ALG_NULL,
aes_cbc_reference,
ARRAY_SIZE(aes_cbc_reference),
- true);
+ true,
+ false);
}
/* This test verifies the correctness of decode (ciphertext -> plaintext)
@@ -1042,6 +1078,7 @@ static void crypto_test_dec_alg_aes_cbc(void)
ODP_AUTH_ALG_NULL,
aes_cbc_reference,
ARRAY_SIZE(aes_cbc_reference),
+ false,
false);
}
@@ -1057,7 +1094,8 @@ static void crypto_test_dec_alg_aes_cbc_ovr_iv(void)
ODP_AUTH_ALG_NULL,
aes_cbc_reference,
ARRAY_SIZE(aes_cbc_reference),
- true);
+ true,
+ false);
}
static int check_alg_aes_ctr(void)
@@ -1076,6 +1114,7 @@ static void crypto_test_enc_alg_aes_ctr(void)
ODP_AUTH_ALG_NULL,
aes_ctr_reference,
ARRAY_SIZE(aes_ctr_reference),
+ false,
false);
}
@@ -1089,7 +1128,8 @@ static void crypto_test_enc_alg_aes_ctr_ovr_iv(void)
ODP_AUTH_ALG_NULL,
aes_ctr_reference,
ARRAY_SIZE(aes_ctr_reference),
- true);
+ true,
+ false);
}
/* This test verifies the correctness of decode (ciphertext -> plaintext)
@@ -1104,6 +1144,7 @@ static void crypto_test_dec_alg_aes_ctr(void)
ODP_AUTH_ALG_NULL,
aes_ctr_reference,
ARRAY_SIZE(aes_ctr_reference),
+ false,
false);
}
@@ -1119,7 +1160,8 @@ static void crypto_test_dec_alg_aes_ctr_ovr_iv(void)
ODP_AUTH_ALG_NULL,
aes_ctr_reference,
ARRAY_SIZE(aes_ctr_reference),
- true);
+ true,
+ false);
}
static int check_alg_hmac_md5(void)
@@ -1141,6 +1183,7 @@ static void crypto_test_gen_alg_hmac_md5(void)
ODP_AUTH_ALG_MD5_HMAC,
hmac_md5_reference,
ARRAY_SIZE(hmac_md5_reference),
+ false,
false);
}
@@ -1151,6 +1194,7 @@ static void crypto_test_check_alg_hmac_md5(void)
ODP_AUTH_ALG_MD5_HMAC,
hmac_md5_reference,
ARRAY_SIZE(hmac_md5_reference),
+ false,
false);
}
@@ -1173,6 +1217,7 @@ static void crypto_test_gen_alg_hmac_sha1(void)
ODP_AUTH_ALG_SHA1_HMAC,
hmac_sha1_reference,
ARRAY_SIZE(hmac_sha1_reference),
+ false,
false);
}
@@ -1183,6 +1228,7 @@ static void crypto_test_check_alg_hmac_sha1(void)
ODP_AUTH_ALG_SHA1_HMAC,
hmac_sha1_reference,
ARRAY_SIZE(hmac_sha1_reference),
+ false,
false);
}
@@ -1205,6 +1251,7 @@ static void crypto_test_gen_alg_hmac_sha256(void)
ODP_AUTH_ALG_SHA256_HMAC,
hmac_sha256_reference,
ARRAY_SIZE(hmac_sha256_reference),
+ false,
false);
}
@@ -1215,6 +1262,7 @@ static void crypto_test_check_alg_hmac_sha256(void)
ODP_AUTH_ALG_SHA256_HMAC,
hmac_sha256_reference,
ARRAY_SIZE(hmac_sha256_reference),
+ false,
false);
}
@@ -1237,6 +1285,7 @@ static void crypto_test_gen_alg_hmac_sha384(void)
ODP_AUTH_ALG_SHA384_HMAC,
hmac_sha384_reference,
ARRAY_SIZE(hmac_sha384_reference),
+ false,
false);
}
@@ -1247,6 +1296,7 @@ static void crypto_test_check_alg_hmac_sha384(void)
ODP_AUTH_ALG_SHA384_HMAC,
hmac_sha384_reference,
ARRAY_SIZE(hmac_sha384_reference),
+ false,
false);
}
@@ -1269,6 +1319,7 @@ static void crypto_test_gen_alg_hmac_sha512(void)
ODP_AUTH_ALG_SHA512_HMAC,
hmac_sha512_reference,
ARRAY_SIZE(hmac_sha512_reference),
+ false,
false);
}
@@ -1279,6 +1330,7 @@ static void crypto_test_check_alg_hmac_sha512(void)
ODP_AUTH_ALG_SHA512_HMAC,
hmac_sha512_reference,
ARRAY_SIZE(hmac_sha512_reference),
+ false,
false);
}
@@ -1302,6 +1354,7 @@ static void crypto_test_gen_alg_aes_xcbc(void)
ODP_AUTH_ALG_AES_XCBC_MAC,
aes_xcbc_reference,
ARRAY_SIZE(aes_xcbc_reference),
+ false,
false);
}
@@ -1312,6 +1365,7 @@ static void crypto_test_check_alg_aes_xcbc(void)
ODP_AUTH_ALG_AES_XCBC_MAC,
aes_xcbc_reference,
ARRAY_SIZE(aes_xcbc_reference),
+ false,
false);
}
@@ -1327,6 +1381,7 @@ static void crypto_test_gen_alg_aes_gmac(void)
ODP_AUTH_ALG_AES_GMAC,
aes_gmac_reference,
ARRAY_SIZE(aes_gmac_reference),
+ false,
false);
}
@@ -1337,7 +1392,8 @@ static void crypto_test_gen_alg_aes_gmac_ovr_iv(void)
ODP_AUTH_ALG_AES_GMAC,
aes_gmac_reference,
ARRAY_SIZE(aes_gmac_reference),
- true);
+ true,
+ false);
}
static void crypto_test_check_alg_aes_gmac(void)
@@ -1347,6 +1403,7 @@ static void crypto_test_check_alg_aes_gmac(void)
ODP_AUTH_ALG_AES_GMAC,
aes_gmac_reference,
ARRAY_SIZE(aes_gmac_reference),
+ false,
false);
}
@@ -1357,6 +1414,7 @@ static void crypto_test_check_alg_aes_gmac_ovr_iv(void)
ODP_AUTH_ALG_AES_GMAC,
aes_gmac_reference,
ARRAY_SIZE(aes_gmac_reference),
+ false,
false);
}
@@ -1372,6 +1430,7 @@ static void crypto_test_gen_alg_aes_cmac(void)
ODP_AUTH_ALG_AES_CMAC,
aes_cmac_reference,
ARRAY_SIZE(aes_cmac_reference),
+ false,
false);
}
@@ -1382,6 +1441,7 @@ static void crypto_test_check_alg_aes_cmac(void)
ODP_AUTH_ALG_AES_CMAC,
aes_cmac_reference,
ARRAY_SIZE(aes_cmac_reference),
+ false,
false);
}
commit f5b1a18c53cec7203b4f94541af4b112c459ab74
Author: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Date: Sat Feb 3 05:27:10 2018 +0300
api: crypto: add bitstring operation capability
For several wireless communication algorithms it is expected that they
operate on bit strings, which are not byte-aligned. Add cipher and auth
flags, denoting that this cipher/auth can be enabled to work in
bit-string mode.
Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/include/odp/api/spec/crypto.h b/include/odp/api/spec/crypto.h
index 654ae7bb..843fdefe 100644
--- a/include/odp/api/spec/crypto.h
+++ b/include/odp/api/spec/crypto.h
@@ -755,6 +755,22 @@ typedef struct odp_crypto_cipher_capability_t {
/** IV length in bytes */
uint32_t iv_len;
+ /** Cipher is operating in bitwise mode
+ *
+ * This cipher works on series of bits, rather than sequences of bytes:
+ * cipher_range in odp_crypto_op_param_t and
+ * odp_crypto_packet_op_param_t will use bits, rather than bytes.
+ *
+ * Note: data buffer MUST start on the byte boundary, using offset
+ * which is not divisible by 8 is unsupported and will result in
+ * unspecified behaviour.
+ *
+ * Note2: currently data length MUST be divisible by 8. Specifying data
+ * which does not consist of full bytes will result in unspecified
+ * behaviour.
+ */
+ odp_bool_t bit_mode;
+
} odp_crypto_cipher_capability_t;
/**
@@ -783,6 +799,18 @@ typedef struct odp_crypto_auth_capability_t {
uint32_t inc;
} aad_len;
+ /** Auth is operating in bitstring mode
+ *
+ * This auth works on series of bits, rather than sequences of bytes:
+ * auth_range in odp_crypto_op_param_t and
+ * odp_crypto_packet_op_param_t will use bits, rather than bytes.
+ *
+ * Note: data buffer MUST start on the byte boundary, using offset
+ * which is not divisible by 8 is unsupported and will result in
+ * unpredictable behaviour.
+ */
+ odp_bool_t bit_mode;
+
} odp_crypto_auth_capability_t;
/**
commit 09da8929a55e31b5005a3bb1c2c1184c435612cf
Author: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Date: Tue Dec 26 01:26:25 2017 +0300
api: crypto: provide definitions for 3GPP crypto algorithms
Add enumeration definitions for KASUMI F8/F9, SNOW 3G UEA2/UIA2 and ZUC
128-EEA3/128-EIA3 algorithms.
Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/include/odp/api/spec/crypto.h b/include/odp/api/spec/crypto.h
index c59f6602..654ae7bb 100644
--- a/include/odp/api/spec/crypto.h
+++ b/include/odp/api/spec/crypto.h
@@ -110,6 +110,24 @@ typedef enum {
*/
ODP_CIPHER_ALG_CHACHA20_POLY1305,
+ /** Confidentiality F8 algorithm (UEA1)
+ *
+ * KASUMI-based F8 algorithm (also known as UEA1).
+ */
+ ODP_CIPHER_ALG_KASUMI_F8,
+
+ /** Confidentiality UEA2 algorithm (128-EEA1)
+ *
+ * SNOW 3G-based UEA2 algorithm (also known as 128-EEA1).
+ */
+ ODP_CIPHER_ALG_SNOW3G_UEA2,
+
+ /** Confidentiality 128-EEA3 algorithm
+ *
+ * ZUC-based 128-EEA3 algorithm.
+ */
+ ODP_CIPHER_ALG_ZUC_EEA3,
+
/** @deprecated Use ODP_CIPHER_ALG_AES_CBC instead */
ODP_DEPRECATE(ODP_CIPHER_ALG_AES128_CBC),
@@ -214,6 +232,27 @@ typedef enum {
*/
ODP_AUTH_ALG_CHACHA20_POLY1305,
+ /** Integrity F9 algorithm (UIA1)
+ *
+ * KASUMI-based F9 algorithm (also known as UIA1).
+ *
+ * IV (9 bytes) is a concatenation of COUNT (32b), FRESH (32b) and
+ * DIRECTION (LSB-aligned, 1b).
+ */
+ ODP_AUTH_ALG_KASUMI_F9,
+
+ /** Integrity UIA2 algorithm (128-EEA1)
+ *
+ * SNOW 3G-based UIA2 algorithm (also known as 128-EIA1).
+ */
+ ODP_AUTH_ALG_SNOW3G_UIA2,
+
+ /** Integrity 128-EIA3 algorithm
+ *
+ * ZUC-based 128-EIA3 algorithm.
+ */
+ ODP_AUTH_ALG_ZUC_EIA3,
+
/** @deprecated Use ODP_AUTH_ALG_MD5_HMAC instead */
ODP_DEPRECATE(ODP_AUTH_ALG_MD5_96),
@@ -255,6 +294,15 @@ typedef union odp_crypto_cipher_algos_t {
/** ODP_CIPHER_ALG_CHACHA20_POLY1305 */
uint32_t chacha20_poly1305 : 1;
+ /** ODP_CIPHER_ALG_KASUMI_F8 */
+ uint32_t kasumi_f8 : 1;
+
+ /** ODP_CIPHER_ALG_SNOW3G_UEA2 */
+ uint32_t snow3g_uea2 : 1;
+
+ /** ODP_CIPHER_ALG_ZUC_EEA3 */
+ uint32_t zuc_eea3 : 1;
+
/** @deprecated Use aes_cbc instead */
uint32_t ODP_DEPRECATE(aes128_cbc) : 1;
@@ -312,6 +360,15 @@ typedef union odp_crypto_auth_algos_t {
/** ODP_AUTH_ALG_CHACHA20_POLY1305 */
uint32_t chacha20_poly1305 : 1;
+ /** ODP_AUTH_ALG_KASUMI_F9 */
+ uint32_t kasumi_f9 : 1;
+
+ /** ODP_AUTH_ALG_SNOW3G_UIA2 */
+ uint32_t snow3g_uia2 : 1;
+
+ /** ODP_AUTH_ALG_ZUC_EIA3 */
+ uint32_t zuc_eia3 : 1;
+
/** @deprecated Use md5_hmac instead */
uint32_t ODP_DEPRECATE(md5_96) : 1;
-----------------------------------------------------------------------
Summary of changes:
include/odp/api/spec/crypto.h | 85 ++++
test/validation/api/crypto/odp_crypto_test_inp.c | 534 +++++++++++++++++++++--
test/validation/api/crypto/test_vectors.h | 182 ++++++++
test/validation/api/crypto/test_vectors_len.h | 27 ++
4 files changed, 789 insertions(+), 39 deletions(-)
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch api-next updated. v1.19.0.2_tigermoth-23-g7c629241
by git＠git-us.linaro.org
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, api-next has been updated
via 7c629241f07aa7509d996c0560a20c5b0c7b371d (commit)
from ee6fdca6b647d1c92ba6d07400c7d1e23c9e0ce3 (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 7c629241f07aa7509d996c0560a20c5b0c7b371d
Author: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Date: Tue Apr 24 20:09:37 2018 +0530
api: comp: compression specification
ODP Compression specification
Signed-off-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org>
Signed-off-by: Shally Verma <shally.verma(a)cavium.com>
Signed-off-by: Mahipal Challa <mahipal.challa(a)cavium.com>
Reviewed-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bogdan Pricope <bogdan.pricope(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/include/odp/api/abi-default/comp.h b/include/odp/api/abi-default/comp.h
new file mode 100644
index 00000000..8a1145af
--- /dev/null
+++ b/include/odp/api/abi-default/comp.h
@@ -0,0 +1,35 @@
+/* Copyright (c) 2018, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef ODP_ABI_COMP_H_
+#define ODP_ABI_COMP_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+/** @internal Dummy type for strong typing */
+typedef struct { char dummy; /**< @internal Dummy */ } _odp_abi_comp_session_t;
+
+/** @ingroup odp_compression
+ * @{
+ */
+
+typedef _odp_abi_comp_session_t *odp_comp_session_t;
+
+#define ODP_COMP_SESSION_INVALID ((odp_comp_session_t)0)
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/include/odp/api/spec/comp.h b/include/odp/api/spec/comp.h
new file mode 100644
index 00000000..a5eb5a23
--- /dev/null
+++ b/include/odp/api/spec/comp.h
@@ -0,0 +1,613 @@
+/* Copyright (c) 2018, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/**
+ * @file
+ *
+ * ODP Compression
+ */
+
+#ifndef ODP_API_COMP_H_
+#define ODP_API_COMP_H_
+
+#include <odp/visibility_begin.h>
+#include <odp/api/support.h>
+#include <odp/api/packet.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @defgroup odp_compression ODP COMP
+ * Operations for Compression and Decompression API.
+ * Hash calculation may be combined with de-/compression operations
+ *
+ * @{
+ */
+
+/**
+ * @def ODP_COMP_SESSION_INVALID
+ * Invalid session handle
+ */
+
+/**
+ * @typedef odp_comp_session_t
+ * Compression/Decompression session handle
+ */
+
+/**
+ * Compression operation mode
+ */
+typedef enum {
+ /** Synchronous Compression operation
+ *
+ * Application uses synchronous operation,
+ * which outputs all results on function return.
+ * */
+ ODP_COMP_OP_MODE_SYNC,
+
+ /** Asynchronous Compression operation
+ *
+ * Application uses asynchronous operation,
+ * which return results via events.
+ * */
+ ODP_COMP_OP_MODE_ASYNC
+} odp_comp_op_mode_t;
+
+/**
+ * Compression operation type.
+ */
+typedef enum {
+ /** Operation type - Compress */
+ ODP_COMP_OP_COMPRESS,
+
+ /** Operation type - Decompress */
+ ODP_COMP_OP_DECOMPRESS
+} odp_comp_op_t;
+
+/**
+ * Compression hash algorithms
+ */
+typedef enum {
+ /** No hash algorithm selected. */
+ ODP_COMP_HASH_ALG_NONE,
+
+ /** SHA-1 hash algorithm. */
+ ODP_COMP_HASH_ALG_SHA1,
+
+ /** SHA-2 hash algorithm 256-bit digest length. */
+ ODP_COMP_HASH_ALG_SHA256
+} odp_comp_hash_alg_t;
+
+/**
+ * Compression algorithms
+ *
+ */
+typedef enum {
+ /** No algorithm specified. Added for testing purpose. */
+ ODP_COMP_ALG_NULL,
+
+ /** DEFLATE - RFC1951 */
+ ODP_COMP_ALG_DEFLATE,
+
+ /** ZLIB - RFC1950 */
+ ODP_COMP_ALG_ZLIB,
+
+ /** LZS */
+ ODP_COMP_ALG_LZS
+} odp_comp_alg_t;
+
+/**
+ * Compression operation status codes
+ */
+typedef enum {
+ /** Operation completed successfully*/
+ ODP_COMP_STATUS_SUCCESS,
+
+ /** Operation terminated due to insufficient output buffer */
+ ODP_COMP_STATUS_OUT_OF_SPACE_TERM,
+
+ /** Operation failure */
+ ODP_COMP_STATUS_FAILURE,
+} odp_comp_status_t;
+
+/**
+ * Hash algorithms in a bit field structure
+ */
+typedef union odp_comp_hash_algos_t {
+ /** hash algorithms */
+ struct {
+ /** ODP_COMP_HASH_ALG_NONE */
+ uint32_t none : 1,
+
+ /** ODP_COMP_HASH_ALG_SHA1 */
+ uint32_t sha1 : 1;
+
+ /** ODP_COMP_HASH_ALG_SHA256 */
+ uint32_t sha256 : 1;
+
+ } bit;
+
+ /** All bits of the bit field structure
+ *
+ * This field can be used to set/clear all flags, or bitwise
+ * operations over the entire structure.
+ */
+ uint32_t all_bits;
+} odp_comp_hash_algos_t;
+
+/**
+ * Compression algorithms in a bit field structure
+ */
+typedef union odp_comp_algos_t {
+ /** Compression algorithms */
+ struct {
+ /** ODP_COMP_ALG_NULL */
+ uint32_t null : 1;
+
+ /** ODP_COMP_ALG_DEFLATE */
+ uint32_t deflate : 1;
+
+ /** ODP_COMP_ALG_ZLIB */
+ uint32_t zlib : 1;
+
+ /** ODP_COMP_ALG_LZS */
+ uint32_t lzs : 1;
+ } bit;
+
+ /** All bits of the bit field structure
+ * This field can be used to set/clear all flags, or bitwise
+ * operations over the entire structure.
+ */
+ uint32_t all_bits;
+} odp_comp_algos_t;
+
+/**
+ * Compression Interface Capabilities
+ */
+typedef struct odp_comp_capability_t {
+ /** Maximum number of sessions */
+ uint32_t max_sessions;
+
+ /** Supported compression algorithms */
+ odp_comp_algos_t comp_algos;
+
+ /** Supported hash algorithms */
+ odp_comp_hash_algos_t hash_algos;
+
+ /** Synchronous compression mode support (ODP_COMP_OP_MODE_SYNC) */
+ odp_support_t sync;
+
+ /** Aynchronous compression mode support (ODP_COMP_OP_MODE_SSYNC) */
+ odp_support_t async;
+} odp_comp_capability_t;
+
+/**
+ * Hash algorithm capabilities
+ */
+typedef struct odp_comp_hash_alg_capability_t {
+ /** Digest length in bytes */
+ uint32_t digest_len;
+} odp_comp_hash_alg_capability_t;
+
+/**
+ * Compression algorithm capabilities
+ */
+typedef struct odp_comp_alg_capability_t {
+
+ /** Maximum compression level supported by implementation of this
+ * algorithm. Indicates number of compression levels supported by
+ * implementation. Valid range from (1 ... max_level)
+ */
+ uint32_t max_level;
+
+ /** Supported hash algorithms */
+ odp_comp_hash_algos_t hash_algo;
+
+ /** Compression ratio
+ * Optimal compression operation ratio for this algorithm.
+ * This is an estimate of maximum compression operation output for this
+ * algorithm. It is expressed as a percentage of maximum expected
+ * output data size with respect to input data size.
+ * i.e a value of 200% denotes the output data is 2x times the input
+ * data size. This is an optimal/most case estimate and it is possible
+ * that the percentage of output data produced might be greater
+ * than this value.
+ *
+ * @see odp__percent_t
+ */
+ odp_percent_t compression_ratio;
+} odp_comp_alg_capability_t;
+
+/**
+ * Compression Huffman type. Used by DEFLATE algorithm
+ */
+typedef enum odp_comp_huffman_code {
+ /** Fixed Huffman code */
+ ODP_COMP_HUFFMAN_FIXED,
+
+ /** Dynamic Huffman code */
+ ODP_COMP_HUFFMAN_DYNAMIC,
+
+ /** Default huffman code selected by implementation */
+ ODP_COMP_HUFFMAN_DEFAULT,
+} odp_comp_huffman_code_t;
+
+/**
+ * Compression DEFLATEe algorithm parameters.
+ * Also initialized by other deflate based algorithms , ex. ZLIB
+ */
+typedef struct odp_comp_deflate_param {
+ /**
+ * Compression level
+ *
+ * Valid range is integer between (0 ... max_level)
+ * level supported by the implementation.
+ *
+ * where,
+ * 0 - implemention default
+ *
+ * 1 - fastest compression i.e. output produced at
+ * best possible speed at the expense of compression quality
+ *
+ * max_level - High quality compression
+ *
+ * @see 'max_level' in odp_comp_alg_capability_t
+ */
+ uint32_t comp_level;
+
+ /** huffman code to use */
+ odp_comp_huffman_code_t huffman_code;
+} odp_comp_deflate_param_t;
+
+/**
+ * Compression algorithm specific parameters
+ */
+typedef union odp_comp_alg_param_t {
+ /** deflate parameter */
+ odp_comp_deflate_param_t deflate;
+
+ /** Struct for defining zlib algorithm parameters */
+ struct {
+ /** deflate algo params */
+ odp_comp_deflate_param_t deflate;
+ } zlib;
+} odp_comp_alg_param_t;
+
+ /**
+ * Compression session creation parameters
+ */
+typedef struct odp_comp_session_param_t {
+ /** Compression operation type Compress vs Decompress */
+ odp_comp_op_t op;
+
+ /** Compression operation mode
+ *
+ * Operation mode Synchronous vs Asynchronous
+ *
+ * @see odp_comp_op(), odp_comp_op_enq()
+ */
+ odp_comp_op_mode_t mode;
+
+ /** Compression algorithm
+ *
+ * @see odp_comp_capability()
+ */
+ odp_comp_alg_t comp_algo;
+
+ /** Hash algorithm
+ *
+ * @see odp_comp_alg_capability()
+ */
+ odp_comp_hash_alg_t hash_algo;
+
+ /** parameters specific to compression */
+ odp_comp_alg_param_t alg_param;
+
+ /** Session packet enqueue ordering
+ * Boolean to indicate if packet enqueue ordering is required per
+ * session. Valid only for Asynchronous operation mode
+ * (ODP_COMP_OP_MODE_ASYNC). Packet order is always maintained for
+ * synchronous operation mode (ODP_COMP_OP_MODE_SYNC)
+ *
+ * true: packet session enqueue order maintained
+ *
+ * false: packet session enqueue order is not maintained
+ *
+ * @note: By disabling packet order requirement, performance oriented
+ * application can leverage HW offered parallelism to increase operation
+ * performance.
+ */
+ odp_bool_t packet_order;
+
+ /** Destination queue for compression operations result.
+ * Results are enqueued as ODP_EVENT_PACKET with subtype
+ * ODP_EVENT_PACKET_COMP
+ */
+ odp_queue_t compl_queue;
+} odp_comp_session_param_t;
+
+/**
+ * Compression packet operation result
+ */
+typedef struct odp_comp_packet_result_t {
+ /** Operation status code */
+ odp_comp_status_t status;
+
+ /** Input packet handle */
+ odp_packet_t pkt_in;
+
+ /** Output packet data range
+ * Specifies offset and length of data resulting from compression
+ * operation. When hashing is configured output_data_range.len equals
+ * length of output data + 'digest+len'
+ */
+ odp_packet_data_range_t output_data_range;
+} odp_comp_packet_result_t;
+
+/**
+ * Compression per packet operation parameters
+ */
+typedef struct odp_comp_packet_op_param_t {
+ /** Session handle */
+ odp_comp_session_t session;
+
+ /** Input data range to process. where,
+ *
+ * offset - starting offset
+ * length - length of data for compression operation
+ * */
+ odp_packet_data_range_t in_data_range;
+
+ /** Output packet data range.
+ * Indicates where processed packet will be written. where,
+ *
+ * offset - starting offset
+ * length - length of buffer available for output
+ *
+ * Output packet data is not modified outside of this provided data
+ * range. If output data length is not sufficient for compression
+ * operation ODP_COMP_STATUS_OUT_OF_SPACE_TERM error will occur
+ */
+ odp_packet_data_range_t out_data_range;
+} odp_comp_packet_op_param_t;
+
+/**
+ * Query compression capabilities
+ *
+ * Output compression capabilities on success.
+ *
+ * @param[out] capa Pointer to capability structure for output
+ *
+ * @retval 0 on success
+ * @retval <0 on failure
+ */
+int odp_comp_capability(odp_comp_capability_t *capa);
+
+/**
+ * Query supported compression algorithm capabilities
+ *
+ * Output algorithm capabilities.
+ *
+ * @param comp Compression algorithm
+ * @param[out] capa Compression algorithm capability
+ *
+ * @retval 0 on success
+ * @retval <0 on failure
+ */
+int odp_comp_alg_capability(odp_comp_alg_t comp,
+ odp_comp_alg_capability_t *capa);
+
+/**
+ * Query supported hash algorithm capabilities
+ *
+ * Outputs all supported configuration options for the algorithm.
+ *
+ * @param hash Hash algorithm
+ * @param capa Hash algorithm capability
+ *
+ * @retval 0 on success
+ * @retval <0 on failure
+ */
+int odp_comp_hash_alg_capability(odp_comp_hash_alg_t hash,
+ odp_comp_hash_alg_capability_t *capa);
+
+/**
+ * Initialize compression session parameters
+ *
+ * Initialize an odp_comp_session_param_t to its default values for
+ * all fields.
+ *
+ * @param param Pointer to odp_comp_session_param_t to be initialized
+ */
+void odp_comp_session_param_init(odp_comp_session_param_t *param);
+
+/**
+ * Compression session creation
+ *
+ * Create a comp session according to the session parameters. Use
+ * odp_comp_session_param_init() to initialize parameters into their
+ * default values.
+ *
+ * @param param Session parameters
+ *
+ * @retval Comp session handle
+ * @retval ODP_COMP_SESSION_INVALID on failure
+ */
+odp_comp_session_t
+odp_comp_session_create(const odp_comp_session_param_t *param);
+
+/**
+ * Compression session destroy
+ *
+ * Destroy an unused session. Result is undefined if session is being used
+ * (i.e. asynchronous operation is in progress).
+ *
+ * @param session Session handle
+ *
+ * @retval 0 on success
+ * @retval <0 on failure
+ */
+int odp_comp_session_destroy(odp_comp_session_t session);
+
+/**
+ * Synchronous packet compression operation
+ *
+ * This operation does packet compression in synchronous mode. A successful operation
+ * returns the number of successfully processed input packets and updates the
+ * results in the corresponding output packets. Outputted packets contain
+ * compression results metadata (odp_comp_packet_result_t), which should be
+ * checked for operation status. Length of outputted data can be got from
+ * output_data_range.len.
+ *
+ * When hashing is configured along with compression operation the
+ * result is appended at the end of the output data, output_data_range.len
+ * equals length of output data + 'digest_len'. Processed data length
+ * can be computed by subtracting 'digest_len' from output_data_range.len where
+ * 'digest_len' can be queried from odp_comp_hash_alg_capability().
+ * Hash is always performed on plain text. Hash validation in decompression is
+ * performed by the application.
+ * For every input packet entry in 'pkt_in' array, application should pass
+ * corresponding valid output packet handle. If any error occurs during
+ * processing of packets, the API returns with number of entries successfully
+ * processed.
+ * Output packet metadatas like length or data pointer will not be updated.
+ *
+ * @param pkt_in Packets to be processed
+ * @param pkt_out Packet handle array for resulting packets
+ * @param num_pkt Number of packets to be processed
+ * @param param Operation parameters
+ *
+ * @return Number of input packets consumed (0 ... num_pkt)
+ * @retval <0 on failure
+ *
+ * @note The 'pkt_in','pkt_out'and 'param' arrays should be of same length,
+ * Results are undefined if otherwise.
+
+ * @note Same packet handle cannot be used as input and output parameter.
+ * In-place compression operation is not supported
+ */
+int odp_comp_op(const odp_packet_t pkt_in[], odp_packet_t pkt_out[],
+ int num_pkt, const odp_comp_packet_op_param_t param[]);
+
+/**
+ * Asynchronous packet compression operation
+ *
+ * This operation does packet compression in asynchronous mode. It processes
+ * packets otherwise identical to odp_comp_op(), but the resulting packets are
+ * enqueued to 'compl_queue' configured during session (odp_comp_session_t)
+ * creation. For every input packet entry in in_pkt array, user should pass
+ * corresponding valid output packet handle. On return, API returns with
+ * number of entries successfully submitted for operation.
+ *
+ * When hashing is configured along with compression operation the
+ * result is appended at the end of the output data, output_data_range.len
+ * equals length of output data + 'digest_len'. Processed data length
+ * can be computed by subtracting 'digest_len' from output_data_range.len where
+ * 'digest_len' can be queried from odp_comp_hash_alg_capability().
+ * Hash is always performed on plain text. Hash validation in decompression is
+ * performed by the application.
+ *
+ * In case of partially accepted array i.e.
+ * when number of packets returned < num_pkt, application may attempt to
+ * resubmit subsequent entries via calling any of the operation API.
+ *
+ * All the packets successfully enqueued will be submitted to 'compl_queue'
+ * after compression operation, Application should check 'status' of the
+ * operation in odp_comp_packet_result_t.
+ * Output packet metadatas like length or data pointer will not be updated.
+ *
+ * Please note it is always recommended that application using async mode,
+ * provide sufficiently large buffer size to avoid
+ * ODP_COMP_STATUS_OUT_OF_SPACE_TERM.
+ *
+ * @param pkt_in Packets to be processed
+ * @param pkt_out Packet handle array for resulting packets
+ * @param num_pkt Number of packets to be processed
+ * @param param Operation parameters
+ *
+ * @return Number of input packets enqueued (0 ... num_pkt)
+ * @retval <0 on failure
+ *
+ * @note The 'pkt_in','pkt_out'and 'param' arrays should be of same length,
+ * Results are undefined if otherwise.
+
+ * @note Same packet handle cannot be used as input and output parameter.
+ * In-place compression operation is not supported
+
+ * @see odp_comp_op(), odp_comp_packet_result()
+ */
+int odp_comp_op_enq(const odp_packet_t pkt_in[], odp_packet_t pkt_out[],
+ int num_pkt, const odp_comp_packet_op_param_t param[]);
+
+/**
+ * Get compression operation results from processed packet.
+ *
+ * Successful compression operations of all modes (ODP_COMP_OP_MODE_SYNC and
+ * ODP_COMP_OP_MODE_ASYNC) produce packets which contain compression result
+ * metadata. This function copies operation results from compression processed
+ * packet. Event subtype of this packet is ODP_EVENT_PACKET_COMP. Results are
+ * undefined if non-compression processed packet is passed as input.
+ *
+ * @param[out] result pointer to operation result for output
+ * @param packet compression processed packet (ODP_EVENT_PACKET_COMP)
+ *
+ * @retval 0 On success
+ * @retval <0 On failure
+ */
+int odp_comp_result(odp_comp_packet_result_t *result, odp_packet_t packet);
+
+ /**
+ * Convert compression processed packet event to packet handle
+ *
+ * Get packet handle corresponding to processed packet event. Event subtype
+ * must be ODP_EVENT_PACKET_COMP. Compression operation results can be
+ * examined with odp_comp_result().
+ *
+ * @param event Event handle
+ *
+ * @return Valid Packet handle on success,
+ * @retval ODP_PACKET_INVALID on failure
+ *
+ * @see odp_event_subtype(), odp_comp_result()
+ *
+ */
+odp_packet_t odp_comp_packet_from_event(odp_event_t event);
+
+ /**
+ * Convert processed packet handle to event
+ *
+ * The packet handle must be an output of a compression operation
+ *
+ * @param pkt Packet handle from compression operation
+ * @return Event handle
+ */
+odp_event_t odp_comp_packet_to_event(odp_packet_t pkt);
+
+/**
+ * Get printable value for an odp_comp_session_t
+ *
+ * @param hdl odp_comp_session_t handle to be printed
+ * @return uint64_t value that can be used to print/display this
+ * handle
+ *
+ * @note This routine is intended to be used for diagnostic purposes
+ * to enable applications to generate a printable value that represents
+ * an odp_comp_session_t handle.
+ */
+uint64_t odp_comp_session_to_u64(odp_comp_session_t hdl);
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <odp/visibility_end.h>
+#endif
+
-----------------------------------------------------------------------
Summary of changes:
include/odp/api/abi-default/{queue.h => comp.h} | 18 +-
include/odp/api/spec/comp.h | 613 ++++++++++++++++++++++++
2 files changed, 622 insertions(+), 9 deletions(-)
copy include/odp/api/abi-default/{queue.h => comp.h} (52%)
create mode 100644 include/odp/api/spec/comp.h
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch master updated. v1.19.0.2_tigermoth-23-g6add70a4
by git＠git-us.linaro.org
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 6add70a4ff916acb331b961bc230cf946fbe835a (commit)
from ee6fdca6b647d1c92ba6d07400c7d1e23c9e0ce3 (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 6add70a4ff916acb331b961bc230cf946fbe835a
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Thu Jul 12 11:35:07 2018 +0300
linux-gen: ipsec: fall back to lower odp_random_kind_t if necessary
Create IV with lower random kind if ODP_RANDOM_CRYPTO is not supported.
This enables passing validation tests using odp_random_null.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_global_data.h b/platform/linux-generic/include/odp_global_data.h
index 009862a8..1ddc49ea 100644
--- a/platform/linux-generic/include/odp_global_data.h
+++ b/platform/linux-generic/include/odp_global_data.h
@@ -13,6 +13,7 @@ extern "C" {
#include <odp/api/init.h>
#include <odp/api/cpumask.h>
+#include <odp/api/random.h>
#include <sys/types.h>
#include <pthread.h>
#include <stdint.h>
@@ -58,6 +59,7 @@ struct odp_global_data_s {
int inotify_watch_fd;
pthread_t inotify_thread;
int inotify_pcapng_is_running;
+ odp_random_kind_t ipsec_rand_kind;
};
extern struct odp_global_data_s odp_global_data;
diff --git a/platform/linux-generic/odp_ipsec.c b/platform/linux-generic/odp_ipsec.c
index 71258fe9..5b739cc1 100644
--- a/platform/linux-generic/odp_ipsec.c
+++ b/platform/linux-generic/odp_ipsec.c
@@ -13,6 +13,7 @@
#include <odp/api/byteorder.h>
#include <odp/api/plat/byteorder_inlines.h>
+#include <odp_global_data.h>
#include <odp_init_internal.h>
#include <odp_debug_internal.h>
#include <odp_packet_internal.h>
@@ -1003,7 +1004,7 @@ static int ipsec_out_iv(ipsec_state_t *state,
uint32_t len;
len = odp_random_data(state->iv, ipsec_sa->esp_iv_len,
- ODP_RANDOM_CRYPTO);
+ odp_global_data.ipsec_rand_kind);
if (len != ipsec_sa->esp_iv_len)
return -1;
@@ -1892,6 +1893,10 @@ int _odp_ipsec_init_global(void)
memset(&default_out_opt, 0, sizeof(default_out_opt));
+ odp_global_data.ipsec_rand_kind = ODP_RANDOM_CRYPTO;
+ if (odp_global_data.ipsec_rand_kind > odp_random_max_kind())
+ odp_global_data.ipsec_rand_kind = odp_random_max_kind();
+
return 0;
}
-----------------------------------------------------------------------
Summary of changes:
platform/linux-generic/include/odp_global_data.h | 2 ++
platform/linux-generic/odp_ipsec.c | 7 ++++++-
2 files changed, 8 insertions(+), 1 deletion(-)
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch api-next updated. v1.19.0.2_tigermoth-22-gee6fdca6
by git＠git-us.linaro.org
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, api-next has been updated
via ee6fdca6b647d1c92ba6d07400c7d1e23c9e0ce3 (commit)
via 0070431f72dacef15d104bcf2baa9d70629d3d31 (commit)
via 5a43e72ba90dc5b4ea4ae3e8875075440e709655 (commit)
via 0ee7d42a7280e7ced1ea2f97e80dc752f28f76b2 (commit)
via c7bbbb603fc4cf2e6590af962e2e255241d18276 (commit)
via c0d530e01e91fbea195993293eed60f1677e6181 (commit)
via 942bbe22b7147e2988aa0b82e094a53421f2c486 (commit)
via d5690aa464880a258f653e1b4d68f150b4c660a8 (commit)
via 8418efbab3fe38ed701d9294800ec85d467763df (commit)
via 6ac9ea26a82c8f71b989d4dc6af22e3e5df62d48 (commit)
via a061f94424cd9cb434a203a04aec4c437dabf251 (commit)
via f7c03ade975b018be0766d5fea300d03642b4b12 (commit)
via 60cc4b660bea6af9b37a14fbf1ad07589b15b34e (commit)
via a9e3b02a54cd9a18baf8042e389ffbdb9266a9c7 (commit)
via ce5951842845b519c7887479c8e4e128e1951add (commit)
via 808acd63c4ec54af93eb5bbf717d4b591df1d904 (commit)
via 6b947deb94b45660a5140472565886e9d5f1203f (commit)
via 0330e7369aa682ac2c2feb2bcb197e52dc1810fb (commit)
via 7c72d611d8d568358d4a7849057e42708cbb10c3 (commit)
via 9ccda90b1788836848ecc5977d9cd8a807ee20c9 (commit)
via 97b316f2342a317843b476094ed7323ca899504c (commit)
via bd2775a49b137034294085b0fc5bf129accc1ea8 (commit)
via 6e741deee25c81429112b82ba54f09205bb7c0ab (commit)
via f48fce7b90cbd7f3efa05d5e7481999bf751e98c (commit)
via a3dccfdd5ffa6d26e00898cb76d3aa25090f983b (commit)
via 838c13654c639baa1c54d19056cd771380ab8a58 (commit)
via abd50139e35c67ddbc1ec09550ea6b6d27861703 (commit)
via 7f5cc90258fe11df6286d9ce562d904e8032c461 (commit)
via 8dd98e227876fbe8f8a0dc0504906975e93c7cd0 (commit)
via 4d9446e1fb4fbc54eee5295dfc9854b2f21bb841 (commit)
via a716bb568dfe2cf4c856786b8fa9006a8a9c3841 (commit)
via 3d591a7970918cee809927595ebf28e554460ca1 (commit)
via bbb0829282ba766e26d334dd7afa05e723ec61e7 (commit)
via 033ae0b58a72f828c608a557cafaf468f8d67b9a (commit)
via eaf3b566293fa2bc10bb5b99b38ad75f4914b1ab (commit)
via 0ebd57ab0ea8e1a95cdb8a564fcaec4cad6231e7 (commit)
via a7c60d702466bc0f9de64993446e8ec39a16de88 (commit)
via 251fd5805122a257060a9de62a4c26bc1862a544 (commit)
via 8813bda68dac4f6ff448cf783b43e6deafff75ae (commit)
via 3d79b95543b6043a9df9f523f81416a30052a9ce (commit)
via 3c335400833959b9a96674984c797e8ec4734566 (commit)
via dd7bcc7dead9bceba895ad877ad3ac7642d4e717 (commit)
via 7c33f29d51082d693c0653df84cb13f2b946eec8 (commit)
via 9ab55a834226a8ae9faea3491f23aa065303cb41 (commit)
via 4e99631dda78212103dc7d6bc9b165f89079e60e (commit)
via 3565cdd101fae3d0ed5aacde80b7d49d8c4c4af8 (commit)
via 719ac4509920bad7d5c8d563426d21f2a0c9e80e (commit)
via b1eadcb681dbe7a3d7db4d3ddb18528ebd15211b (commit)
via ac851856893867331ab9f692a135a40677daa351 (commit)
from 492390a79f20c7aaaf16f232fbd5ecf0d9b700e7 (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 -----------------------------------------------------------------
-----------------------------------------------------------------------
Summary of changes:
.travis.yml | 25 +-
CHANGELOG | 132 ++++
DEPENDENCIES | 6 +
config/odp-linux-generic.conf | 11 +
configure.ac | 23 +-
example/Makefile.am | 1 +
example/classifier/odp_classifier.c | 12 +-
example/generator/odp_generator.c | 22 +-
example/ipsec/Makefile.am | 17 +-
example/ipsec/odp_ipsec.c | 39 +-
example/ipsec_api/Makefile.am | 17 +-
example/ipsec_api/odp_ipsec.c | 46 +-
example/ipsec_offload/odp_ipsec_offload.c | 11 +-
example/l3fwd/odp_l3fwd.c | 23 +-
example/m4/configure.m4 | 1 +
example/packet/odp_pktio.c | 10 +-
example/switch/odp_switch.c | 10 +-
example/{hello => sysinfo}/.gitignore | 2 +-
example/sysinfo/Makefile.am | 9 +
example/sysinfo/odp_sysinfo.c | 293 ++++++++
example/timer/odp_timer_test.c | 13 +-
m4/ax_check_compile_flag.m4 | 74 --
m4/ax_compiler_vendor.m4 | 87 ---
m4/ax_compiler_version.m4 | 492 -------------
m4/ax_pthread.m4 | 332 ---------
m4/odp_check_flag.m4 | 38 +-
m4/odp_pthread.m4 | 23 +-
platform/linux-generic/Makefile.am | 17 +-
.../linux-generic/arch/aarch64/odp_sysinfo_parse.c | 212 ++++++
.../linux-generic/arch/default/odp_sysinfo_parse.c | 8 +-
.../linux-generic/arch/mips64/odp_sysinfo_parse.c | 4 +-
.../linux-generic/arch/powerpc/odp_sysinfo_parse.c | 4 +-
.../linux-generic/arch/x86/odp_sysinfo_parse.c | 30 +-
.../linux-generic/include/odp_config_internal.h | 5 +
platform/linux-generic/include/odp_global_data.h | 7 +-
platform/linux-generic/include/odp_init_internal.h | 5 +
.../include/odp_packet_io_ring_internal.h | 184 +----
...queue_internal.h => odp_queue_basic_internal.h} | 11 +-
platform/linux-generic/include/odp_ring_internal.h | 69 +-
platform/linux-generic/include/odp_schedule_if.h | 6 -
.../linux-generic/include/odp_sysinfo_internal.h | 1 -
platform/linux-generic/m4/configure.m4 | 9 +-
platform/linux-generic/odp_crypto_null.c | 573 +++++++++++++++
.../{odp_crypto.c => odp_crypto_openssl.c} | 0
platform/linux-generic/odp_hash_crc_gen.c | 222 ++++++
platform/linux-generic/odp_init.c | 29 +
platform/linux-generic/odp_queue_basic.c | 93 ++-
platform/linux-generic/odp_queue_lf.c | 135 ++--
platform/linux-generic/odp_queue_spsc.c | 2 +-
.../{odp_random.c => odp_random_null.c} | 60 +-
.../{odp_random.c => odp_random_openssl.c} | 11 +
platform/linux-generic/odp_schedule_basic.c | 128 +++-
platform/linux-generic/odp_schedule_iquery.c | 13 +-
platform/linux-generic/odp_schedule_sp.c | 10 +-
platform/linux-generic/odp_system_info.c | 24 +-
platform/linux-generic/odp_traffic_mngr.c | 6 +-
platform/linux-generic/pktio/ethtool_rss.c | 5 +-
platform/linux-generic/pktio/ring.c | 189 +----
platform/linux-generic/pktio/socket_common.c | 5 +-
platform/linux-generic/pktio/stats/ethtool_stats.c | 4 +-
platform/linux-generic/pktio/tap.c | 2 +-
platform/linux-generic/test/pktio_ipc/pktio_ipc1.c | 7 +-
platform/linux-generic/test/ring/ring_basic.c | 111 +--
platform/linux-generic/test/ring/ring_suites.c | 1 -
platform/linux-generic/test/ring/ring_suites.h | 1 -
test/common/odp_cunit_common.c | 16 +
test/common/odp_cunit_common.h | 2 +
test/performance/.gitignore | 3 +
test/performance/Makefile.am | 8 +-
test/performance/odp_cpu_bench.c | 813 +++++++++++++++++++++
test/performance/odp_l2fwd.c | 10 +-
test/performance/odp_pktio_ordered.c | 16 +-
test/performance/odp_pktio_perf.c | 9 +-
test/performance/odp_pool_perf.c | 401 ++++++++++
test/performance/odp_sched_latency.c | 7 +-
test/performance/odp_sched_perf.c | 559 ++++++++++++++
test/performance/odp_scheduling.c | 6 +-
test/validation/api/crypto/odp_crypto_test_inp.c | 35 +-
test/validation/api/hash/hash.c | 475 +++++++++++-
test/validation/api/queue/queue.c | 39 +-
test/validation/api/traffic_mngr/traffic_mngr.c | 74 +-
81 files changed, 4496 insertions(+), 1949 deletions(-)
copy example/{hello => sysinfo}/.gitignore (50%)
create mode 100644 example/sysinfo/Makefile.am
create mode 100644 example/sysinfo/odp_sysinfo.c
delete mode 100644 m4/ax_check_compile_flag.m4
delete mode 100644 m4/ax_compiler_vendor.m4
delete mode 100644 m4/ax_compiler_version.m4
delete mode 100644 m4/ax_pthread.m4
create mode 100644 platform/linux-generic/arch/aarch64/odp_sysinfo_parse.c
rename platform/linux-generic/include/{odp_queue_internal.h => odp_queue_basic_internal.h} (86%)
create mode 100644 platform/linux-generic/odp_crypto_null.c
rename platform/linux-generic/{odp_crypto.c => odp_crypto_openssl.c} (100%)
create mode 100644 platform/linux-generic/odp_hash_crc_gen.c
copy platform/linux-generic/{odp_random.c => odp_random_null.c} (56%)
rename platform/linux-generic/{odp_random.c => odp_random_openssl.c} (88%)
create mode 100644 test/performance/odp_cpu_bench.c
create mode 100644 test/performance/odp_pool_perf.c
create mode 100644 test/performance/odp_sched_perf.c
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch master updated. v1.19.0.2_tigermoth-22-gee6fdca6
by git＠git-us.linaro.org
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 ee6fdca6b647d1c92ba6d07400c7d1e23c9e0ce3 (commit)
via 0070431f72dacef15d104bcf2baa9d70629d3d31 (commit)
via 5a43e72ba90dc5b4ea4ae3e8875075440e709655 (commit)
via 0ee7d42a7280e7ced1ea2f97e80dc752f28f76b2 (commit)
via c7bbbb603fc4cf2e6590af962e2e255241d18276 (commit)
via c0d530e01e91fbea195993293eed60f1677e6181 (commit)
from 942bbe22b7147e2988aa0b82e094a53421f2c486 (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 ee6fdca6b647d1c92ba6d07400c7d1e23c9e0ce3
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Thu Jul 5 14:27:45 2018 +0300
linux-gen: sched: configurable default burst size
Make default burst sizes configurable. User can set limits for
burst size round up in high/low priority. When less than
burst_size_xx events are requested, scheduler rounds up the
number of events to these limit and stash extra events. Requests
with more events are not round down. So, user can use small
values in burst size configure for better real-time support, but
still request large number of events for better throughput on
non real-time threads.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/config/odp-linux-generic.conf b/config/odp-linux-generic.conf
index f5f21b45..85d5414b 100644
--- a/config/odp-linux-generic.conf
+++ b/config/odp-linux-generic.conf
@@ -55,4 +55,15 @@ sched_basic: {
# uneven service level for low thread counts. Typically, optimal
# value is the number of threads using the scheduler.
prio_spread = 4
+
+ # Default burst sizes for high and low priority queues. The default
+ # and higher priority levels are considered as high. Scheduler
+ # rounds up number of requested events up to these values. In general,
+ # larger requests are not round down. So, larger bursts than these may
+ # received when requested. A large burst size improves throughput,
+ # but decreases application responsiveness to high priority events
+ # due to head of line blocking cause by a burst of low priority
+ # events.
+ burst_size_hi = 32
+ burst_size_low = 16
}
diff --git a/platform/linux-generic/odp_schedule_basic.c b/platform/linux-generic/odp_schedule_basic.c
index 75434149..df63da72 100644
--- a/platform/linux-generic/odp_schedule_basic.c
+++ b/platform/linux-generic/odp_schedule_basic.c
@@ -94,7 +94,8 @@ ODP_STATIC_ASSERT((8 * sizeof(pri_mask_t)) >= MAX_SPREAD,
/* Default burst size. Scheduler rounds up number of requested events up to
* this value. */
-#define BURST_SIZE CONFIG_BURST_SIZE
+#define BURST_SIZE_MAX CONFIG_BURST_SIZE
+#define BURST_SIZE_MIN 1
/* Ordered stash size */
#define MAX_ORDERED_STASH 512
@@ -124,7 +125,7 @@ typedef struct {
uint16_t spread_round;
uint32_t stash_qi;
odp_queue_t stash_queue;
- odp_event_t stash_ev[BURST_SIZE];
+ odp_event_t stash_ev[BURST_SIZE_MAX];
uint32_t grp_epoch;
uint16_t num_grp;
@@ -179,6 +180,8 @@ typedef struct {
struct {
uint8_t num_spread;
+ uint8_t burst_hi;
+ uint8_t burst_low;
} config;
uint32_t pri_count[NUM_PRIO][MAX_SPREAD];
@@ -252,6 +255,34 @@ static int read_config_file(sched_global_t *sched)
}
sched->config.num_spread = val;
+ ODP_PRINT(" %s: %i\n", str, val);
+
+ str = "sched_basic.burst_size_hi";
+ if (!_odp_libconfig_lookup_int(str, &val)) {
+ ODP_ERR("Config option '%s' not found.\n", str);
+ return -1;
+ }
+
+ if (val > BURST_SIZE_MAX || val < BURST_SIZE_MIN) {
+ ODP_ERR("Bad value %s = %u\n", str, val);
+ return -1;
+ }
+
+ sched->config.burst_hi = val;
+ ODP_PRINT(" %s: %i\n", str, val);
+
+ str = "sched_basic.burst_size_low";
+ if (!_odp_libconfig_lookup_int(str, &val)) {
+ ODP_ERR("Config option '%s' not found.\n", str);
+ return -1;
+ }
+
+ if (val > BURST_SIZE_MAX || val < BURST_SIZE_MIN) {
+ ODP_ERR("Bad value %s = %u\n", str, val);
+ return -1;
+ }
+
+ sched->config.burst_low = val;
ODP_PRINT(" %s: %i\n\n", str, val);
return 0;
@@ -767,7 +798,7 @@ static inline int poll_pktin(uint32_t qi, int direct_recv,
odp_buffer_hdr_t **hdr_tbl;
int ret;
void *q_int;
- odp_buffer_hdr_t *b_hdr[BURST_SIZE];
+ odp_buffer_hdr_t *b_hdr[BURST_SIZE_MAX];
hdr_tbl = (odp_buffer_hdr_t **)ev_tbl;
@@ -775,8 +806,8 @@ static inline int poll_pktin(uint32_t qi, int direct_recv,
hdr_tbl = b_hdr;
/* Limit burst to max queue enqueue size */
- if (max_num > BURST_SIZE)
- max_num = BURST_SIZE;
+ if (max_num > BURST_SIZE_MAX)
+ max_num = BURST_SIZE_MAX;
}
pktio_index = sched->queue[qi].pktio_index;
@@ -831,6 +862,7 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
int ret;
int id;
uint32_t qi;
+ unsigned int max_burst;
int num_spread = sched->config.num_spread;
uint32_t ring_mask = sched->ring_mask;
@@ -840,6 +872,10 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
if (sched->pri_mask[prio] == 0)
continue;
+ max_burst = sched->config.burst_hi;
+ if (prio > ODP_SCHED_PRIO_DEFAULT)
+ max_burst = sched->config.burst_low;
+
/* Select the first ring based on weights */
id = first;
@@ -849,7 +885,7 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
odp_queue_t handle;
ring_t *ring;
int pktin;
- unsigned int max_deq = BURST_SIZE;
+ unsigned int max_deq = max_burst;
int stashed = 1;
odp_event_t *ev_tbl = sched_local.stash_ev;
@@ -877,24 +913,17 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
ordered = queue_is_ordered(qi);
- /* When application's array is larger than our burst
+ /* When application's array is larger than max burst
* size, output all events directly there. Also, ordered
* queues are not stashed locally to improve
* parallelism. Ordered context can only be released
* when the local cache is empty. */
- if (max_num > BURST_SIZE || ordered) {
+ if (max_num > max_burst || ordered) {
stashed = 0;
ev_tbl = out_ev;
max_deq = max_num;
}
- /* Low priorities have smaller burst size to limit
- * head of line blocking latency. */
- if (BURST_SIZE > 1 &&
- odp_unlikely(prio > ODP_SCHED_PRIO_DEFAULT) &&
- max_deq > BURST_SIZE / 2)
- max_deq = BURST_SIZE / 2;
-
pktin = queue_is_pktin(qi);
num = sched_queue_deq(qi, ev_tbl, max_deq, !pktin);
commit 0070431f72dacef15d104bcf2baa9d70629d3d31
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Thu Jul 5 11:14:26 2018 +0300
linux-gen: sched: move basic queue scheduler functions
Moved and renamed basic queue interface functions towards
schedulers. Queue and scheduler implementations are tied
together as queue enq/deq operations change queue scheduling
state. Three schedulers are based on basic queue implementation
and include basic queue internal header file already. Move this
internal interface into proper internal header file.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_queue_basic_internal.h b/platform/linux-generic/include/odp_queue_basic_internal.h
index 0a81f3c4..654b9e31 100644
--- a/platform/linux-generic/include/odp_queue_basic_internal.h
+++ b/platform/linux-generic/include/odp_queue_basic_internal.h
@@ -98,6 +98,13 @@ static inline odp_queue_t queue_from_index(uint32_t queue_id)
void queue_spsc_init(queue_entry_t *queue, uint32_t queue_size);
+/* Functions for schedulers */
+void sched_queue_destroy_finalize(uint32_t queue_index);
+void sched_queue_set_status(uint32_t queue_index, int status);
+int sched_queue_deq(uint32_t queue_index, odp_event_t ev[], int num,
+ int update_status);
+int sched_queue_empty(uint32_t queue_index);
+
#ifdef __cplusplus
}
#endif
diff --git a/platform/linux-generic/include/odp_schedule_if.h b/platform/linux-generic/include/odp_schedule_if.h
index 0d095262..8f082aaa 100644
--- a/platform/linux-generic/include/odp_schedule_if.h
+++ b/platform/linux-generic/include/odp_schedule_if.h
@@ -82,12 +82,6 @@ int sched_cb_pktin_poll(int pktio_index, int pktin_index,
int sched_cb_pktin_poll_old(int pktio_index, int num_queue, int index[]);
int sched_cb_pktin_poll_one(int pktio_index, int rx_queue, odp_event_t evts[]);
void sched_cb_pktio_stop_finalize(int pktio_index);
-odp_queue_t sched_cb_queue_handle(uint32_t queue_index);
-void sched_cb_queue_destroy_finalize(uint32_t queue_index);
-void sched_cb_queue_set_status(uint32_t queue_index, int status);
-int sched_cb_queue_deq_multi(uint32_t queue_index, odp_event_t ev[], int num,
- int update_status);
-int sched_cb_queue_empty(uint32_t queue_index);
/* API functions */
typedef struct {
diff --git a/platform/linux-generic/odp_queue_basic.c b/platform/linux-generic/odp_queue_basic.c
index 3962f9f1..89eed3c0 100644
--- a/platform/linux-generic/odp_queue_basic.c
+++ b/platform/linux-generic/odp_queue_basic.c
@@ -357,7 +357,7 @@ static odp_queue_t queue_create(const char *name,
return handle;
}
-void sched_cb_queue_destroy_finalize(uint32_t queue_index)
+void sched_queue_destroy_finalize(uint32_t queue_index)
{
queue_entry_t *queue = qentry_from_index(queue_index);
@@ -370,7 +370,7 @@ void sched_cb_queue_destroy_finalize(uint32_t queue_index)
UNLOCK(queue);
}
-void sched_cb_queue_set_status(uint32_t queue_index, int status)
+void sched_queue_set_status(uint32_t queue_index, int status)
{
queue_entry_t *queue = qentry_from_index(queue_index);
@@ -761,8 +761,8 @@ static int queue_info(odp_queue_t handle, odp_queue_info_t *info)
return 0;
}
-int sched_cb_queue_deq_multi(uint32_t queue_index, odp_event_t ev[],
- int max_num, int update_status)
+int sched_queue_deq(uint32_t queue_index, odp_event_t ev[], int max_num,
+ int update_status)
{
int num_deq;
ring_st_t *ring_st;
@@ -807,7 +807,7 @@ int sched_cb_queue_deq_multi(uint32_t queue_index, odp_event_t ev[],
return num_deq;
}
-int sched_cb_queue_empty(uint32_t queue_index)
+int sched_queue_empty(uint32_t queue_index)
{
queue_entry_t *queue = qentry_from_index(queue_index);
int ret = 0;
diff --git a/platform/linux-generic/odp_schedule_basic.c b/platform/linux-generic/odp_schedule_basic.c
index fbe5b26a..75434149 100644
--- a/platform/linux-generic/odp_schedule_basic.c
+++ b/platform/linux-generic/odp_schedule_basic.c
@@ -363,7 +363,7 @@ static int schedule_init_global(void)
static inline void queue_destroy_finalize(uint32_t qi)
{
- sched_cb_queue_destroy_finalize(qi);
+ sched_queue_destroy_finalize(qi);
}
static int schedule_term_global(void)
@@ -384,9 +384,7 @@ static int schedule_term_global(void)
odp_event_t events[1];
int num;
- num = sched_cb_queue_deq_multi(qi,
- events,
- 1, 1);
+ num = sched_queue_deq(qi, events, 1, 1);
if (num < 0)
queue_destroy_finalize(qi);
@@ -581,7 +579,7 @@ static void schedule_pktio_start(int pktio_index, int num_pktin,
ODP_ASSERT(pktin_idx[i] <= MAX_PKTIN_INDEX);
/* Start polling */
- sched_cb_queue_set_status(qi, QUEUE_STATUS_SCHED);
+ sched_queue_set_status(qi, QUEUE_STATUS_SCHED);
schedule_sched_queue(qi);
}
}
@@ -797,7 +795,7 @@ static inline int poll_pktin(uint32_t qi, int direct_recv,
num_pktin = sched->pktio[pktio_index].num_pktin;
odp_spinlock_unlock(&sched->pktio_lock);
- sched_cb_queue_set_status(qi, QUEUE_STATUS_NOTSCHED);
+ sched_queue_set_status(qi, QUEUE_STATUS_NOTSCHED);
if (num_pktin == 0)
sched_cb_pktio_stop_finalize(pktio_index);
@@ -899,13 +897,12 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
pktin = queue_is_pktin(qi);
- num = sched_cb_queue_deq_multi(qi, ev_tbl, max_deq,
- !pktin);
+ num = sched_queue_deq(qi, ev_tbl, max_deq, !pktin);
if (num < 0) {
/* Destroyed queue. Continue scheduling the same
* priority queue. */
- sched_cb_queue_destroy_finalize(qi);
+ sched_queue_destroy_finalize(qi);
continue;
}
diff --git a/platform/linux-generic/odp_schedule_iquery.c b/platform/linux-generic/odp_schedule_iquery.c
index e7e23aa5..2501a3f6 100644
--- a/platform/linux-generic/odp_schedule_iquery.c
+++ b/platform/linux-generic/odp_schedule_iquery.c
@@ -289,10 +289,10 @@ static int schedule_term_global(void)
odp_event_t events[1];
if (sched->availables[i])
- count = sched_cb_queue_deq_multi(i, events, 1, 1);
+ count = sched_queue_deq(i, events, 1, 1);
if (count < 0)
- sched_cb_queue_destroy_finalize(i);
+ sched_queue_destroy_finalize(i);
else if (count > 0)
ODP_ERR("Queue (%d) not empty\n", i);
}
@@ -1532,12 +1532,11 @@ static inline int consume_queue(int prio, unsigned int queue_index)
if (is_ordered_queue(queue_index))
max = 1;
- count = sched_cb_queue_deq_multi(
- queue_index, cache->stash, max, 1);
+ count = sched_queue_deq(queue_index, cache->stash, max, 1);
if (count < 0) {
DO_SCHED_UNLOCK();
- sched_cb_queue_destroy_finalize(queue_index);
+ sched_queue_destroy_finalize(queue_index);
DO_SCHED_LOCK();
return 0;
}
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index b6bb3b2b..ae292051 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -228,7 +228,7 @@ static int term_global(void)
for (qi = 0; qi < NUM_QUEUE; qi++) {
if (sched_global->queue_cmd[qi].s.init) {
/* todo: dequeue until empty ? */
- sched_cb_queue_destroy_finalize(qi);
+ sched_queue_destroy_finalize(qi);
}
}
@@ -507,7 +507,7 @@ static int schedule_multi(odp_queue_t *from, uint64_t wait,
if (sched_local.cmd) {
/* Continue scheduling if queue is not empty */
- if (sched_cb_queue_empty(sched_local.cmd->s.index) == 0)
+ if (sched_queue_empty(sched_local.cmd->s.index) == 0)
add_tail(sched_local.cmd);
sched_local.cmd = NULL;
@@ -562,7 +562,7 @@ static int schedule_multi(odp_queue_t *from, uint64_t wait,
}
qi = cmd->s.index;
- num = sched_cb_queue_deq_multi(qi, events, 1, 1);
+ num = sched_queue_deq(qi, events, 1, 1);
if (num > 0) {
sched_local.cmd = cmd;
@@ -575,7 +575,7 @@ static int schedule_multi(odp_queue_t *from, uint64_t wait,
if (num < 0) {
/* Destroyed queue */
- sched_cb_queue_destroy_finalize(qi);
+ sched_queue_destroy_finalize(qi);
continue;
}
commit 5a43e72ba90dc5b4ea4ae3e8875075440e709655
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Thu Jul 5 10:54:16 2018 +0300
linux-gen: queue: rename queue basic internal header file
This is internal interface towards queue basic.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index a3399011..13101cfd 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -123,7 +123,7 @@ noinst_HEADERS = \
include/odp_pool_internal.h \
include/odp_posix_extensions.h \
include/odp_queue_if.h \
- include/odp_queue_internal.h \
+ include/odp_queue_basic_internal.h \
include/odp_queue_lf.h \
include/odp_queue_scalable_internal.h \
include/odp_ring_internal.h \
diff --git a/platform/linux-generic/include/odp_queue_internal.h b/platform/linux-generic/include/odp_queue_basic_internal.h
similarity index 97%
rename from platform/linux-generic/include/odp_queue_internal.h
rename to platform/linux-generic/include/odp_queue_basic_internal.h
index bb74f729..0a81f3c4 100644
--- a/platform/linux-generic/include/odp_queue_internal.h
+++ b/platform/linux-generic/include/odp_queue_basic_internal.h
@@ -4,8 +4,8 @@
* SPDX-License-Identifier: BSD-3-Clause
*/
-#ifndef ODP_QUEUE_INTERNAL_H_
-#define ODP_QUEUE_INTERNAL_H_
+#ifndef ODP_QUEUE_BASIC_INTERNAL_H_
+#define ODP_QUEUE_BASIC_INTERNAL_H_
#ifdef __cplusplus
extern "C" {
diff --git a/platform/linux-generic/odp_queue_basic.c b/platform/linux-generic/odp_queue_basic.c
index 311fda69..3962f9f1 100644
--- a/platform/linux-generic/odp_queue_basic.c
+++ b/platform/linux-generic/odp_queue_basic.c
@@ -7,7 +7,7 @@
#include "config.h"
#include <odp/api/queue.h>
-#include <odp_queue_internal.h>
+#include <odp_queue_basic_internal.h>
#include <odp_queue_if.h>
#include <odp/api/std_types.h>
#include <odp/api/align.h>
diff --git a/platform/linux-generic/odp_queue_lf.c b/platform/linux-generic/odp_queue_lf.c
index 3ec32524..d12a994b 100644
--- a/platform/linux-generic/odp_queue_lf.c
+++ b/platform/linux-generic/odp_queue_lf.c
@@ -8,7 +8,7 @@
#include <odp/api/atomic.h>
#include <odp/api/plat/atomic_inlines.h>
#include <odp/api/shared_memory.h>
-#include <odp_queue_internal.h>
+#include <odp_queue_basic_internal.h>
#include <string.h>
#include <stdio.h>
diff --git a/platform/linux-generic/odp_queue_spsc.c b/platform/linux-generic/odp_queue_spsc.c
index f8b04ca2..3e42b038 100644
--- a/platform/linux-generic/odp_queue_spsc.c
+++ b/platform/linux-generic/odp_queue_spsc.c
@@ -6,7 +6,7 @@
#include <string.h>
#include <stdio.h>
-#include <odp_queue_internal.h>
+#include <odp_queue_basic_internal.h>
#include <odp_pool_internal.h>
#include "config.h"
diff --git a/platform/linux-generic/odp_schedule_basic.c b/platform/linux-generic/odp_schedule_basic.c
index f45bc8f1..fbe5b26a 100644
--- a/platform/linux-generic/odp_schedule_basic.c
+++ b/platform/linux-generic/odp_schedule_basic.c
@@ -26,7 +26,7 @@
#include <odp/api/packet_io.h>
#include <odp_ring_internal.h>
#include <odp_timer_internal.h>
-#include <odp_queue_internal.h>
+#include <odp_queue_basic_internal.h>
#include <odp_libconfig_internal.h>
/* Number of priority levels */
diff --git a/platform/linux-generic/odp_schedule_iquery.c b/platform/linux-generic/odp_schedule_iquery.c
index c1e51bb5..e7e23aa5 100644
--- a/platform/linux-generic/odp_schedule_iquery.c
+++ b/platform/linux-generic/odp_schedule_iquery.c
@@ -25,9 +25,7 @@
#include <odp/api/packet_io.h>
#include <odp_config_internal.h>
#include <odp_timer_internal.h>
-
-/* Should remove this dependency */
-#include <odp_queue_internal.h>
+#include <odp_queue_basic_internal.h>
/* Number of priority levels */
#define NUM_SCHED_PRIO 8
diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c
index ac0b35fd..b6bb3b2b 100644
--- a/platform/linux-generic/odp_schedule_sp.c
+++ b/platform/linux-generic/odp_schedule_sp.c
@@ -20,7 +20,7 @@
#include <odp_config_internal.h>
#include <odp_ring_internal.h>
#include <odp_timer_internal.h>
-#include <odp_queue_internal.h>
+#include <odp_queue_basic_internal.h>
#define NUM_THREAD ODP_THREAD_COUNT_MAX
#define NUM_QUEUE ODP_CONFIG_QUEUES
commit 0ee7d42a7280e7ced1ea2f97e80dc752f28f76b2
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Thu Jul 5 10:33:34 2018 +0300
linux-gen: queue: separate plain and sched dequeues
Separate dequeue functions for plain and scheduled queues.
Plain queue dequeue function become simpler and scheduler
dequeue function may be optimized later as it is a single
consumer dequeue operation.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_queue_basic.c b/platform/linux-generic/odp_queue_basic.c
index 39e2d59c..311fda69 100644
--- a/platform/linux-generic/odp_queue_basic.c
+++ b/platform/linux-generic/odp_queue_basic.c
@@ -576,10 +576,9 @@ static int queue_enq(odp_queue_t handle, odp_event_t ev)
(odp_buffer_hdr_t *)(uintptr_t)ev);
}
-static inline int deq_multi(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr[],
- int num, int update_status)
+static inline int plain_queue_deq(queue_entry_t *queue,
+ odp_buffer_hdr_t *buf_hdr[], int num)
{
- int status_sync = sched_fn->status_sync;
int num_deq;
ring_st_t *ring_st;
uint32_t buf_idx[num];
@@ -589,32 +588,17 @@ static inline int deq_multi(queue_entry_t *queue, odp_buffer_hdr_t *buf_hdr[],
LOCK(queue);
if (odp_unlikely(queue->s.status < QUEUE_STATUS_READY)) {
- /* Bad queue, or queue has been destroyed.
- * Scheduler finalizes queue destroy after this. */
+ /* Bad queue, or queue has been destroyed. */
UNLOCK(queue);
return -1;
}
num_deq = ring_st_deq_multi(ring_st, buf_idx, num);
- if (num_deq == 0) {
- /* Already empty queue */
- if (update_status && queue->s.status == QUEUE_STATUS_SCHED) {
- queue->s.status = QUEUE_STATUS_NOTSCHED;
-
- if (status_sync)
- sched_fn->unsched_queue(queue->s.index);
- }
-
- UNLOCK(queue);
+ UNLOCK(queue);
+ if (num_deq == 0)
return 0;
- }
-
- if (status_sync && queue->s.type == ODP_QUEUE_TYPE_SCHED)
- sched_fn->save_context(queue->s.index);
-
- UNLOCK(queue);
buffer_index_to_buf(buf_hdr, buf_idx, num_deq);
@@ -626,7 +610,7 @@ static int queue_int_deq_multi(void *q_int, odp_buffer_hdr_t *buf_hdr[],
{
queue_entry_t *queue = q_int;
- return deq_multi(queue, buf_hdr, num, 0);
+ return plain_queue_deq(queue, buf_hdr, num);
}
static odp_buffer_hdr_t *queue_int_deq(void *q_int)
@@ -635,7 +619,7 @@ static odp_buffer_hdr_t *queue_int_deq(void *q_int)
odp_buffer_hdr_t *buf_hdr = NULL;
int ret;
- ret = deq_multi(queue, &buf_hdr, 1, 0);
+ ret = plain_queue_deq(queue, &buf_hdr, 1);
if (ret == 1)
return buf_hdr;
@@ -777,12 +761,50 @@ static int queue_info(odp_queue_t handle, odp_queue_info_t *info)
return 0;
}
-int sched_cb_queue_deq_multi(uint32_t queue_index, odp_event_t ev[], int num,
- int update_status)
+int sched_cb_queue_deq_multi(uint32_t queue_index, odp_event_t ev[],
+ int max_num, int update_status)
{
- queue_entry_t *qe = qentry_from_index(queue_index);
+ int num_deq;
+ ring_st_t *ring_st;
+ queue_entry_t *queue = qentry_from_index(queue_index);
+ int status_sync = sched_fn->status_sync;
+ uint32_t buf_idx[max_num];
+
+ ring_st = &queue->s.ring_st;
+
+ LOCK(queue);
- return deq_multi(qe, (odp_buffer_hdr_t **)ev, num, update_status);
+ if (odp_unlikely(queue->s.status < QUEUE_STATUS_READY)) {
+ /* Bad queue, or queue has been destroyed.
+ * Scheduler finalizes queue destroy after this. */
+ UNLOCK(queue);
+ return -1;
+ }
+
+ num_deq = ring_st_deq_multi(ring_st, buf_idx, max_num);
+
+ if (num_deq == 0) {
+ /* Already empty queue */
+ if (update_status && queue->s.status == QUEUE_STATUS_SCHED) {
+ queue->s.status = QUEUE_STATUS_NOTSCHED;
+
+ if (status_sync)
+ sched_fn->unsched_queue(queue->s.index);
+ }
+
+ UNLOCK(queue);
+
+ return 0;
+ }
+
+ if (status_sync && queue->s.type == ODP_QUEUE_TYPE_SCHED)
+ sched_fn->save_context(queue->s.index);
+
+ UNLOCK(queue);
+
+ buffer_index_to_buf((odp_buffer_hdr_t **)ev, buf_idx, num_deq);
+
+ return num_deq;
}
int sched_cb_queue_empty(uint32_t queue_index)
commit c7bbbb603fc4cf2e6590af962e2e255241d18276
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Wed Jul 4 17:17:46 2018 +0300
linux-gen: sched: support large burst size from pktin
When directly receiving from pktin (atomic or parallel queues),
output event handles directly to destination array (scheduler
stash or application's array). This avoids extra handle copy
and enables supports for large burst sizes.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_schedule_basic.c b/platform/linux-generic/odp_schedule_basic.c
index 78ab6135..f45bc8f1 100644
--- a/platform/linux-generic/odp_schedule_basic.c
+++ b/platform/linux-generic/odp_schedule_basic.c
@@ -762,17 +762,29 @@ static inline int queue_is_pktin(uint32_t queue_index)
return sched->queue[queue_index].poll_pktin;
}
-static inline int poll_pktin(uint32_t qi, int stash)
+static inline int poll_pktin(uint32_t qi, int direct_recv,
+ odp_event_t ev_tbl[], int max_num)
{
- odp_buffer_hdr_t *b_hdr[BURST_SIZE];
- int pktio_index, pktin_index, num, num_pktin, i;
+ int pktio_index, pktin_index, num, num_pktin;
+ odp_buffer_hdr_t **hdr_tbl;
int ret;
void *q_int;
+ odp_buffer_hdr_t *b_hdr[BURST_SIZE];
+
+ hdr_tbl = (odp_buffer_hdr_t **)ev_tbl;
+
+ if (!direct_recv) {
+ hdr_tbl = b_hdr;
+
+ /* Limit burst to max queue enqueue size */
+ if (max_num > BURST_SIZE)
+ max_num = BURST_SIZE;
+ }
pktio_index = sched->queue[qi].pktio_index;
pktin_index = sched->queue[qi].pktin_index;
- num = sched_cb_pktin_poll(pktio_index, pktin_index, b_hdr, BURST_SIZE);
+ num = sched_cb_pktin_poll(pktio_index, pktin_index, hdr_tbl, max_num);
if (num == 0)
return 0;
@@ -793,12 +805,8 @@ static inline int poll_pktin(uint32_t qi, int stash)
return num;
}
- if (stash) {
- for (i = 0; i < num; i++)
- sched_local.stash_ev[i] = event_from_buf_hdr(b_hdr[i]);
-
+ if (direct_recv)
return num;
- }
q_int = qentry_from_index(qi);
@@ -908,13 +916,16 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
* priorities. Stop scheduling queue when pktio
* has been stopped. */
if (pktin) {
- int stash = !ordered;
- int num_pkt = poll_pktin(qi, stash);
+ int direct_recv = !ordered;
+ int num_pkt;
+
+ num_pkt = poll_pktin(qi, direct_recv,
+ ev_tbl, max_deq);
if (odp_unlikely(num_pkt < 0))
continue;
- if (num_pkt == 0 || !stash) {
+ if (num_pkt == 0 || !direct_recv) {
ring_enq(ring, ring_mask, qi);
break;
}
@@ -922,7 +933,6 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
/* Process packets from an atomic or
* parallel queue right away. */
num = num_pkt;
- stashed = 1;
} else {
/* Remove empty queue from scheduling.
* Continue scheduling the same priority
commit c0d530e01e91fbea195993293eed60f1677e6181
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Wed Jul 4 14:11:59 2018 +0300
linux-gen: sched: support large burst sizes
Small burst sizes are rounded up to CONFIG_BURST_SIZE and excess
events are stashed. Larger (>CONFIG_BURST_SIZE) bursts are stored
directly into application buffer and nothing is stashed.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/odp_schedule_basic.c b/platform/linux-generic/odp_schedule_basic.c
index c81e417c..78ab6135 100644
--- a/platform/linux-generic/odp_schedule_basic.c
+++ b/platform/linux-generic/odp_schedule_basic.c
@@ -92,8 +92,9 @@ ODP_STATIC_ASSERT((8 * sizeof(pri_mask_t)) >= MAX_SPREAD,
/* Start of named groups in group mask arrays */
#define SCHED_GROUP_NAMED (ODP_SCHED_GROUP_CONTROL + 1)
-/* Maximum number of dequeues */
-#define MAX_DEQ CONFIG_BURST_SIZE
+/* Default burst size. Scheduler rounds up number of requested events up to
+ * this value. */
+#define BURST_SIZE CONFIG_BURST_SIZE
/* Ordered stash size */
#define MAX_ORDERED_STASH 512
@@ -123,7 +124,7 @@ typedef struct {
uint16_t spread_round;
uint32_t stash_qi;
odp_queue_t stash_queue;
- odp_event_t stash_ev[MAX_DEQ];
+ odp_event_t stash_ev[BURST_SIZE];
uint32_t grp_epoch;
uint16_t num_grp;
@@ -763,7 +764,7 @@ static inline int queue_is_pktin(uint32_t queue_index)
static inline int poll_pktin(uint32_t qi, int stash)
{
- odp_buffer_hdr_t *b_hdr[MAX_DEQ];
+ odp_buffer_hdr_t *b_hdr[BURST_SIZE];
int pktio_index, pktin_index, num, num_pktin, i;
int ret;
void *q_int;
@@ -771,7 +772,7 @@ static inline int poll_pktin(uint32_t qi, int stash)
pktio_index = sched->queue[qi].pktio_index;
pktin_index = sched->queue[qi].pktin_index;
- num = sched_cb_pktin_poll(pktio_index, pktin_index, b_hdr, MAX_DEQ);
+ num = sched_cb_pktin_poll(pktio_index, pktin_index, b_hdr, BURST_SIZE);
if (num == 0)
return 0;
@@ -824,7 +825,6 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
int ret;
int id;
uint32_t qi;
- unsigned int max_deq = MAX_DEQ;
int num_spread = sched->config.num_spread;
uint32_t ring_mask = sched->ring_mask;
@@ -843,6 +843,9 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
odp_queue_t handle;
ring_t *ring;
int pktin;
+ unsigned int max_deq = BURST_SIZE;
+ int stashed = 1;
+ odp_event_t *ev_tbl = sched_local.stash_ev;
if (id >= num_spread)
id = 0;
@@ -866,24 +869,30 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
continue;
}
- /* Low priorities have smaller batch size to limit
- * head of line blocking latency. */
- if (odp_unlikely(MAX_DEQ > 1 &&
- prio > ODP_SCHED_PRIO_DEFAULT))
- max_deq = MAX_DEQ / 2;
-
ordered = queue_is_ordered(qi);
- /* Do not cache ordered events locally to improve
+ /* When application's array is larger than our burst
+ * size, output all events directly there. Also, ordered
+ * queues are not stashed locally to improve
* parallelism. Ordered context can only be released
* when the local cache is empty. */
- if (ordered && max_num < MAX_DEQ)
+ if (max_num > BURST_SIZE || ordered) {
+ stashed = 0;
+ ev_tbl = out_ev;
max_deq = max_num;
+ }
+
+ /* Low priorities have smaller burst size to limit
+ * head of line blocking latency. */
+ if (BURST_SIZE > 1 &&
+ odp_unlikely(prio > ODP_SCHED_PRIO_DEFAULT) &&
+ max_deq > BURST_SIZE / 2)
+ max_deq = BURST_SIZE / 2;
pktin = queue_is_pktin(qi);
- num = sched_cb_queue_deq_multi(qi, sched_local.stash_ev,
- max_deq, !pktin);
+ num = sched_cb_queue_deq_multi(qi, ev_tbl, max_deq,
+ !pktin);
if (num < 0) {
/* Destroyed queue. Continue scheduling the same
@@ -913,6 +922,7 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
/* Process packets from an atomic or
* parallel queue right away. */
num = num_pkt;
+ stashed = 1;
} else {
/* Remove empty queue from scheduling.
* Continue scheduling the same priority
@@ -943,10 +953,16 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, odp_event_t out_ev[],
}
handle = queue_from_index(qi);
- sched_local.stash_num = num;
- sched_local.stash_index = 0;
- sched_local.stash_queue = handle;
- ret = copy_from_stash(out_ev, max_num);
+
+ if (stashed) {
+ sched_local.stash_num = num;
+ sched_local.stash_index = 0;
+ sched_local.stash_queue = handle;
+ ret = copy_from_stash(out_ev, max_num);
+ } else {
+ sched_local.stash_num = 0;
+ ret = num;
+ }
/* Output the source queue handle */
if (out_queue)
-----------------------------------------------------------------------
Summary of changes:
config/odp-linux-generic.conf | 11 ++
platform/linux-generic/Makefile.am | 2 +-
...queue_internal.h => odp_queue_basic_internal.h} | 11 +-
platform/linux-generic/include/odp_schedule_if.h | 6 -
platform/linux-generic/odp_queue_basic.c | 84 +++++++++-----
platform/linux-generic/odp_queue_lf.c | 2 +-
platform/linux-generic/odp_queue_spsc.c | 2 +-
platform/linux-generic/odp_schedule_basic.c | 128 +++++++++++++++------
platform/linux-generic/odp_schedule_iquery.c | 13 +--
platform/linux-generic/odp_schedule_sp.c | 10 +-
10 files changed, 176 insertions(+), 93 deletions(-)
rename platform/linux-generic/include/{odp_queue_internal.h => odp_queue_basic_internal.h} (86%)
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch master updated. v1.19.0.2_tigermoth-16-g942bbe22
by git＠git-us.linaro.org
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 942bbe22b7147e2988aa0b82e094a53421f2c486 (commit)
via d5690aa464880a258f653e1b4d68f150b4c660a8 (commit)
via 8418efbab3fe38ed701d9294800ec85d467763df (commit)
from 6ac9ea26a82c8f71b989d4dc6af22e3e5df62d48 (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 942bbe22b7147e2988aa0b82e094a53421f2c486
Author: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Date: Mon Jul 9 21:54:34 2018 +0300
travis: switch iptables policy to let tap driver work
Fix suggested by Maxim Uvarov.
Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/.travis.yml b/.travis.yml
index 8d918775..26bbe1a3 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -144,6 +144,10 @@ before_install:
- export PKG_CONFIG_PATH="$HOME/cunit-install/$CROSS_ARCH/lib/pkgconfig:${PKG_CONFIG_PATH}"
- find $HOME/cunit-install
+ # workaround for tap driver issues on recent Travis images
+ # Allow forwaring on virtual interfaces used for testing
+ - sudo iptables --policy FORWARD ACCEPT
+
install:
- echo 1000 | sudo tee /proc/sys/vm/nr_hugepages
commit d5690aa464880a258f653e1b4d68f150b4c660a8
Author: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Date: Mon Jul 9 17:00:10 2018 +0300
travis: pin repositories to architectures
Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/.travis.yml b/.travis.yml
index 0130eb64..8d918775 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -76,20 +76,22 @@ before_install:
CROSS_MULTIARCH=`dpkg-architecture -a"$CROSS_ARCH" -qDEB_HOST_MULTIARCH` ;
CROSS="--host="$CROSS_GNU_TYPE" --build="$BUILD_GNU_TYPE"" ;
sudo dpkg --add-architecture "$CROSS_ARCH" ;
- sudo -E apt-add-repository -y "deb http://ports.ubuntu.com trusty main" ;
- sudo -E apt-add-repository -y "deb http://ports.ubuntu.com trusty-updates main" ;
- sudo -E apt-get -y update || true ;
PKGS="build-essential libc6-dev:$CROSS_ARCH libssl-dev:$CROSS_ARCH zlib1g-dev:$CROSS_ARCH libconfig-dev:$CROSS_ARCH libstdc++-4.8-dev:$CROSS_ARCH libpcap0.8-dev:$CROSS_ARCH" ;
if [ "$CROSS_ARCH" = "i386" ] ;
then
PKGS="$PKGS g++-multilib" ;
else
PKGS="$PKGS g++-$CROSS_GNU_TYPE" ;
+ sudo sed -e 's/^deb http/deb [arch=amd64] http/g' /etc/apt/sources.list -i ;
+ sudo -E apt-add-repository -y "deb [arch=$CROSS_ARCH] http://ports.ubuntu.com trusty main" ;
+ sudo -E apt-add-repository -y "deb [arch=$CROSS_ARCH] http://ports.ubuntu.com trusty-updates main" ;
fi ;
if [ "$CROSS_ARCH" != "armhf" ] ;
then
PKGS="$PKGS libnuma-dev:$CROSS_ARCH" ;
fi ;
+ sudo cat /etc/apt/sources.list ;
+ sudo -E apt-get -y update || true ;
sudo -E apt-get -y --no-install-suggests --no-install-recommends --force-yes install $PKGS || exit 1 ;
export PKG_CONFIG_PATH=/usr/lib/${CROSS_MULTIARCH}/pkgconfig:/usr/${CROSS_MULTIARCH}/lib/pkgconfig ;
fi
commit 8418efbab3fe38ed701d9294800ec85d467763df
Author: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Date: Mon Jul 9 16:13:03 2018 +0300
travis: stop using deprecated image
Signed-off-by: Dmitry Eremin-Solenikov <dmitry.ereminsolenikov(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/.travis.yml b/.travis.yml
index 3431f27e..0130eb64 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -10,7 +10,6 @@
language: c
sudo: required
dist: trusty
-group: deprecated-2017Q2
stages:
- "build only"
- test
-----------------------------------------------------------------------
Summary of changes:
.travis.yml | 13 +++++++++----
1 file changed, 9 insertions(+), 4 deletions(-)
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch master updated. v1.19.0.2_tigermoth-13-g6ac9ea26
by git＠git-us.linaro.org
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 6ac9ea26a82c8f71b989d4dc6af22e3e5df62d48 (commit)
via a061f94424cd9cb434a203a04aec4c437dabf251 (commit)
from f7c03ade975b018be0766d5fea300d03642b4b12 (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 6ac9ea26a82c8f71b989d4dc6af22e3e5df62d48
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Thu Jul 5 12:14:07 2018 +0300
linux-gen: pktio: ring: guarantee enq/deq variable load order
Fix ___ring_mp_do_enqueue() and ___ring_mc_do_dequeue failing on weak
memory order architectures.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/pktio/ring.c b/platform/linux-generic/pktio/ring.c
index 332bb46b..bb0d6780 100644
--- a/platform/linux-generic/pktio/ring.c
+++ b/platform/linux-generic/pktio/ring.c
@@ -250,7 +250,7 @@ int ___ring_mp_do_enqueue(_ring_t *r, void * const *obj_table,
/* Reset n to the initial burst count */
n = max;
- prod_head = __atomic_load_n(&r->prod.head, __ATOMIC_RELAXED);
+ prod_head = __atomic_load_n(&r->prod.head, __ATOMIC_ACQUIRE);
cons_tail = __atomic_load_n(&r->cons.tail, __ATOMIC_ACQUIRE);
/* The subtraction is done between two unsigned 32bits value
* (the result is always modulo 32 bits even if we have
@@ -313,7 +313,7 @@ int ___ring_mc_do_dequeue(_ring_t *r, void **obj_table,
/* Restore n as it may change every loop */
n = max;
- cons_head = __atomic_load_n(&r->cons.head, __ATOMIC_RELAXED);
+ cons_head = __atomic_load_n(&r->cons.head, __ATOMIC_ACQUIRE);
prod_tail = __atomic_load_n(&r->prod.tail, __ATOMIC_ACQUIRE);
/* The subtraction is done between two unsigned 32bits value
* (the result is always modulo 32 bits even if we have
commit a061f94424cd9cb434a203a04aec4c437dabf251
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Thu Jul 5 10:11:32 2018 +0300
linux-gen: pktio: remove unused ring operations
Remove unused ring operations and water marking support to speed-up testing
and remove potential bugs with weak memory order architectures.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_packet_io_ring_internal.h b/platform/linux-generic/include/odp_packet_io_ring_internal.h
index e459e3a5..889a6559 100644
--- a/platform/linux-generic/include/odp_packet_io_ring_internal.h
+++ b/platform/linux-generic/include/odp_packet_io_ring_internal.h
@@ -133,8 +133,6 @@ typedef struct _ring {
/** @private Producer */
struct ODP_ALIGNED_CACHE _prod {
- uint32_t watermark; /* Maximum items */
- uint32_t sp_enqueue; /* True, if single producer. */
uint32_t size; /* Size of ring. */
uint32_t mask; /* Mask (size-1) of ring. */
volatile uint32_t head; /* Producer head. */
@@ -143,7 +141,6 @@ typedef struct _ring {
/** @private Consumer */
struct ODP_ALIGNED_CACHE _cons {
- uint32_t sc_dequeue; /* True, if single consumer. */
uint32_t size; /* Size of the ring. */
uint32_t mask; /* Mask (size-1) of ring. */
volatile uint32_t head; /* Consumer head. */
@@ -163,8 +160,6 @@ typedef struct _ring {
#define _RING_SHM_PROC (1 << 2)
/* Do not link ring to linked list. */
#define _RING_NO_LIST (1 << 3)
-/* Quota exceed for burst ops */
-#define _RING_QUOT_EXCEED (1 << 31)
/* Ring size mask */
#define _RING_SZ_MASK (unsigned)(0x0fffffff)
@@ -172,9 +167,8 @@ typedef struct _ring {
* Create a new ring named *name* in memory.
*
* This function uses odp_shm_reserve() to allocate memory. Its size is
- * set to *count*, which must be a power of two. Water marking is
- * disabled by default. Note that the real usable ring size is count-1
- * instead of count.
+ * set to *count*, which must be a power of two. Note that the real usable
+ * ring size is count-1 instead of count.
*
* @param name
* The name of the ring.
@@ -207,23 +201,6 @@ _ring_t *_ring_create(const char *name, unsigned count,
*/
int _ring_destroy(const char *name);
-/**
- * Change the high water mark.
- *
- * If *count* is 0, water marking is disabled. Otherwise, it is set to the
- * *count* value. The *count* value must be greater than 0 and less
- * than the ring size.
- *
- * This function can be called at any time (not necessarily at
- * initialization).
- *
- * @param r Pointer to the ring structure.
- * @param count New water mark value.
- * @return 0: Success; water mark changed.
- * -EINVAL: Invalid water mark value.
- */
-int _ring_set_water_mark(_ring_t *r, unsigned count);
-
/**
* Dump the status of the ring to the console.
*
@@ -250,8 +227,6 @@ void _ring_dump(const _ring_t *r);
* Depend on the behavior value
* if behavior = ODPH_RING_QUEUE_FIXED
* - 0: Success; objects enqueue.
- * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the
- * high water mark is exceeded.
* - -ENOBUFS: Not enough room in the ring to enqueue, no object is enqueued.
* if behavior = ODPH_RING_QUEUE_VARIABLE
* - n: Actual number of objects enqueued.
@@ -260,32 +235,6 @@ int ___ring_mp_do_enqueue(_ring_t *r, void * const *obj_table,
unsigned n,
enum _ring_queue_behavior behavior);
-/**
- * Enqueue several objects on a ring (NOT multi-producers safe).
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects).
- * @param n
- * The number of objects to add in the ring from the obj_table.
- * @param behavior
- * ODPH_RING_QUEUE_FIXED: Enqueue a fixed number of items from a ring
- * ODPH_RING_QUEUE_VARIABLE: Enqueue as many items a possible from ring
- * @return
- * Depend on the behavior value
- * if behavior = ODPH_RING_QUEUE_FIXED
- * - 0: Success; objects enqueue.
- * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the
- * high water mark is exceeded.
- * - -ENOBUFS: Not enough room in the ring to enqueue, no object is enqueued.
- * if behavior = ODPH_RING_QUEUE_VARIABLE
- * - n: Actual number of objects enqueued.
- */
-int ___ring_sp_do_enqueue(_ring_t *r, void * const *obj_table,
- unsigned n,
- enum _ring_queue_behavior behavior);
-
/**
* Dequeue several objects from a ring (multi-consumers safe). When
* the request objects are more than the available objects, only dequeue the
@@ -317,33 +266,6 @@ int ___ring_mc_do_dequeue(_ring_t *r, void **obj_table,
unsigned n,
enum _ring_queue_behavior behavior);
-/**
- * Dequeue several objects from a ring (NOT multi-consumers safe).
- * When the request objects are more than the available objects, only dequeue
- * the actual number of objects
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects) that will be filled.
- * @param n
- * The number of objects to dequeue from the ring to the obj_table.
- * @param behavior
- * ODPH_RING_QUEUE_FIXED: Dequeue a fixed number of items from a ring
- * ODPH_RING_QUEUE_VARIABLE: Dequeue as many items a possible from ring
- * @return
- * Depend on the behavior value
- * if behavior = ODPH_RING_QUEUE_FIXED
- * - 0: Success; objects dequeued.
- * - -ENOENT: Not enough entries in the ring to dequeue; no object is
- * dequeued.
- * if behavior = ODPH_RING_QUEUE_VARIABLE
- * - n: Actual number of objects dequeued.
- */
-int ___ring_sc_do_dequeue(_ring_t *r, void **obj_table,
- unsigned n,
- enum _ring_queue_behavior behavior);
-
/**
* Enqueue several objects on the ring (multi-producers safe).
*
@@ -365,24 +287,6 @@ int ___ring_sc_do_dequeue(_ring_t *r, void **obj_table,
int _ring_mp_enqueue_bulk(_ring_t *r, void * const *obj_table,
unsigned n);
-/**
- * Enqueue several objects on a ring (NOT multi-producers safe).
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects).
- * @param n
- * The number of objects to add in the ring from the obj_table.
- * @return
- * - 0: Success; objects enqueued.
- * - -EDQUOT: Quota exceeded. The objects have been enqueued, but the
- * high water mark is exceeded.
- * - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued.
- */
-int _ring_sp_enqueue_bulk(_ring_t *r, void * const *obj_table,
- unsigned n);
-
/**
* Dequeue several objects from a ring (multi-consumers safe).
*
@@ -402,23 +306,6 @@ int _ring_sp_enqueue_bulk(_ring_t *r, void * const *obj_table,
*/
int _ring_mc_dequeue_bulk(_ring_t *r, void **obj_table, unsigned n);
-/**
- * Dequeue several objects from a ring (NOT multi-consumers safe).
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects) that will be filled.
- * @param n
- * The number of objects to dequeue from the ring to the obj_table,
- * must be strictly positive.
- * @return
- * - 0: Success; objects dequeued.
- * - -ENOENT: Not enough entries in the ring to dequeue; no object is
- * dequeued.
- */
-int _ring_sc_dequeue_bulk(_ring_t *r, void **obj_table, unsigned n);
-
/**
* Test if a ring is full.
*
@@ -486,39 +373,6 @@ _ring_t *_ring_lookup(const char *name);
int _ring_mp_enqueue_burst(_ring_t *r, void * const *obj_table,
unsigned n);
-/**
- * Enqueue several objects on a ring (NOT multi-producers safe).
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects).
- * @param n
- * The number of objects to add in the ring from the obj_table.
- * @return
- * - n: Actual number of objects enqueued.
- */
-int _ring_sp_enqueue_burst(_ring_t *r, void * const *obj_table,
- unsigned n);
-/**
- * Enqueue several objects on a ring.
- *
- * This function calls the multi-producer or the single-producer
- * version depending on the default behavior that was specified at
- * ring creation time (see flags).
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects).
- * @param n
- * The number of objects to add in the ring from the obj_table.
- * @return
- * - n: Actual number of objects enqueued.
- */
-int _ring_enqueue_burst(_ring_t *r, void * const *obj_table,
- unsigned n);
-
/**
* Dequeue several objects from a ring (multi-consumers safe). When the request
* objects are more than the available objects, only dequeue the actual number
@@ -538,40 +392,6 @@ int _ring_enqueue_burst(_ring_t *r, void * const *obj_table,
*/
int _ring_mc_dequeue_burst(_ring_t *r, void **obj_table, unsigned n);
-/**
- * Dequeue several objects from a ring (NOT multi-consumers safe).When the
- * request objects are more than the available objects, only dequeue the
- * actual number of objects
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects) that will be filled.
- * @param n
- * The number of objects to dequeue from the ring to the obj_table.
- * @return
- * - n: Actual number of objects dequeued, 0 if ring is empty
- */
-int _ring_sc_dequeue_burst(_ring_t *r, void **obj_table, unsigned n);
-
-/**
- * Dequeue multiple objects from a ring up to a maximum number.
- *
- * This function calls the multi-consumers or the single-consumer
- * version, depending on the default behaviour that was specified at
- * ring creation time (see flags).
- *
- * @param r
- * A pointer to the ring structure.
- * @param obj_table
- * A pointer to a table of void * pointers (objects) that will be filled.
- * @param n
- * The number of objects to dequeue from the ring to the obj_table.
- * @return
- * - Number of objects dequeued, or a negative error code on error
- */
-int _ring_dequeue_burst(_ring_t *r, void **obj_table, unsigned n);
-
/**
* dump the status of all rings on the console
*/
diff --git a/platform/linux-generic/pktio/ring.c b/platform/linux-generic/pktio/ring.c
index 518d940e..332bb46b 100644
--- a/platform/linux-generic/pktio/ring.c
+++ b/platform/linux-generic/pktio/ring.c
@@ -195,9 +195,6 @@ _ring_create(const char *name, unsigned count, unsigned flags)
/* init the ring structure */
snprintf(r->name, sizeof(r->name), "%s", name);
r->flags = flags;
- r->prod.watermark = count;
- r->prod.sp_enqueue = !!(flags & _RING_F_SP_ENQ);
- r->cons.sc_dequeue = !!(flags & _RING_F_SC_DEQ);
r->prod.size = count;
r->cons.size = count;
r->prod.mask = count - 1;
@@ -235,23 +232,6 @@ int _ring_destroy(const char *name)
return 0;
}
-/*
- * change the high water mark. If *count* is 0, water marking is
- * disabled
- */
-int _ring_set_water_mark(_ring_t *r, unsigned count)
-{
- if (count >= r->prod.size)
- return -EINVAL;
-
- /* if count is 0, disable the watermarking */
- if (count == 0)
- count = r->prod.size;
-
- r->prod.watermark = count;
- return 0;
-}
-
/**
* Enqueue several objects on the ring (multi-producers safe).
*/
@@ -264,7 +244,6 @@ int ___ring_mp_do_enqueue(_ring_t *r, void * const *obj_table,
int success;
unsigned i;
uint32_t mask = r->prod.mask;
- int ret;
/* move prod.head atomically */
do {
@@ -302,14 +281,6 @@ int ___ring_mp_do_enqueue(_ring_t *r, void * const *obj_table,
/* write entries in ring */
ENQUEUE_PTRS();
- /* if we exceed the watermark */
- if (odp_unlikely(((mask + 1) - free_entries + n) > r->prod.watermark)) {
- ret = (behavior == _RING_QUEUE_FIXED) ? -EDQUOT :
- (int)(n | _RING_QUOT_EXCEED);
- } else {
- ret = (behavior == _RING_QUEUE_FIXED) ? 0 : n;
- }
-
/*
* If there are other enqueues in progress that preceded us,
* we need to wait for them to complete
@@ -320,57 +291,7 @@ int ___ring_mp_do_enqueue(_ring_t *r, void * const *obj_table,
/* Release our entries and the memory they refer to */
__atomic_store_n(&r->prod.tail, prod_next, __ATOMIC_RELEASE);
- return ret;
-}
-
-/**
- * Enqueue several objects on a ring (NOT multi-producers safe).
- */
-int ___ring_sp_do_enqueue(_ring_t *r, void * const *obj_table,
- unsigned n, enum _ring_queue_behavior behavior)
-{
- uint32_t prod_head, cons_tail;
- uint32_t prod_next, free_entries;
- unsigned i;
- uint32_t mask = r->prod.mask;
- int ret;
-
- prod_head = r->prod.head;
- cons_tail = __atomic_load_n(&r->cons.tail, __ATOMIC_ACQUIRE);
- /* The subtraction is done between two unsigned 32bits value
- * (the result is always modulo 32 bits even if we have
- * prod_head > cons_tail). So 'free_entries' is always between 0
- * and size(ring)-1. */
- free_entries = mask + cons_tail - prod_head;
-
- /* check that we have enough room in ring */
- if (odp_unlikely(n > free_entries)) {
- if (behavior == _RING_QUEUE_FIXED)
- return -ENOBUFS;
- /* No free entry available */
- if (odp_unlikely(free_entries == 0))
- return 0;
-
- n = free_entries;
- }
-
- prod_next = prod_head + n;
- r->prod.head = prod_next;
-
- /* write entries in ring */
- ENQUEUE_PTRS();
-
- /* if we exceed the watermark */
- if (odp_unlikely(((mask + 1) - free_entries + n) > r->prod.watermark)) {
- ret = (behavior == _RING_QUEUE_FIXED) ? -EDQUOT :
- (int)(n | _RING_QUOT_EXCEED);
- } else {
- ret = (behavior == _RING_QUEUE_FIXED) ? 0 : n;
- }
-
- /* Release our entries and the memory they refer to */
- __atomic_store_n(&r->prod.tail, prod_next, __ATOMIC_RELEASE);
- return ret;
+ return (behavior == _RING_QUEUE_FIXED) ? 0 : n;
}
/**
@@ -436,45 +357,6 @@ int ___ring_mc_do_dequeue(_ring_t *r, void **obj_table,
return behavior == _RING_QUEUE_FIXED ? 0 : n;
}
-/**
- * Dequeue several objects from a ring (NOT multi-consumers safe).
- */
-int ___ring_sc_do_dequeue(_ring_t *r, void **obj_table,
- unsigned n, enum _ring_queue_behavior behavior)
-{
- uint32_t cons_head, prod_tail;
- uint32_t cons_next, entries;
- unsigned i;
- uint32_t mask = r->prod.mask;
-
- cons_head = r->cons.head;
- prod_tail = __atomic_load_n(&r->prod.tail, __ATOMIC_ACQUIRE);
- /* The subtraction is done between two unsigned 32bits value
- * (the result is always modulo 32 bits even if we have
- * cons_head > prod_tail). So 'entries' is always between 0
- * and size(ring)-1. */
- entries = prod_tail - cons_head;
-
- if (n > entries) {
- if (behavior == _RING_QUEUE_FIXED)
- return -ENOENT;
- if (odp_unlikely(entries == 0))
- return 0;
-
- n = entries;
- }
-
- cons_next = cons_head + n;
- r->cons.head = cons_next;
-
- /* Acquire the pointers and the memory they refer to */
- /* copy in table */
- DEQUEUE_PTRS();
-
- __atomic_store_n(&r->cons.tail, cons_next, __ATOMIC_RELEASE);
- return behavior == _RING_QUEUE_FIXED ? 0 : n;
-}
-
/**
* Enqueue several objects on the ring (multi-producers safe).
*/
@@ -485,16 +367,6 @@ int _ring_mp_enqueue_bulk(_ring_t *r, void * const *obj_table,
_RING_QUEUE_FIXED);
}
-/**
- * Enqueue several objects on a ring (NOT multi-producers safe).
- */
-int _ring_sp_enqueue_bulk(_ring_t *r, void * const *obj_table,
- unsigned n)
-{
- return ___ring_sp_do_enqueue(r, obj_table, n,
- _RING_QUEUE_FIXED);
-}
-
/**
* Dequeue several objects from a ring (multi-consumers safe).
*/
@@ -504,15 +376,6 @@ int _ring_mc_dequeue_bulk(_ring_t *r, void **obj_table, unsigned n)
_RING_QUEUE_FIXED);
}
-/**
- * Dequeue several objects from a ring (NOT multi-consumers safe).
- */
-int _ring_sc_dequeue_bulk(_ring_t *r, void **obj_table, unsigned n)
-{
- return ___ring_sc_do_dequeue(r, obj_table, n,
- _RING_QUEUE_FIXED);
-}
-
/**
* Test if a ring is full.
*/
@@ -569,10 +432,6 @@ void _ring_dump(const _ring_t *r)
ODP_DBG(" ph=%" PRIu32 "\n", r->prod.head);
ODP_DBG(" used=%u\n", _ring_count(r));
ODP_DBG(" avail=%u\n", _ring_free_count(r));
- if (r->prod.watermark == r->prod.size)
- ODP_DBG(" watermark=0\n");
- else
- ODP_DBG(" watermark=%" PRIu32 "\n", r->prod.watermark);
}
/* dump the status of all rings on the console */
@@ -614,28 +473,6 @@ int _ring_mp_enqueue_burst(_ring_t *r, void * const *obj_table,
_RING_QUEUE_VARIABLE);
}
-/**
- * Enqueue several objects on a ring (NOT multi-producers safe).
- */
-int _ring_sp_enqueue_burst(_ring_t *r, void * const *obj_table,
- unsigned n)
-{
- return ___ring_sp_do_enqueue(r, obj_table, n,
- _RING_QUEUE_VARIABLE);
-}
-
-/**
- * Enqueue several objects on a ring.
- */
-int _ring_enqueue_burst(_ring_t *r, void * const *obj_table,
- unsigned n)
-{
- if (r->prod.sp_enqueue)
- return _ring_sp_enqueue_burst(r, obj_table, n);
- else
- return _ring_mp_enqueue_burst(r, obj_table, n);
-}
-
/**
* Dequeue several objects from a ring (multi-consumers safe).
*/
@@ -644,23 +481,3 @@ int _ring_mc_dequeue_burst(_ring_t *r, void **obj_table, unsigned n)
return ___ring_mc_do_dequeue(r, obj_table, n,
_RING_QUEUE_VARIABLE);
}
-
-/**
- * Dequeue several objects from a ring (NOT multi-consumers safe).
- */
-int _ring_sc_dequeue_burst(_ring_t *r, void **obj_table, unsigned n)
-{
- return ___ring_sc_do_dequeue(r, obj_table, n,
- _RING_QUEUE_VARIABLE);
-}
-
-/**
- * Dequeue multiple objects from a ring up to a maximum number.
- */
-int _ring_dequeue_burst(_ring_t *r, void **obj_table, unsigned n)
-{
- if (r->cons.sc_dequeue)
- return _ring_sc_dequeue_burst(r, obj_table, n);
- else
- return _ring_mc_dequeue_burst(r, obj_table, n);
-}
diff --git a/platform/linux-generic/test/ring/ring_basic.c b/platform/linux-generic/test/ring/ring_basic.c
index 87fb18c3..6b17d8e5 100644
--- a/platform/linux-generic/test/ring/ring_basic.c
+++ b/platform/linux-generic/test/ring/ring_basic.c
@@ -26,20 +26,14 @@
/* labor functions declaration */
static void __do_basic_burst(_ring_t *r);
static void __do_basic_bulk(_ring_t *r);
-static void __do_basic_watermark(_ring_t *r);
/* dummy object pointers for enqueue and dequeue testing */
static void **test_enq_data;
static void **test_deq_data;
-/* create two rings: one for single thread usage scenario
- * and another for multiple thread usage scenario.
- * st - single thread usage scenario
- * mt - multiple thread usage scenario
- */
-static const char *st_ring_name = "ST basic ring";
+/* create multiple thread test ring */
static const char *mt_ring_name = "MT basic ring";
-static _ring_t *st_ring, *mt_ring;
+static _ring_t *mt_ring;
int ring_test_basic_start(void)
{
@@ -69,7 +63,6 @@ int ring_test_basic_start(void)
int ring_test_basic_end(void)
{
- _ring_destroy(st_ring_name);
_ring_destroy(mt_ring_name);
free(test_enq_data);
@@ -81,17 +74,10 @@ int ring_test_basic_end(void)
void ring_test_basic_create(void)
{
/* prove illegal size shall fail */
- st_ring = _ring_create(st_ring_name, ILLEGAL_SIZE, 0);
- CU_ASSERT(NULL == st_ring);
+ mt_ring = _ring_create(mt_ring_name, ILLEGAL_SIZE, 0);
+ CU_ASSERT(NULL == mt_ring);
CU_ASSERT(EINVAL == __odp_errno);
- /* create ring for single thread usage scenario */
- st_ring = _ring_create(st_ring_name, RING_SIZE,
- _RING_F_SP_ENQ | _RING_F_SC_DEQ);
-
- CU_ASSERT(NULL != st_ring);
- CU_ASSERT(_ring_lookup(st_ring_name) == st_ring);
-
/* create ring for multiple thread usage scenario */
mt_ring = _ring_create(mt_ring_name, RING_SIZE,
_RING_SHM_PROC);
@@ -102,25 +88,14 @@ void ring_test_basic_create(void)
void ring_test_basic_burst(void)
{
- /* two rounds to cover both single
- * thread and multiple thread APIs
- */
- __do_basic_burst(st_ring);
__do_basic_burst(mt_ring);
}
void ring_test_basic_bulk(void)
{
- __do_basic_bulk(st_ring);
__do_basic_bulk(mt_ring);
}
-void ring_test_basic_watermark(void)
-{
- __do_basic_watermark(st_ring);
- __do_basic_watermark(mt_ring);
-}
-
/* labor functions definition */
static void __do_basic_burst(_ring_t *r)
{
@@ -136,17 +111,17 @@ static void __do_basic_burst(_ring_t *r)
CU_ASSERT(1 == _ring_empty(r));
/* enqueue 1 object */
- result = _ring_enqueue_burst(r, enq, 1);
+ result = _ring_mp_enqueue_burst(r, enq, 1);
enq += 1;
CU_ASSERT(1 == (result & _RING_SZ_MASK));
/* enqueue 2 objects */
- result = _ring_enqueue_burst(r, enq, 2);
+ result = _ring_mp_enqueue_burst(r, enq, 2);
enq += 2;
CU_ASSERT(2 == (result & _RING_SZ_MASK));
/* enqueue HALF_BULK objects */
- result = _ring_enqueue_burst(r, enq, HALF_BULK);
+ result = _ring_mp_enqueue_burst(r, enq, HALF_BULK);
enq += HALF_BULK;
CU_ASSERT(HALF_BULK == (result & _RING_SZ_MASK));
@@ -162,23 +137,23 @@ static void __do_basic_burst(_ring_t *r)
CU_ASSERT(count == _ring_free_count(r));
/* exceed the size, enquene as many as possible */
- result = _ring_enqueue_burst(r, enq, HALF_BULK);
+ result = _ring_mp_enqueue_burst(r, enq, HALF_BULK);
enq += count;
CU_ASSERT(count == (result & _RING_SZ_MASK));
CU_ASSERT(1 == _ring_full(r));
/* dequeue 1 object */
- result = _ring_dequeue_burst(r, deq, 1);
+ result = _ring_mc_dequeue_burst(r, deq, 1);
deq += 1;
CU_ASSERT(1 == (result & _RING_SZ_MASK));
/* dequeue 2 objects */
- result = _ring_dequeue_burst(r, deq, 2);
+ result = _ring_mc_dequeue_burst(r, deq, 2);
deq += 2;
CU_ASSERT(2 == (result & _RING_SZ_MASK));
/* dequeue HALF_BULK objects */
- result = _ring_dequeue_burst(r, deq, HALF_BULK);
+ result = _ring_mc_dequeue_burst(r, deq, HALF_BULK);
deq += HALF_BULK;
CU_ASSERT(HALF_BULK == (result & _RING_SZ_MASK));
@@ -190,7 +165,7 @@ static void __do_basic_burst(_ring_t *r)
CU_ASSERT(count == _ring_count(r));
/* underrun the size, dequeue as many as possible */
- result = _ring_dequeue_burst(r, deq, HALF_BULK);
+ result = _ring_mc_dequeue_burst(r, deq, HALF_BULK);
deq += count;
CU_ASSERT(count == (result & _RING_SZ_MASK));
CU_ASSERT(1 == _ring_empty(r));
@@ -208,19 +183,13 @@ static void __do_basic_burst(_ring_t *r)
static inline int __ring_enqueue_bulk(
_ring_t *r, void * const *objects, unsigned bulk)
{
- if (r->prod.sp_enqueue)
- return _ring_sp_enqueue_bulk(r, objects, bulk);
- else
- return _ring_mp_enqueue_bulk(r, objects, bulk);
+ return _ring_mp_enqueue_bulk(r, objects, bulk);
}
static inline int __ring_dequeue_bulk(
_ring_t *r, void **objects, unsigned bulk)
{
- if (r->cons.sc_dequeue)
- return _ring_sc_dequeue_bulk(r, objects, bulk);
- else
- return _ring_mc_dequeue_bulk(r, objects, bulk);
+ return _ring_mc_dequeue_bulk(r, objects, bulk);
}
static void __do_basic_bulk(_ring_t *r)
@@ -310,55 +279,3 @@ static void __do_basic_bulk(_ring_t *r)
/* reset dequeue data */
memset(test_deq_data, 0, RING_SIZE * 2 * sizeof(void *));
}
-
-void __do_basic_watermark(_ring_t *r)
-{
- int result = 0;
- void * const *source = test_enq_data;
- void * const *dest = test_deq_data;
- void **enq = NULL, **deq = NULL;
-
- enq = test_enq_data; deq = test_deq_data;
-
- /* bulk = 3/4 watermark to trigger alarm on 2nd enqueue */
- const unsigned watermark = PIECE_BULK;
- const unsigned bulk = (watermark / 4) * 3;
-
- /* watermark cannot exceed ring size */
- result = _ring_set_water_mark(r, ILLEGAL_SIZE);
- CU_ASSERT(-EINVAL == result);
-
- /* set watermark */
- result = _ring_set_water_mark(r, watermark);
- CU_ASSERT(0 == result);
-
- /* 1st enqueue shall succeed */
- result = __ring_enqueue_bulk(r, enq, bulk);
- enq += bulk;
- CU_ASSERT(0 == result);
-
- /* 2nd enqueue shall succeed but return -EDQUOT */
- result = __ring_enqueue_bulk(r, enq, bulk);
- enq += bulk;
- CU_ASSERT(-EDQUOT == result);
-
- /* dequeue 1st bulk */
- result = __ring_dequeue_bulk(r, deq, bulk);
- deq += bulk;
- CU_ASSERT(0 == result);
-
- /* dequeue 2nd bulk */
- result = __ring_dequeue_bulk(r, deq, bulk);
- deq += bulk;
- CU_ASSERT(0 == result);
-
- /* check data */
- CU_ASSERT(0 == memcmp(source, dest, deq - dest));
-
- /* reset watermark */
- result = _ring_set_water_mark(r, 0);
- CU_ASSERT(0 == result);
-
- /* reset dequeue data */
- memset(test_deq_data, 0, RING_SIZE * 2 * sizeof(void *));
-}
diff --git a/platform/linux-generic/test/ring/ring_suites.c b/platform/linux-generic/test/ring/ring_suites.c
index baecba6e..5f195777 100644
--- a/platform/linux-generic/test/ring/ring_suites.c
+++ b/platform/linux-generic/test/ring/ring_suites.c
@@ -36,7 +36,6 @@ static odp_testinfo_t ring_suite_basic[] = {
ODP_TEST_INFO(ring_test_basic_create),
ODP_TEST_INFO(ring_test_basic_burst),
ODP_TEST_INFO(ring_test_basic_bulk),
- ODP_TEST_INFO(ring_test_basic_watermark),
ODP_TEST_INFO_NULL,
};
diff --git a/platform/linux-generic/test/ring/ring_suites.h b/platform/linux-generic/test/ring/ring_suites.h
index 1735f2d7..d56ab784 100644
--- a/platform/linux-generic/test/ring/ring_suites.h
+++ b/platform/linux-generic/test/ring/ring_suites.h
@@ -18,7 +18,6 @@ int ring_test_basic_end(void);
void ring_test_basic_create(void);
void ring_test_basic_burst(void);
void ring_test_basic_bulk(void);
-void ring_test_basic_watermark(void);
/* test suite start and stop */
int ring_test_stress_start(void);
-----------------------------------------------------------------------
Summary of changes:
.../include/odp_packet_io_ring_internal.h | 184 +-------------------
platform/linux-generic/pktio/ring.c | 189 +--------------------
platform/linux-generic/test/ring/ring_basic.c | 111 ++----------
platform/linux-generic/test/ring/ring_suites.c | 1 -
platform/linux-generic/test/ring/ring_suites.h | 1 -
5 files changed, 19 insertions(+), 467 deletions(-)
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch master updated. v1.19.0.2_tigermoth-11-gf7c03ade
by git＠git-us.linaro.org
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 f7c03ade975b018be0766d5fea300d03642b4b12 (commit)
from 60cc4b660bea6af9b37a14fbf1ad07589b15b34e (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 f7c03ade975b018be0766d5fea300d03642b4b12
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Wed Jun 13 16:53:56 2018 +0300
test: performance: add new CPU benchmarking application
New self-contained test application for CPUs stress testing.
The application launches a number of worker threads, which receive
preallocated test UDP packets from the scheduler and perform the following
per packet processing:
1. Calculate a CRC-32C hash over the packet data and check that it matches
to the value stored in test header
2. Perform full packet parsing
3. Read a value from dummy lookup table based on packet data
4. Modify packet payload based on the lookup table data and sequence number
5. Update UDP checksum
6. Recalculate CRC-32C hash and store it in test header
Dummy lookup table (default 1M entries) is used to increase memory usage.
The size of the lookup table can be modified with '-l' option.
The application measures and prints the maximum throughput per each worker
thread.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-by: Bogdan Pricope <bogdan.pricope(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/test/performance/.gitignore b/test/performance/.gitignore
index 499c4d33..ca0e884f 100644
--- a/test/performance/.gitignore
+++ b/test/performance/.gitignore
@@ -2,6 +2,7 @@
*.trs
odp_atomic
odp_bench_packet
+odp_cpu_bench
odp_crypto
odp_ipsec
odp_l2fwd
diff --git a/test/performance/Makefile.am b/test/performance/Makefile.am
index a110c23a..887a013e 100644
--- a/test/performance/Makefile.am
+++ b/test/performance/Makefile.am
@@ -3,6 +3,7 @@ include $(top_srcdir)/test/Makefile.inc
TESTS_ENVIRONMENT += TEST_DIR=${builddir}
EXECUTABLES = odp_bench_packet \
+ odp_cpu_bench \
odp_crypto \
odp_ipsec \
odp_pktio_perf \
@@ -34,6 +35,7 @@ endif
bin_PROGRAMS = $(EXECUTABLES) $(COMPILE_ONLY)
odp_bench_packet_SOURCES = odp_bench_packet.c
+odp_cpu_bench_SOURCES = odp_cpu_bench.c
odp_crypto_SOURCES = odp_crypto.c
odp_ipsec_SOURCES = odp_ipsec.c
odp_pktio_ordered_SOURCES = odp_pktio_ordered.c dummy_crc.h
diff --git a/test/performance/odp_cpu_bench.c b/test/performance/odp_cpu_bench.c
new file mode 100644
index 00000000..949825e9
--- /dev/null
+++ b/test/performance/odp_cpu_bench.c
@@ -0,0 +1,813 @@
+/* Copyright (c) 2018, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "config.h"
+
+#include <odp_api.h>
+#include <odp/helper/odph_api.h>
+
+#include <test_debug.h>
+
+#include <getopt.h>
+#include <inttypes.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/* Queues are divided into groups and tests packets are passed only between
+ * queues which belong to the same group. */
+#define MAX_GROUPS 64
+#define QUEUES_PER_GROUP 4
+#define PKTS_PER_QUEUE 256
+
+#define MAX_EVENT_BURST 32
+#define CRC_INIT_VAL 123456789
+#define PASS_PACKETS 10000
+
+/* Default number of entries in the test lookup table */
+#define DEF_LOOKUP_TBL_SIZE (1024 * 1024)
+
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
+ODP_STATIC_ASSERT(MAX_WORKERS <= MAX_GROUPS * QUEUES_PER_GROUP,
+ "Not enough queues for all workers");
+
+/* Get rid of path in filename - only for unix-type paths using '/' */
+#define NO_PATH(file_name) (strrchr((file_name), '/') ? \
+ strrchr((file_name), '/') + 1 : (file_name))
+
+/* Test dummy lookup table entry */
+typedef struct {
+ uint64_t idx;
+ uint32_t val0;
+ uint32_t val1;
+} lookup_entry_t;
+
+/* Test packet */
+typedef struct {
+ uint32_t seq;
+ uint32_t crc;
+ uint16_t group;
+} test_hdr_t;
+
+/* Parsed application arguments */
+typedef struct {
+ uint64_t lookup_tbl_size; /* Lookup table size */
+ int accuracy; /* Number of seconds between stats prints */
+ unsigned int cpu_count; /* CPU count */
+ int time; /* Time in seconds to run */
+} appl_args_t;
+
+/* Statistics */
+typedef union ODP_ALIGNED_CACHE {
+ struct {
+ /* Number of processed packets */
+ uint64_t pkts;
+ /* Number of dropped packets */
+ uint64_t dropped_pkts;
+ /* Time spent processing packets */
+ uint64_t nsec;
+ /* Cycles spent processing packets */
+ uint64_t cycles;
+ } s;
+
+ uint8_t padding[ODP_CACHE_LINE_SIZE];
+} stats_t;
+
+/* Thread specific data */
+typedef struct thread_args_t {
+ stats_t stats;
+ uint16_t idx;
+} thread_args_t;
+
+/* Grouping of all global data */
+typedef struct {
+ /* Thread specific arguments */
+ thread_args_t thread[MAX_WORKERS];
+ /* Barriers to synchronize main and workers */
+ odp_barrier_t init_barrier;
+ odp_barrier_t term_barrier;
+ /* Application (parsed) arguments */
+ appl_args_t appl;
+ /* Test queues */
+ odp_queue_t queue[MAX_GROUPS][QUEUES_PER_GROUP];
+ /* Test lookup table */
+ lookup_entry_t *lookup_tbl;
+} args_t;
+
+/* Global pointer to args */
+static args_t *gbl_args;
+
+static volatile int exit_threads; /* Break workers loop if set to 1 */
+
+static const uint8_t test_udp_packet[] = {
+ 0x00, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x00, 0x01,
+ 0x02, 0x03, 0x04, 0x05, 0x08, 0x00, 0x45, 0x00,
+ 0x02, 0x1C, 0x00, 0x01, 0x00, 0x00, 0x40, 0x11,
+ 0xF7, 0x7C, 0xC0, 0xA8, 0x00, 0x01, 0xC0, 0xA8,
+ 0x00, 0x02, 0x04, 0xD2, 0x1A, 0x82, 0x02, 0x08,
+ 0x24, 0x1E, 0xC9, 0x56, 0xB4, 0xD6, 0x4B, 0x64,
+ 0xB3, 0x01, 0xA1, 0x97, 0x4D, 0xD1, 0xA4, 0x76,
+ 0xF5, 0x7B, 0x27, 0x22, 0x6C, 0xA9, 0xED, 0x29,
+ 0x6E, 0x02, 0x80, 0xF7, 0xC4, 0x2D, 0x2A, 0x96,
+ 0x2D, 0xF6, 0x02, 0x8E, 0x89, 0x9F, 0x8C, 0xF4,
+ 0x0D, 0xC5, 0xE5, 0x1F, 0xA1, 0x52, 0xC3, 0x4B,
+ 0x5C, 0x4C, 0xDF, 0x14, 0x05, 0x6A, 0xA8, 0xD7,
+ 0xAD, 0x4F, 0x22, 0xA6, 0xB8, 0xF9, 0x52, 0x5A,
+ 0xB8, 0xF9, 0xE2, 0x2C, 0x05, 0x2A, 0x6F, 0xF2,
+ 0xCA, 0xA1, 0xA7, 0xC3, 0x56, 0xE1, 0xDB, 0xC1,
+ 0xDB, 0x86, 0x26, 0x55, 0xAC, 0xBE, 0xE1, 0x3D,
+ 0x82, 0x86, 0xB9, 0xDE, 0x3E, 0xD3, 0x11, 0xAB,
+ 0x65, 0x6A, 0xED, 0x1B, 0x60, 0xBE, 0x69, 0x71,
+ 0xB2, 0xA8, 0x5B, 0xB1, 0x06, 0xE3, 0x48, 0x14,
+ 0xC9, 0x13, 0x73, 0xDA, 0xBE, 0xE4, 0x7A, 0x5F,
+ 0xC0, 0xE0, 0xCA, 0xF3, 0x7A, 0xCA, 0x3F, 0xC9,
+ 0x4A, 0xEE, 0x47, 0x76, 0x67, 0xF0, 0x0D, 0x3F,
+ 0x7F, 0x3D, 0x69, 0xEA, 0x39, 0x53, 0x7C, 0xE3,
+ 0xED, 0x78, 0x79, 0x47, 0x60, 0x95, 0xCB, 0xDC,
+ 0x26, 0x60, 0x46, 0xAC, 0x47, 0xDA, 0x4C, 0x4D,
+ 0x0F, 0xE1, 0x68, 0x43, 0xBC, 0xCD, 0x4E, 0xFE,
+ 0x2E, 0xD6, 0xC2, 0x6E, 0x63, 0xEA, 0xB3, 0x98,
+ 0xCA, 0x8F, 0x7F, 0x05, 0xDF, 0x72, 0x8F, 0x6E,
+ 0x3E, 0x6D, 0xC7, 0x94, 0x59, 0x9D, 0x15, 0x5B,
+ 0xB8, 0x02, 0x52, 0x4F, 0x68, 0x3A, 0xF1, 0xFF,
+ 0xA9, 0xA4, 0x30, 0x29, 0xE0, 0x1C, 0xA0, 0x1B,
+ 0x50, 0xAB, 0xFD, 0x06, 0x84, 0xD4, 0x33, 0x51,
+ 0x01, 0xB3, 0x5F, 0x49, 0x5F, 0x21, 0xA0, 0xA1,
+ 0xC9, 0x08, 0xB3, 0xDF, 0x72, 0x9B, 0x5B, 0x70,
+ 0x89, 0x96, 0x08, 0x25, 0x88, 0x1E, 0xED, 0x52,
+ 0xDC, 0x98, 0xA0, 0xB8, 0x83, 0x2A, 0xA0, 0x90,
+ 0x45, 0xC9, 0x77, 0xD2, 0x19, 0xD7, 0x6B, 0xAB,
+ 0x49, 0x67, 0x7C, 0xD1, 0xE0, 0x23, 0xA2, 0x36,
+ 0xB2, 0x91, 0x3B, 0x23, 0x3B, 0x03, 0x36, 0xAF,
+ 0xAD, 0x81, 0xFA, 0x6F, 0x68, 0xD5, 0xBE, 0x73,
+ 0x1D, 0x56, 0x8A, 0xE8, 0x1A, 0xB4, 0xA8, 0x7C,
+ 0xF3, 0x82, 0x10, 0xD0, 0xF2, 0x1D, 0x9C, 0xEA,
+ 0xAB, 0xE7, 0xEC, 0x53, 0x6D, 0x52, 0xBD, 0x29,
+ 0x86, 0x21, 0xCE, 0xAA, 0xF3, 0x68, 0xA6, 0xEC,
+ 0x7E, 0xCA, 0x6F, 0xEB, 0xE1, 0x81, 0x80, 0x7C,
+ 0xF3, 0xE5, 0x22, 0xA0, 0x91, 0x08, 0xB7, 0x35,
+ 0x15, 0x87, 0x0C, 0x77, 0x31, 0x9C, 0x2F, 0x73,
+ 0xCE, 0x29, 0x6F, 0xC6, 0xAC, 0x9F, 0x68, 0xB8,
+ 0x6A, 0xFC, 0xD3, 0xB5, 0x08, 0x98, 0xAE, 0xE4,
+ 0x20, 0x84, 0x24, 0x69, 0xA5, 0xF5, 0x4A, 0x9D,
+ 0x44, 0x26, 0x5A, 0xF9, 0x6B, 0x5E, 0x5D, 0xC8,
+ 0x6F, 0xD4, 0x62, 0x91, 0xE5, 0x8E, 0x80, 0x05,
+ 0xA1, 0x95, 0x09, 0xEA, 0xFE, 0x84, 0x6D, 0xC3,
+ 0x0D, 0xD4, 0x32, 0xA4, 0x38, 0xB2, 0xF7, 0x9D,
+ 0x58, 0xD3, 0x5D, 0x93, 0x5F, 0x67, 0x86, 0xE1,
+ 0xAF, 0xFF, 0xE9, 0xFE, 0xF4, 0x71, 0x63, 0xE3,
+ 0x3E, 0xE1, 0x7A, 0x80, 0x5A, 0x23, 0x4F, 0x5B,
+ 0x54, 0x21, 0x0E, 0xE2, 0xAF, 0x01, 0x2E, 0xA4,
+ 0xF5, 0x1F, 0x59, 0x96, 0x3E, 0x82, 0xF3, 0x44,
+ 0xDF, 0xA6, 0x7C, 0x64, 0x5D, 0xC7, 0x79, 0xA1,
+ 0x17, 0xE1, 0x06, 0x14, 0x3E, 0x1B, 0x46, 0xCA,
+ 0x71, 0xC8, 0x05, 0x62, 0xD0, 0x56, 0x23, 0x9B,
+ 0xBA, 0xFE, 0x6D, 0xA8, 0x03, 0x4C, 0x23, 0xD8,
+ 0x98, 0x8A, 0xE8, 0x9C, 0x93, 0x8E, 0xB7, 0x24,
+ 0x31, 0x2A, 0x81, 0x72, 0x8F, 0x13, 0xD4, 0x7E,
+ 0xEB, 0xB1, 0xEE, 0x33, 0xD9, 0xF4, 0x96, 0x5E,
+ 0x6C, 0x3D, 0x45, 0x9C, 0xE0, 0x71, 0xA3, 0xFA,
+ 0x17, 0x2B, 0xC3, 0x07, 0xD6, 0x86, 0xA2, 0x06,
+ 0xC5, 0x33, 0xF0, 0xEA, 0x25, 0x70, 0x68, 0x56,
+ 0xD5, 0xB0
+};
+
+static void sig_handler(int signo ODP_UNUSED)
+{
+ exit_threads = 1;
+}
+
+static inline void init_packet(odp_packet_t pkt, uint32_t seq, uint16_t group)
+{
+ uint32_t *payload;
+ test_hdr_t *hdr;
+ odp_packet_parse_param_t param;
+
+ param.proto = ODP_PROTO_ETH;
+ param.last_layer = ODP_PROTO_LAYER_ALL;
+ param.chksums.all_chksum = 0;
+ if (odp_packet_parse(pkt, 0, ¶m))
+ LOG_ABORT("odp_packet_parse() failed\n");
+
+ /* Modify UDP payload and update checksum */
+ payload = odp_packet_offset(pkt, odp_packet_l4_offset(pkt) +
+ ODPH_UDPHDR_LEN, NULL, NULL);
+ *payload = seq;
+ if (odph_udp_chksum_set(pkt))
+ LOG_ABORT("odph_udp_chksum_set() failed\n");
+
+ /* Test header is stored in user area */
+ hdr = odp_packet_user_area(pkt);
+ hdr->seq = seq;
+ hdr->group = group;
+ hdr->crc = odp_hash_crc32c(odp_packet_data(pkt), odp_packet_len(pkt),
+ CRC_INIT_VAL);
+}
+
+static inline odp_queue_t work_on_event(odp_event_t event)
+{
+ odp_packet_t pkt;
+ odp_packet_parse_param_t param;
+ odph_udphdr_t *udp_hdr;
+ test_hdr_t *hdr;
+ lookup_entry_t *lookup_entry;
+ uint32_t *payload;
+ uint32_t crc;
+ uint32_t pkt_len;
+ uint8_t *data;
+ uint32_t new_val;
+ uint32_t old_val;
+
+ if (odp_event_type(event) != ODP_EVENT_PACKET)
+ return ODP_QUEUE_INVALID;
+
+ pkt = odp_packet_from_event(event);
+ hdr = odp_packet_user_area(pkt);
+ pkt_len = odp_packet_len(pkt);
+ data = odp_packet_data(pkt);
+
+ crc = odp_hash_crc32c(data, pkt_len, CRC_INIT_VAL);
+ if (crc != hdr->crc)
+ LOG_ERR("Error: Invalid packet crc\n");
+
+ param.proto = ODP_PROTO_ETH;
+ param.last_layer = ODP_PROTO_LAYER_ALL;
+ param.chksums.all_chksum = 1;
+ if (odp_packet_parse(pkt, 0, ¶m)) {
+ LOG_ERR("Error: odp_packet_parse() failed\n");
+ return ODP_QUEUE_INVALID;
+ }
+
+ /* Modify packet data using lookup table value and sequence number, and
+ * update UDP checksum accordingly. */
+ lookup_entry = &gbl_args->lookup_tbl[(crc + hdr->seq) %
+ gbl_args->appl.lookup_tbl_size];
+ udp_hdr = odp_packet_l4_ptr(pkt, NULL);
+ payload = odp_packet_offset(pkt, odp_packet_l4_offset(pkt) +
+ ODPH_UDPHDR_LEN, NULL, NULL);
+ old_val = *payload;
+ *payload += lookup_entry->idx % 2 ? lookup_entry->val1 :
+ lookup_entry->val0;
+ new_val = *payload;
+ udp_hdr->chksum = ~(~udp_hdr->chksum + (-old_val) + new_val);
+
+ payload++;
+ old_val = *payload;
+ *payload += hdr->seq;
+ new_val = *payload;
+ udp_hdr->chksum = ~(~udp_hdr->chksum + (-old_val) + new_val);
+
+ hdr->crc = odp_hash_crc32c(data, pkt_len, CRC_INIT_VAL);
+
+ return gbl_args->queue[hdr->group][hdr->seq++ % QUEUES_PER_GROUP];
+}
+
+/**
+ * Worker thread
+ */
+static int run_thread(void *arg)
+{
+ thread_args_t *thr_args = arg;
+ stats_t *stats = &thr_args->stats;
+ odp_time_t t1, t2;
+ uint64_t c1, c2;
+
+ odp_barrier_wait(&gbl_args->init_barrier);
+
+ c1 = odp_cpu_cycles();
+ t1 = odp_time_local();
+
+ while (!exit_threads) {
+ odp_event_t event_tbl[MAX_EVENT_BURST];
+ odp_queue_t dst_queue;
+ int num_events;
+ int i;
+
+ num_events = odp_schedule_multi(NULL, ODP_SCHED_NO_WAIT,
+ event_tbl, MAX_EVENT_BURST);
+ if (num_events <= 0)
+ continue;
+
+ for (i = 0; i < num_events; i++) {
+ odp_event_t event = event_tbl[i];
+
+ dst_queue = work_on_event(event);
+ if (odp_unlikely(dst_queue == ODP_QUEUE_INVALID)) {
+ stats->s.dropped_pkts++;
+ odp_event_free(event);
+ continue;
+ }
+
+ if (odp_unlikely(odp_queue_enq(dst_queue, event))) {
+ LOG_ERR("Error: odp_queue_enq() failed\n");
+ stats->s.dropped_pkts++;
+ odp_event_free(event);
+ break;
+ }
+
+ stats->s.pkts++;
+ }
+ }
+
+ c2 = odp_cpu_cycles();
+ t2 = odp_time_local();
+
+ stats->s.cycles = c2 - c1;
+ stats->s.nsec = odp_time_diff_ns(t2, t1);
+
+ odp_barrier_wait(&gbl_args->term_barrier);
+
+ /* Free remaining events in queues */
+ while (1) {
+ odp_event_t ev;
+
+ ev = odp_schedule(NULL,
+ odp_schedule_wait_time(ODP_TIME_SEC_IN_NS));
+
+ if (ev == ODP_EVENT_INVALID)
+ break;
+
+ odp_event_free(ev);
+ }
+
+ return 0;
+}
+
+/*
+ * Prinf usage information
+ */
+static void usage(char *progname)
+{
+ printf("\n"
+ "OpenDataPlane CPU benchmarking application.\n"
+ "\n"
+ "Usage: %s [options]\n"
+ "\n"
+ " E.g. %s -c 4 -t 30\n"
+ "Options:\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
+ " -t, --time <sec> Time in seconds to run\n"
+ " (default is 10 second).\n"
+ " -a, --accuracy <sec> Time in seconds get print statistics\n"
+ " (default is 1 second).\n"
+ " -l, --lookup_tbl <num> Number of entries in dummy lookup table\n"
+ " (default is %d).\n"
+ " -h, --help Display help and exit.\n\n"
+ "\n", NO_PATH(progname), NO_PATH(progname), DEF_LOOKUP_TBL_SIZE);
+}
+
+/**
+ * @internal Parse arguments
+ *
+ * @param argc Argument count
+ * @param argv Argument vector
+ * @param args Test arguments
+ */
+static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
+{
+ int opt;
+ int long_index;
+
+ static const struct option longopts[] = {
+ {"accuracy", required_argument, NULL, 'a'},
+ {"cpu", required_argument, NULL, 'c'},
+ {"lookup_tbl", required_argument, NULL, 'l'},
+ {"time", required_argument, NULL, 't'},
+ {"help", no_argument, NULL, 'h'},
+ {NULL, 0, NULL, 0}
+ };
+
+ static const char *shortopts = "+a:+c:+l:+t:h";
+
+ /* Let helper collect its own arguments (e.g. --odph_proc) */
+ argc = odph_parse_options(argc, argv);
+
+ appl_args->accuracy = 1; /* Get and print pps stats second */
+ appl_args->cpu_count = 1;
+ appl_args->lookup_tbl_size = DEF_LOOKUP_TBL_SIZE;
+ appl_args->time = 10; /* Loop forever if time to run is 0 */
+
+ while (1) {
+ opt = getopt_long(argc, argv, shortopts, longopts, &long_index);
+
+ if (opt == -1)
+ break; /* No more options */
+
+ switch (opt) {
+ case 'a':
+ appl_args->accuracy = atoi(optarg);
+ break;
+ case 'c':
+ appl_args->cpu_count = atoi(optarg);
+ break;
+ case 'l':
+ appl_args->lookup_tbl_size = atoi(optarg);
+ break;
+ case 't':
+ appl_args->time = atoi(optarg);
+ break;
+ case 'h':
+ usage(argv[0]);
+ exit(EXIT_SUCCESS);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ if (appl_args->lookup_tbl_size < 1) {
+ printf("At least one lookup table entry required.\n");
+ exit(EXIT_FAILURE);
+ }
+}
+
+/*
+ * Print statistics
+ *
+ * num_workers Number of worker threads
+ * thr_stats Pointers to stats storage
+ * duration Number of seconds to loop
+ */
+static int print_stats(int num_workers, stats_t **thr_stats, int duration,
+ int accuracy)
+{
+ uint64_t pkts;
+ uint64_t dropped;
+ uint64_t pkts_prev = 0;
+ uint64_t nsec = 0;
+ uint64_t cycles = 0;
+ int i;
+ int elapsed = 0;
+ int stats_enabled = 1;
+ int loop_forever = (duration == 0);
+
+ if (accuracy <= 0) {
+ stats_enabled = 0;
+ accuracy = 1;
+ }
+ /* Wait for all threads to be ready*/
+ odp_barrier_wait(&gbl_args->init_barrier);
+
+ do {
+ uint64_t pps;
+
+ sleep(accuracy);
+
+ pkts = 0;
+ dropped = 0;
+ for (i = 0; i < num_workers; i++) {
+ pkts += thr_stats[i]->s.pkts;
+ dropped += thr_stats[i]->s.dropped_pkts;
+ }
+
+ pps = (pkts - pkts_prev) / accuracy;
+
+ if (stats_enabled) {
+ printf("%.2f Mpps, ", pps / 1000000.0);
+
+ printf("%" PRIu64 " dropped\n", dropped);
+ }
+
+ pkts_prev = pkts;
+ elapsed += accuracy;
+ } while (!exit_threads && (loop_forever || (elapsed < duration)));
+
+ exit_threads = 1;
+ odp_barrier_wait(&gbl_args->term_barrier);
+
+ pkts = 0;
+ dropped = 0;
+ for (i = 0; i < num_workers; i++) {
+ pkts += thr_stats[i]->s.pkts;
+ dropped += thr_stats[i]->s.dropped_pkts;
+ nsec += thr_stats[i]->s.nsec;
+ cycles += thr_stats[i]->s.cycles;
+ }
+
+ printf("\nRESULTS - per thread (Million packets per sec):\n");
+ printf("-----------------------------------------------\n");
+ printf(" avg 1 2 3 4 5 6 7 8 9 10\n");
+ printf("%6.2f ", pkts / (nsec / 1000.0));
+
+ for (i = 0; i < num_workers; i++) {
+ if (i != 0 && (i % 10) == 0)
+ printf("\n ");
+
+ printf("%6.2f ", thr_stats[i]->s.pkts /
+ (thr_stats[i]->s.nsec / 1000.0));
+ }
+ printf("\n\n");
+
+ nsec /= num_workers;
+ printf("RESULTS - total over %i threads:\n", num_workers);
+ printf("----------------------------------\n");
+ printf(" avg packets per sec: %.3f M\n", pkts / (nsec / 1000.0));
+ printf(" avg cycles per packet: %" PRIu64 "\n", cycles / pkts);
+ printf(" dropped packets: %" PRIu64 "\n\n", dropped);
+
+ return pkts > PASS_PACKETS ? 0 : -1;
+}
+
+static void gbl_args_init(args_t *args)
+{
+ memset(args, 0, sizeof(args_t));
+}
+
+/**
+ * Test main function
+ */
+int main(int argc, char *argv[])
+{
+ stats_t *stats[MAX_WORKERS];
+ odph_odpthread_t thread_tbl[MAX_WORKERS];
+ odp_cpumask_t cpumask;
+ odp_pool_capability_t pool_capa;
+ odp_pool_t pool;
+ odp_queue_capability_t queue_capa;
+ odp_shm_t shm;
+ odp_shm_t lookup_tbl_shm;
+ odp_pool_param_t params;
+ odp_instance_t instance;
+ odp_init_t init;
+ char cpumaskstr[ODP_CPUMASK_STR_SIZE];
+ uint32_t num_pkts;
+ uint32_t num_groups;
+ uint32_t num_queues;
+ uint32_t pkts_per_group;
+ uint32_t pkt_len;
+ uint32_t init_val;
+ unsigned int num_workers;
+ unsigned int i, j;
+ int cpu;
+ int ret = 0;
+
+ odp_init_param_init(&init);
+
+ /* List features not to be used (may optimize performance) */
+ init.not_used.feat.cls = 1;
+ init.not_used.feat.crypto = 1;
+ init.not_used.feat.ipsec = 1;
+ init.not_used.feat.timer = 1;
+ init.not_used.feat.tm = 1;
+
+ /* Signal handler has to be registered before global init in case ODP
+ * implementation creates internal threads/processes. */
+ signal(SIGINT, sig_handler);
+
+ if (odp_init_global(&instance, &init, NULL)) {
+ LOG_ERR("Error: ODP global init failed\n");
+ return -1;
+ }
+
+ if (odp_init_local(instance, ODP_THREAD_CONTROL)) {
+ LOG_ERR("Error: ODP local init failed\n");
+ exit(EXIT_FAILURE);
+ }
+
+ shm = odp_shm_reserve("shm_args", sizeof(args_t), ODP_CACHE_LINE_SIZE,
+ 0);
+ gbl_args = odp_shm_addr(shm);
+ if (gbl_args == NULL) {
+ LOG_ERR("Error: shared mem alloc failed\n");
+ exit(EXIT_FAILURE);
+ }
+ gbl_args_init(gbl_args);
+
+ /* Parse and store the application arguments */
+ parse_args(argc, argv, &gbl_args->appl);
+
+ lookup_tbl_shm = odp_shm_reserve("lookup_tbl_shm",
+ sizeof(lookup_entry_t) *
+ gbl_args->appl.lookup_tbl_size,
+ ODP_CACHE_LINE_SIZE, 0);
+ gbl_args->lookup_tbl = odp_shm_addr(lookup_tbl_shm);
+ if (gbl_args->lookup_tbl == NULL) {
+ LOG_ERR("Error: lookup table mem alloc failed\n");
+ exit(EXIT_FAILURE);
+ }
+
+ printf("\n");
+ odp_sys_info_print();
+
+ /* Default to system CPU count unless user specified */
+ num_workers = MAX_WORKERS;
+ if (gbl_args->appl.cpu_count && gbl_args->appl.cpu_count < MAX_WORKERS)
+ num_workers = gbl_args->appl.cpu_count;
+
+ /* Get default worker cpumask */
+ num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
+ (void)odp_cpumask_to_str(&cpumask, cpumaskstr, sizeof(cpumaskstr));
+
+ printf("num worker threads: %i\n", num_workers);
+ printf("first CPU: %i\n", odp_cpumask_first(&cpumask));
+ printf("cpu mask: %s\n", cpumaskstr);
+
+ /* Create application queues */
+ if (odp_queue_capability(&queue_capa)) {
+ LOG_ERR("Error: odp_queue_capability() failed\n");
+ exit(EXIT_FAILURE);
+ }
+
+ /* Make sure a single queue can store all the packets in a group */
+ pkts_per_group = QUEUES_PER_GROUP * PKTS_PER_QUEUE;
+ if (queue_capa.sched.max_size &&
+ queue_capa.sched.max_size < pkts_per_group)
+ pkts_per_group = queue_capa.sched.max_size;
+
+ /* Divide queues evenly into groups */
+ if (queue_capa.sched.max_num < QUEUES_PER_GROUP) {
+ LOG_ERR("Error: min %d queues required\n", QUEUES_PER_GROUP);
+ return -1;
+ }
+ num_queues = num_workers > queue_capa.sched.max_num ?
+ queue_capa.sched.max_num : num_workers;
+ num_groups = (num_queues + QUEUES_PER_GROUP - 1) / QUEUES_PER_GROUP;
+ if (num_groups * QUEUES_PER_GROUP > queue_capa.sched.max_num)
+ num_groups--;
+ num_queues = num_groups * QUEUES_PER_GROUP;
+
+ for (i = 0; i < num_groups; i++) {
+ for (j = 0; j < QUEUES_PER_GROUP; j++) {
+ odp_queue_t queue;
+ odp_queue_param_t param;
+
+ odp_queue_param_init(¶m);
+ param.type = ODP_QUEUE_TYPE_SCHED;
+ param.sched.prio = ODP_SCHED_PRIO_NORMAL;
+ param.sched.sync = ODP_SCHED_SYNC_PARALLEL;
+ param.sched.group = ODP_SCHED_GROUP_ALL;
+ param.size = pkts_per_group;
+
+ queue = odp_queue_create(NULL, ¶m);
+ if (queue == ODP_QUEUE_INVALID) {
+ LOG_ERR("Error: odp_queue_create() failed\n");
+ return -1;
+ }
+ gbl_args->queue[i][j] = queue;
+ }
+ }
+
+ /* Create packet pool */
+ if (odp_pool_capability(&pool_capa)) {
+ LOG_ERR("Error: odp_pool_capability() failed\n");
+ exit(EXIT_FAILURE);
+ }
+ num_pkts = pkts_per_group * num_groups;
+ if (num_pkts > pool_capa.pkt.max_num)
+ num_pkts = pool_capa.pkt.max_num;
+
+ pkt_len = sizeof(test_udp_packet);
+ if (pool_capa.pkt.max_len && pkt_len > pool_capa.pkt.max_len)
+ pkt_len = pool_capa.pkt.max_len;
+
+ if (pool_capa.pkt.max_seg_len && pkt_len > pool_capa.pkt.max_seg_len)
+ pkt_len = pool_capa.pkt.max_seg_len;
+
+ if (pkt_len < sizeof(test_udp_packet)) {
+ LOG_ERR("Error: min %dB single segment packets required\n",
+ (int)sizeof(test_udp_packet));
+ exit(EXIT_FAILURE);
+ }
+
+ if (pool_capa.pkt.max_uarea_size &&
+ pool_capa.pkt.max_uarea_size < sizeof(test_hdr_t)) {
+ LOG_ERR("Error: min %dB of packet user area required\n",
+ (int)sizeof(test_hdr_t));
+ exit(EXIT_FAILURE);
+ }
+
+ odp_pool_param_init(¶ms);
+ params.pkt.len = pkt_len;
+ params.pkt.max_len = pkt_len;
+ params.pkt.seg_len = pkt_len;
+ params.pkt.num = num_pkts;
+ params.pkt.max_num = num_pkts;
+ params.pkt.uarea_size = sizeof(test_hdr_t);
+ params.type = ODP_POOL_PACKET;
+ pool = odp_pool_create("pkt_pool", ¶ms);
+ if (pool == ODP_POOL_INVALID) {
+ LOG_ERR("Error: packet pool create failed\n");
+ exit(EXIT_FAILURE);
+ }
+ odp_pool_print(pool);
+
+ printf("CPU bench args\n--------------\n");
+ printf(" workers: %u\n", num_workers);
+ printf(" queues: %" PRIu32 "\n", num_queues);
+ printf(" pkts: %" PRIu32 "\n", num_pkts);
+ printf(" pkt size: %" PRIu32 " B\n", pkt_len);
+ printf(" lookup entries: %" PRIu64 "\n\n",
+ gbl_args->appl.lookup_tbl_size);
+
+ /* Spread test packets into queues */
+ for (i = 0; i < num_pkts; i++) {
+ odp_packet_t pkt = odp_packet_alloc(pool, pkt_len);
+ odp_event_t ev;
+ odp_queue_t queue;
+ uint16_t group = i % num_groups;
+
+ if (pkt == ODP_PACKET_INVALID) {
+ LOG_ERR("Error: odp_packet_alloc() failed\n");
+ return -1;
+ }
+
+ odp_packet_copy_from_mem(pkt, 0, pkt_len, test_udp_packet);
+
+ init_packet(pkt, i, group);
+
+ queue = gbl_args->queue[group][i % QUEUES_PER_GROUP];
+
+ ev = odp_packet_to_event(pkt);
+ if (odp_queue_enq(queue, ev)) {
+ LOG_ERR("Error: odp_queue_enq() failed\n");
+ return -1;
+ }
+ }
+
+ memset(thread_tbl, 0, sizeof(thread_tbl));
+ odp_barrier_init(&gbl_args->init_barrier, num_workers + 1);
+ odp_barrier_init(&gbl_args->term_barrier, num_workers + 1);
+
+ /* Initialize lookup table */
+ init_val = CRC_INIT_VAL;
+ for (i = 0; i < gbl_args->appl.lookup_tbl_size; i++) {
+ uint32_t *val0 = &gbl_args->lookup_tbl[i].val0;
+ uint32_t *val1 = &gbl_args->lookup_tbl[i].val1;
+
+ gbl_args->lookup_tbl[i].idx = i;
+
+ *val0 = i;
+ *val0 = odp_hash_crc32c(val0, sizeof(uint32_t), init_val);
+ *val1 = odp_hash_crc32c(val0, sizeof(uint32_t), init_val);
+ init_val = *val1;
+ }
+
+ /* Create worker threads */
+ cpu = odp_cpumask_first(&cpumask);
+ for (i = 0; i < num_workers; i++) {
+ odp_cpumask_t thd_mask;
+ odph_odpthread_params_t thr_params;
+
+ gbl_args->thread[i].idx = i;
+
+ memset(&thr_params, 0, sizeof(thr_params));
+ thr_params.start = run_thread;
+ thr_params.arg = &gbl_args->thread[i];
+ thr_params.thr_type = ODP_THREAD_WORKER;
+ thr_params.instance = instance;
+
+ stats[i] = &gbl_args->thread[i].stats;
+
+ odp_cpumask_zero(&thd_mask);
+ odp_cpumask_set(&thd_mask, cpu);
+ odph_odpthreads_create(&thread_tbl[i], &thd_mask,
+ &thr_params);
+ cpu = odp_cpumask_next(&cpumask, cpu);
+ }
+
+ ret = print_stats(num_workers, stats, gbl_args->appl.time,
+ gbl_args->appl.accuracy);
+
+ /* Master thread waits for other threads to exit */
+ for (i = 0; i < num_workers; ++i)
+ odph_odpthreads_join(&thread_tbl[i]);
+
+ for (i = 0; i < num_groups; i++) {
+ for (j = 0; j < QUEUES_PER_GROUP; j++) {
+ if (odp_queue_destroy(gbl_args->queue[i][j])) {
+ LOG_ERR("Error: queue destroy\n");
+ exit(EXIT_FAILURE);
+ }
+ }
+ }
+ if (odp_pool_destroy(pool)) {
+ LOG_ERR("Error: pool destroy\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (odp_shm_free(shm)) {
+ LOG_ERR("Error: shm free\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (odp_shm_free(lookup_tbl_shm)) {
+ LOG_ERR("Error: shm free\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (odp_term_local()) {
+ LOG_ERR("Error: term local\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (odp_term_global(instance)) {
+ LOG_ERR("Error: term global\n");
+ exit(EXIT_FAILURE);
+ }
+
+ return ret;
+}
-----------------------------------------------------------------------
Summary of changes:
test/performance/.gitignore | 1 +
test/performance/Makefile.am | 2 +
test/performance/odp_cpu_bench.c | 813 +++++++++++++++++++++++++++++++++++++++
3 files changed, 816 insertions(+)
create mode 100644 test/performance/odp_cpu_bench.c
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch master updated. v1.19.0.2_tigermoth-10-g60cc4b66
by git＠git-us.linaro.org
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 60cc4b660bea6af9b37a14fbf1ad07589b15b34e (commit)
via a9e3b02a54cd9a18baf8042e389ffbdb9266a9c7 (commit)
via ce5951842845b519c7887479c8e4e128e1951add (commit)
via 808acd63c4ec54af93eb5bbf717d4b591df1d904 (commit)
via 6b947deb94b45660a5140472565886e9d5f1203f (commit)
from 0330e7369aa682ac2c2feb2bcb197e52dc1810fb (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 60cc4b660bea6af9b37a14fbf1ad07589b15b34e
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Mon Jun 25 13:29:08 2018 +0300
linux-gen: sysinfo: parse aarch64 cpuinfo
Parse /proc/cpuinfo also on aarch64 and fill in cpu model
information.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/Makefile.am b/platform/linux-generic/Makefile.am
index c6b5ac99..a3399011 100644
--- a/platform/linux-generic/Makefile.am
+++ b/platform/linux-generic/Makefile.am
@@ -266,7 +266,7 @@ endif
if ARCH_IS_AARCH64
__LIB__libodp_linux_la_SOURCES += arch/default/odp_cpu_cycles.c \
arch/aarch64/odp_global_time.c \
- arch/default/odp_sysinfo_parse.c
+ arch/aarch64/odp_sysinfo_parse.c
odpapiabiarchinclude_HEADERS += arch/default/odp/api/abi/cpu_inlines.h \
arch/default/odp/api/abi/cpu_time.h
if !ODP_ABI_COMPAT
diff --git a/platform/linux-generic/arch/aarch64/odp_sysinfo_parse.c b/platform/linux-generic/arch/aarch64/odp_sysinfo_parse.c
new file mode 100644
index 00000000..85aec6a6
--- /dev/null
+++ b/platform/linux-generic/arch/aarch64/odp_sysinfo_parse.c
@@ -0,0 +1,212 @@
+/* Copyright (c) 2018, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#include "config.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <odp_sysinfo_internal.h>
+#include <odp_debug_internal.h>
+
+#define DUMMY_MAX_MHZ 1000
+#define TMP_STR_LEN 64
+
+static void aarch64_impl_str(char *str, int maxlen, int implementer)
+{
+ switch (implementer) {
+ case 0x41:
+ snprintf(str, maxlen, "ARM Limited");
+ return;
+ case 0x42:
+ snprintf(str, maxlen, "Broadcom Corporation");
+ return;
+ case 0x43:
+ snprintf(str, maxlen, "Cavium Inc.");
+ return;
+ case 0x44:
+ snprintf(str, maxlen, "Digital Equipment Corporation");
+ return;
+ case 0x49:
+ snprintf(str, maxlen, "Infineon Technologies AG");
+ return;
+ case 0x4d:
+ snprintf(str, maxlen, "Freescale Semiconductor Inc.");
+ return;
+ case 0x4e:
+ snprintf(str, maxlen, "NVIDIA Corporation");
+ return;
+ case 0x50:
+ snprintf(str, maxlen, "Applied Micro Circuits Corporation");
+ return;
+ case 0x51:
+ snprintf(str, maxlen, "Qualcomm Inc.");
+ return;
+ case 0x56:
+ snprintf(str, maxlen, "Marvell International Ltd.");
+ return;
+ case 0x69:
+ snprintf(str, maxlen, "Intel Corporation");
+ return;
+ default:
+ break;
+ }
+
+ snprintf(str, maxlen, "UNKNOWN (0x%x)", implementer);
+}
+
+static void aarch64_part_str(char *str, int maxlen, int implementer,
+ int part, int variant, int revision)
+{
+ if (implementer == 0x41) {
+ switch (part) {
+ case 0xd03:
+ snprintf(str, maxlen, "Cortex-A53");
+ return;
+ case 0xd05:
+ snprintf(str, maxlen, "Cortex-A55");
+ return;
+ case 0xd07:
+ snprintf(str, maxlen, "Cortex-A57");
+ return;
+ case 0xd08:
+ snprintf(str, maxlen, "Cortex-A72");
+ return;
+ case 0xd09:
+ snprintf(str, maxlen, "Cortex-A73");
+ return;
+ case 0xd0a:
+ snprintf(str, maxlen, "Cortex-A75");
+ return;
+ default:
+ break;
+ }
+ } else if (implementer == 0x43) {
+ switch (part) {
+ case 0xa1:
+ snprintf(str, maxlen, "CN88XX, Pass %i.%i",
+ variant + 1, revision);
+ return;
+ case 0xa2:
+ snprintf(str, maxlen, "CN81XX, Pass %i.%i",
+ variant + 1, revision);
+ return;
+ case 0xa3:
+ snprintf(str, maxlen, "CN83XX, Pass %i.%i",
+ variant + 1, revision);
+ return;
+ case 0xaf:
+ snprintf(str, maxlen, "CN99XX, Pass %i.%i",
+ variant + 1, revision);
+ return;
+ default:
+ break;
+ }
+ }
+
+ snprintf(str, maxlen, "part 0x%x, var 0x%x, rev 0x%x",
+ part, variant, revision);
+}
+
+int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
+{
+ char str[1024];
+ char impl_str[TMP_STR_LEN];
+ char part_str[TMP_STR_LEN];
+ const char *cur;
+ long int impl, arch, var, part, rev;
+ int id;
+
+ strcpy(sysinfo->cpu_arch_str, "aarch64");
+
+ memset(impl_str, 0, sizeof(impl_str));
+ memset(part_str, 0, sizeof(part_str));
+
+ impl = 0;
+ arch = 0;
+ var = 0;
+ part = 0;
+ rev = 0;
+ id = 0;
+
+ while (fgets(str, sizeof(str), file) != NULL && id < CONFIG_NUM_CPU) {
+ /* Parse line by line a block of cpuinfo */
+ cur = strstr(str, "CPU implementer");
+
+ if (cur) {
+ cur = strchr(cur, ':');
+ impl = strtol(cur + 1, NULL, 16);
+ aarch64_impl_str(impl_str, TMP_STR_LEN, impl);
+ continue;
+ }
+
+ cur = strstr(str, "CPU architecture");
+
+ if (cur) {
+ cur = strchr(cur, ':');
+ arch = strtol(cur + 1, NULL, 10);
+ continue;
+ }
+
+ cur = strstr(str, "CPU variant");
+
+ if (cur) {
+ cur = strchr(cur, ':');
+ var = strtol(cur + 1, NULL, 16);
+ continue;
+ }
+
+ cur = strstr(str, "CPU part");
+
+ if (cur) {
+ cur = strchr(cur, ':');
+ part = strtol(cur + 1, NULL, 16);
+ continue;
+ }
+
+ cur = strstr(str, "CPU revision");
+
+ if (cur) {
+ cur = strchr(cur, ':');
+ rev = strtol(cur + 1, NULL, 10);
+
+ aarch64_part_str(part_str, TMP_STR_LEN,
+ impl, part, var, rev);
+
+ /* This is the last line about this cpu, update
+ * model string. */
+ snprintf(sysinfo->model_str[id],
+ sizeof(sysinfo->model_str[id]),
+ "%s, %s, arch %li",
+ impl_str, part_str, arch);
+
+ /* Some CPUs do not support cpufreq, use a dummy
+ * max freq. */
+ if (sysinfo->cpu_hz_max[id] == 0) {
+ uint64_t hz = DUMMY_MAX_MHZ * 1000000;
+
+ ODP_PRINT("WARN: cpu[%i] uses dummy max frequency %u MHz\n",
+ id, DUMMY_MAX_MHZ);
+ sysinfo->cpu_hz_max[id] = hz;
+ }
+
+ id++;
+ }
+ }
+
+ return 0;
+}
+
+void sys_info_print_arch(void)
+{
+}
+
+uint64_t odp_cpu_arch_hz_current(int id)
+{
+ (void)id;
+
+ return 0;
+}
commit a9e3b02a54cd9a18baf8042e389ffbdb9266a9c7
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Wed Jun 27 17:10:16 2018 +0300
linux-gen: sysinfo: use cpufreq for max freq by default
Usually, maximum CPU frequency is found from a cpufreq file.
Read that file first, if it's not found use cpuinfo instead.
If max freq cannot be found, use hard coded value and print
a warning.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/arch/default/odp_sysinfo_parse.c b/platform/linux-generic/arch/default/odp_sysinfo_parse.c
index 2c3bf841..b9378887 100644
--- a/platform/linux-generic/arch/default/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/default/odp_sysinfo_parse.c
@@ -10,13 +10,17 @@
#include <odp_debug_internal.h>
#include <string.h>
+#define DUMMY_MAX_MHZ 1400
+
int cpuinfo_parser(FILE *file ODP_UNUSED, system_info_t *sysinfo)
{
int i;
ODP_DBG("Warning: use dummy values for freq and model string\n");
for (i = 0; i < CONFIG_NUM_CPU; i++) {
- sysinfo->cpu_hz_max[i] = 1400000000;
+ ODP_PRINT("WARN: cpu[%i] uses dummy max frequency %u MHz\n",
+ i, DUMMY_MAX_MHZ);
+ sysinfo->cpu_hz_max[i] = DUMMY_MAX_MHZ * 1000000;
strcpy(sysinfo->model_str[i], "UNKNOWN");
}
diff --git a/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c b/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c
index 927cb83f..7b313b6d 100644
--- a/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c
@@ -41,7 +41,7 @@ int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
pos = strchr(str, ':');
strncpy(sysinfo->model_str[id], pos + 2,
- sizeof(sysinfo->model_str[id]) - 1);
+ MODEL_STR_SIZE - 1);
len = strlen(sysinfo->model_str[id]);
sysinfo->model_str[id][len - 1] = 0;
model = 1;
diff --git a/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c b/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c
index daa72c24..1fb1b4a3 100644
--- a/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c
@@ -40,7 +40,7 @@ int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
pos = strchr(str, ':');
strncpy(sysinfo->model_str[id], pos + 2,
- sizeof(sysinfo->model_str[id]) - 1);
+ MODEL_STR_SIZE - 1);
len = strlen(sysinfo->model_str[id]);
sysinfo->model_str[id][len - 1] = 0;
model = 1;
diff --git a/platform/linux-generic/arch/x86/odp_sysinfo_parse.c b/platform/linux-generic/arch/x86/odp_sysinfo_parse.c
index f9a21975..504aa3ef 100644
--- a/platform/linux-generic/arch/x86/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/x86/odp_sysinfo_parse.c
@@ -13,7 +13,7 @@
int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
{
char str[1024];
- char *pos;
+ char *pos, *pos_end;
double ghz = 0.0;
uint64_t hz;
int id = 0;
@@ -22,17 +22,25 @@ int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
while (fgets(str, sizeof(str), file) != NULL && id < CONFIG_NUM_CPU) {
pos = strstr(str, "model name");
if (pos) {
- pos = strchr(str, ':');
+ /* Copy model name between : and @ characters */
+ pos = strchr(str, ':');
+ pos_end = strchr(str, '@');
+ if (pos == NULL || pos_end == NULL)
+ continue;
+
+ *(pos_end - 1) = '\0';
strncpy(sysinfo->model_str[id], pos + 2,
- sizeof(sysinfo->model_str[id]) - 1);
+ MODEL_STR_SIZE - 1);
+
+ if (sysinfo->cpu_hz_max[id]) {
+ id++;
+ continue;
+ }
- pos = strchr(sysinfo->model_str[id], '@');
- if (pos) {
- *(pos - 1) = '\0';
- if (sscanf(pos, "@ %lfGHz", &ghz) == 1) {
- hz = (uint64_t)(ghz * 1000000000.0);
- sysinfo->cpu_hz_max[id] = hz;
- }
+ /* max frequency needs to be set */
+ if (sscanf(pos_end, "@ %lfGHz", &ghz) == 1) {
+ hz = (uint64_t)(ghz * 1000000000.0);
+ sysinfo->cpu_hz_max[id] = hz;
}
id++;
}
diff --git a/platform/linux-generic/include/odp_global_data.h b/platform/linux-generic/include/odp_global_data.h
index 4a8702a6..009862a8 100644
--- a/platform/linux-generic/include/odp_global_data.h
+++ b/platform/linux-generic/include/odp_global_data.h
@@ -19,6 +19,7 @@ extern "C" {
#include <libconfig.h>
#include <odp_config_internal.h>
+#define MODEL_STR_SIZE 128
#define UID_MAXLEN 30
typedef struct {
@@ -27,7 +28,7 @@ typedef struct {
int cache_line_size;
int cpu_count;
char cpu_arch_str[128];
- char model_str[CONFIG_NUM_CPU][128];
+ char model_str[CONFIG_NUM_CPU][MODEL_STR_SIZE];
} system_info_t;
typedef struct {
diff --git a/platform/linux-generic/include/odp_sysinfo_internal.h b/platform/linux-generic/include/odp_sysinfo_internal.h
index d34087e2..2f01d18e 100644
--- a/platform/linux-generic/include/odp_sysinfo_internal.h
+++ b/platform/linux-generic/include/odp_sysinfo_internal.h
@@ -14,7 +14,6 @@ extern "C" {
#include <odp_global_data.h>
int cpuinfo_parser(FILE *file, system_info_t *sysinfo);
-uint64_t odp_cpufreq_id(const char *filename, int id);
uint64_t odp_cpu_hz_current(int id);
uint64_t odp_cpu_arch_hz_current(int id);
void sys_info_print_arch(void);
diff --git a/platform/linux-generic/odp_system_info.c b/platform/linux-generic/odp_system_info.c
index 09e184a7..bca02ba1 100644
--- a/platform/linux-generic/odp_system_info.c
+++ b/platform/linux-generic/odp_system_info.c
@@ -265,7 +265,7 @@ static char *get_hugepage_dir(uint64_t hugepage_sz)
/*
* Analysis of /sys/devices/system/cpu/cpu%d/cpufreq/ files
*/
-uint64_t odp_cpufreq_id(const char *filename, int id)
+static uint64_t read_cpufreq(const char *filename, int id)
{
char path[256], buffer[256], *endptr = NULL;
FILE *file;
@@ -343,23 +343,25 @@ int odp_system_info_init(void)
odp_global_data.system_info.page_size = ODP_PAGE_SIZE;
+ /* By default, read max frequency from a cpufreq file */
+ for (i = 0; i < CONFIG_NUM_CPU; i++) {
+ uint64_t cpu_hz_max = read_cpufreq("cpuinfo_max_freq", i);
+
+ if (cpu_hz_max)
+ odp_global_data.system_info.cpu_hz_max[i] = cpu_hz_max;
+ }
+
file = fopen("/proc/cpuinfo", "rt");
if (file == NULL) {
ODP_ERR("Failed to open /proc/cpuinfo\n");
return -1;
}
+ /* Read CPU model, and set max cpu frequency if not set from cpufreq. */
cpuinfo_parser(file, &odp_global_data.system_info);
fclose(file);
- for (i = 0; i < CONFIG_NUM_CPU; i++) {
- uint64_t cpu_hz_max = odp_cpufreq_id("cpuinfo_max_freq", i);
-
- if (cpu_hz_max)
- odp_global_data.system_info.cpu_hz_max[i] = cpu_hz_max;
- }
-
if (systemcpu(&odp_global_data.system_info)) {
ODP_ERR("systemcpu failed\n");
return -1;
@@ -387,7 +389,7 @@ int odp_system_info_term(void)
*/
uint64_t odp_cpu_hz_current(int id)
{
- uint64_t cur_hz = odp_cpufreq_id("cpuinfo_cur_freq", id);
+ uint64_t cur_hz = read_cpufreq("cpuinfo_cur_freq", id);
if (!cur_hz)
cur_hz = odp_cpu_arch_hz_current(id);
commit ce5951842845b519c7887479c8e4e128e1951add
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Wed Jun 27 16:11:56 2018 +0300
linux-gen: config: increase max number of cpus
Enable testing on a new system that has more than 128 cpus.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/include/odp_config_internal.h b/platform/linux-generic/include/odp_config_internal.h
index d47ce55e..14fa4f6c 100644
--- a/platform/linux-generic/include/odp_config_internal.h
+++ b/platform/linux-generic/include/odp_config_internal.h
@@ -14,7 +14,7 @@ extern "C" {
/*
* Maximum number of CPUs supported. Maximum CPU ID is CONFIG_NUM_CPU - 1.
*/
-#define CONFIG_NUM_CPU 128
+#define CONFIG_NUM_CPU 256
/*
* Maximum number of pools
commit 808acd63c4ec54af93eb5bbf717d4b591df1d904
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Wed Jun 27 15:58:28 2018 +0300
linux-gen: cpu: move num cpu into config header file
Rename and move number of CPUs define into the config header
file.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/platform/linux-generic/arch/default/odp_sysinfo_parse.c b/platform/linux-generic/arch/default/odp_sysinfo_parse.c
index 49e94029..2c3bf841 100644
--- a/platform/linux-generic/arch/default/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/default/odp_sysinfo_parse.c
@@ -15,7 +15,7 @@ int cpuinfo_parser(FILE *file ODP_UNUSED, system_info_t *sysinfo)
int i;
ODP_DBG("Warning: use dummy values for freq and model string\n");
- for (i = 0; i < MAX_CPU_NUMBER; i++) {
+ for (i = 0; i < CONFIG_NUM_CPU; i++) {
sysinfo->cpu_hz_max[i] = 1400000000;
strcpy(sysinfo->model_str[i], "UNKNOWN");
}
diff --git a/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c b/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c
index 339c6749..927cb83f 100644
--- a/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/mips64/odp_sysinfo_parse.c
@@ -20,7 +20,7 @@ int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
int id = 0;
strcpy(sysinfo->cpu_arch_str, "mips64");
- while (fgets(str, sizeof(str), file) != NULL && id < MAX_CPU_NUMBER) {
+ while (fgets(str, sizeof(str), file) != NULL && id < CONFIG_NUM_CPU) {
if (!mhz) {
pos = strstr(str, "BogoMIPS");
diff --git a/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c b/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c
index 810f3758..daa72c24 100644
--- a/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/powerpc/odp_sysinfo_parse.c
@@ -20,7 +20,7 @@ int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
int id = 0;
strcpy(sysinfo->cpu_arch_str, "powerpc");
- while (fgets(str, sizeof(str), file) != NULL && id < MAX_CPU_NUMBER) {
+ while (fgets(str, sizeof(str), file) != NULL && id < CONFIG_NUM_CPU) {
if (!mhz) {
pos = strstr(str, "clock");
diff --git a/platform/linux-generic/arch/x86/odp_sysinfo_parse.c b/platform/linux-generic/arch/x86/odp_sysinfo_parse.c
index d9f3a82d..f9a21975 100644
--- a/platform/linux-generic/arch/x86/odp_sysinfo_parse.c
+++ b/platform/linux-generic/arch/x86/odp_sysinfo_parse.c
@@ -19,7 +19,7 @@ int cpuinfo_parser(FILE *file, system_info_t *sysinfo)
int id = 0;
strcpy(sysinfo->cpu_arch_str, "x86");
- while (fgets(str, sizeof(str), file) != NULL && id < MAX_CPU_NUMBER) {
+ while (fgets(str, sizeof(str), file) != NULL && id < CONFIG_NUM_CPU) {
pos = strstr(str, "model name");
if (pos) {
pos = strchr(str, ':');
diff --git a/platform/linux-generic/include/odp_config_internal.h b/platform/linux-generic/include/odp_config_internal.h
index d579381e..d47ce55e 100644
--- a/platform/linux-generic/include/odp_config_internal.h
+++ b/platform/linux-generic/include/odp_config_internal.h
@@ -11,6 +11,11 @@
extern "C" {
#endif
+/*
+ * Maximum number of CPUs supported. Maximum CPU ID is CONFIG_NUM_CPU - 1.
+ */
+#define CONFIG_NUM_CPU 128
+
/*
* Maximum number of pools
*/
diff --git a/platform/linux-generic/include/odp_global_data.h b/platform/linux-generic/include/odp_global_data.h
index a5c2abd1..4a8702a6 100644
--- a/platform/linux-generic/include/odp_global_data.h
+++ b/platform/linux-generic/include/odp_global_data.h
@@ -17,17 +17,17 @@ extern "C" {
#include <pthread.h>
#include <stdint.h>
#include <libconfig.h>
+#include <odp_config_internal.h>
-#define MAX_CPU_NUMBER 128
#define UID_MAXLEN 30
typedef struct {
- uint64_t cpu_hz_max[MAX_CPU_NUMBER];
+ uint64_t cpu_hz_max[CONFIG_NUM_CPU];
uint64_t page_size;
int cache_line_size;
int cpu_count;
char cpu_arch_str[128];
- char model_str[MAX_CPU_NUMBER][128];
+ char model_str[CONFIG_NUM_CPU][128];
} system_info_t;
typedef struct {
diff --git a/platform/linux-generic/odp_system_info.c b/platform/linux-generic/odp_system_info.c
index 8b2bfc5c..09e184a7 100644
--- a/platform/linux-generic/odp_system_info.c
+++ b/platform/linux-generic/odp_system_info.c
@@ -353,7 +353,7 @@ int odp_system_info_init(void)
fclose(file);
- for (i = 0; i < MAX_CPU_NUMBER; i++) {
+ for (i = 0; i < CONFIG_NUM_CPU; i++) {
uint64_t cpu_hz_max = odp_cpufreq_id("cpuinfo_max_freq", i);
if (cpu_hz_max)
@@ -414,7 +414,7 @@ uint64_t odp_cpu_hz_max(void)
uint64_t odp_cpu_hz_max_id(int id)
{
- if (id >= 0 && id < MAX_CPU_NUMBER)
+ if (id >= 0 && id < CONFIG_NUM_CPU)
return odp_global_data.system_info.cpu_hz_max[id];
else
return 0;
@@ -473,7 +473,7 @@ const char *odp_cpu_model_str(void)
const char *odp_cpu_model_str_id(int id)
{
- if (id >= 0 && id < MAX_CPU_NUMBER)
+ if (id >= 0 && id < CONFIG_NUM_CPU)
return odp_global_data.system_info.model_str[id];
else
return NULL;
commit 6b947deb94b45660a5140472565886e9d5f1203f
Author: Petri Savolainen <petri.savolainen(a)linaro.org>
Date: Tue Jun 26 13:37:35 2018 +0300
example: sysinfo: application to print system information
Add new application that simply queries and prints out various
system information which is available through ODP APIs. This
can be useful e.g. when examining HW or ODP implementation
capabilities, when debugging other ODP applications, etc.
Signed-off-by: Petri Savolainen <petri.savolainen(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/example/Makefile.am b/example/Makefile.am
index 2ea244cf..0e12baf1 100644
--- a/example/Makefile.am
+++ b/example/Makefile.am
@@ -9,6 +9,7 @@ SUBDIRS = classifier \
l3fwd \
packet \
switch \
+ sysinfo \
time \
timer \
traffic_mgmt
diff --git a/example/m4/configure.m4 b/example/m4/configure.m4
index 1ce0cb11..cbac0914 100644
--- a/example/m4/configure.m4
+++ b/example/m4/configure.m4
@@ -18,6 +18,7 @@ AC_CONFIG_FILES([example/classifier/Makefile
example/l3fwd/Makefile
example/packet/Makefile
example/switch/Makefile
+ example/sysinfo/Makefile
example/time/Makefile
example/timer/Makefile
example/traffic_mgmt/Makefile
diff --git a/example/sysinfo/.gitignore b/example/sysinfo/.gitignore
new file mode 100644
index 00000000..208e8dfc
--- /dev/null
+++ b/example/sysinfo/.gitignore
@@ -0,0 +1,3 @@
+odp_sysinfo
+*.log
+*.trs
diff --git a/example/sysinfo/Makefile.am b/example/sysinfo/Makefile.am
new file mode 100644
index 00000000..a8b55b5c
--- /dev/null
+++ b/example/sysinfo/Makefile.am
@@ -0,0 +1,9 @@
+include $(top_srcdir)/example/Makefile.inc
+
+bin_PROGRAMS = odp_sysinfo
+
+odp_sysinfo_SOURCES = odp_sysinfo.c
+
+if test_example
+TESTS = odp_sysinfo
+endif
diff --git a/example/sysinfo/odp_sysinfo.c b/example/sysinfo/odp_sysinfo.c
new file mode 100644
index 00000000..e177319b
--- /dev/null
+++ b/example/sysinfo/odp_sysinfo.c
@@ -0,0 +1,293 @@
+/* Copyright (c) 2018, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include <odp_api.h>
+
+#define KB 1024
+#define MB (1024 * 1024)
+#define MAX_HUGE_PAGES 32
+
+static const char *support_level(odp_support_t support)
+{
+ switch (support) {
+ case ODP_SUPPORT_NO: return "no";
+ case ODP_SUPPORT_YES: return "yes";
+ case ODP_SUPPORT_PREFERRED: return "yes, preferred";
+ default: return "UNKNOWN";
+ }
+}
+
+static void print_cipher_algos(odp_crypto_cipher_algos_t ciphers)
+{
+ if (ciphers.bit.null)
+ printf("null ");
+ if (ciphers.bit.des)
+ printf("des ");
+ if (ciphers.bit.trides_cbc)
+ printf("trides_cbc ");
+ if (ciphers.bit.aes_cbc)
+ printf("aes_cbc ");
+ if (ciphers.bit.aes_ctr)
+ printf("aes_ctr ");
+ if (ciphers.bit.aes_gcm)
+ printf("aes_gcm ");
+ if (ciphers.bit.aes_ccm)
+ printf("aes_ccm ");
+ if (ciphers.bit.chacha20_poly1305)
+ printf("chacha20_poly1305 ");
+}
+
+static void print_auth_algos(odp_crypto_auth_algos_t auths)
+{
+ if (auths.bit.null)
+ printf("null ");
+ if (auths.bit.md5_hmac)
+ printf("md5_hmac ");
+ if (auths.bit.sha1_hmac)
+ printf("sha1_hmac ");
+ if (auths.bit.sha256_hmac)
+ printf("sha256_hmac ");
+ if (auths.bit.sha384_hmac)
+ printf("sha384_hmac ");
+ if (auths.bit.sha512_hmac)
+ printf("sha512_hmac ");
+ if (auths.bit.aes_gcm)
+ printf("aes_gcm ");
+ if (auths.bit.aes_gmac)
+ printf("aes_gmac ");
+ if (auths.bit.aes_ccm)
+ printf("aes_ccm ");
+ if (auths.bit.aes_cmac)
+ printf("aes_cmac ");
+ if (auths.bit.aes_xcbc_mac)
+ printf("aes_xcbc_mac ");
+ if (auths.bit.chacha20_poly1305)
+ printf("chacha20_poly1305 ");
+}
+
+int main(void)
+{
+ odp_instance_t inst;
+ int i, num_hp, num_hp_print;
+ int num_ava, num_work, num_ctrl;
+ odp_cpumask_t ava_mask, work_mask, ctrl_mask;
+ odp_shm_capability_t shm_capa;
+ odp_pool_capability_t pool_capa;
+ odp_queue_capability_t queue_capa;
+ odp_timer_capability_t timer_capa;
+ odp_crypto_capability_t crypto_capa;
+ uint64_t huge_page[MAX_HUGE_PAGES];
+ char ava_mask_str[ODP_CPUMASK_STR_SIZE];
+ char work_mask_str[ODP_CPUMASK_STR_SIZE];
+ char ctrl_mask_str[ODP_CPUMASK_STR_SIZE];
+
+ printf("\n");
+ printf("ODP system info example\n");
+ printf("***********************************************************\n");
+ printf("\n");
+
+ if (odp_init_global(&inst, NULL, NULL)) {
+ printf("Global init failed.\n");
+ return -1;
+ }
+
+ if (odp_init_local(inst, ODP_THREAD_CONTROL)) {
+ printf("Local init failed.\n");
+ return -1;
+ }
+
+ odp_sys_info_print();
+
+ memset(ava_mask_str, 0, ODP_CPUMASK_STR_SIZE);
+ num_ava = odp_cpumask_all_available(&ava_mask);
+ odp_cpumask_to_str(&ava_mask, ava_mask_str, ODP_CPUMASK_STR_SIZE);
+
+ memset(work_mask_str, 0, ODP_CPUMASK_STR_SIZE);
+ num_work = odp_cpumask_default_worker(&work_mask, 0);
+ odp_cpumask_to_str(&work_mask, work_mask_str, ODP_CPUMASK_STR_SIZE);
+
+ memset(ctrl_mask_str, 0, ODP_CPUMASK_STR_SIZE);
+ num_ctrl = odp_cpumask_default_control(&ctrl_mask, 0);
+ odp_cpumask_to_str(&ctrl_mask, ctrl_mask_str, ODP_CPUMASK_STR_SIZE);
+
+ num_hp = odp_sys_huge_page_size_all(huge_page, MAX_HUGE_PAGES);
+
+ num_hp_print = num_hp;
+ if (num_hp_print > MAX_HUGE_PAGES)
+ num_hp_print = MAX_HUGE_PAGES;
+
+ if (odp_shm_capability(&shm_capa)) {
+ printf("shm capability failed\n");
+ return -1;
+ }
+
+ if (odp_pool_capability(&pool_capa)) {
+ printf("pool capability failed\n");
+ return -1;
+ }
+
+ if (odp_queue_capability(&queue_capa)) {
+ printf("queue capability failed\n");
+ return -1;
+ }
+
+ if (odp_timer_capability(ODP_CLOCK_CPU, &timer_capa)) {
+ printf("timer capability failed\n");
+ return -1;
+ }
+
+ if (odp_crypto_capability(&crypto_capa)) {
+ printf("crypto capability failed\n");
+ return -1;
+ }
+
+ printf("\n");
+ printf("S Y S T E M I N F O R M A T I O N\n");
+ printf("***********************************************************\n");
+ printf("\n");
+ printf(" ODP API version: %s\n", odp_version_api_str());
+ printf(" ODP impl name: %s\n", odp_version_impl_name());
+ printf(" ODP impl details: %s\n", odp_version_impl_str());
+ printf(" CPU model: %s\n", odp_cpu_model_str());
+ printf(" CPU max freq: %" PRIu64 " hz\n", odp_cpu_hz_max());
+ printf(" Current CPU: %i\n", odp_cpu_id());
+ printf(" Current CPU freq: %" PRIu64 " hz\n", odp_cpu_hz());
+ printf(" CPU count: %i\n", odp_cpu_count());
+ printf(" CPU available num: %i\n", num_ava);
+ printf(" CPU available mask: %s\n", ava_mask_str);
+ printf(" CPU worker num: %i\n", num_work);
+ printf(" CPU worker mask: %s\n", work_mask_str);
+ printf(" CPU control num: %i\n", num_ctrl);
+ printf(" CPU control mask: %s\n", ctrl_mask_str);
+ printf(" Max threads (define): %i\n", ODP_THREAD_COUNT_MAX);
+ printf(" Max threads: %i\n", odp_thread_count_max());
+ printf(" Byte order: %s (%i / %i)\n",
+ ODP_BYTE_ORDER == ODP_BIG_ENDIAN ? "big" : "little",
+ ODP_BIG_ENDIAN, ODP_LITTLE_ENDIAN);
+ printf(" Bitfield order: %s (%i / %i)\n",
+ ODP_BITFIELD_ORDER == ODP_BIG_ENDIAN_BITFIELD ?
+ "big" : "little",
+ ODP_BIG_ENDIAN_BITFIELD, ODP_LITTLE_ENDIAN_BITFIELD);
+ printf(" Cache line size: %i B\n", odp_sys_cache_line_size());
+ printf(" Page size: %" PRIu64 " kB\n",
+ odp_sys_page_size() / KB);
+ printf(" Default huge page size: %" PRIu64 " kB\n",
+ odp_sys_huge_page_size() / KB);
+ printf(" Num huge page sizes: %i\n", num_hp);
+
+ for (i = 0; i < num_hp_print; i++)
+ printf(" Huge page size [%i]: %" PRIu64 " kB\n",
+ i, huge_page[i] / KB);
+
+ printf("\n");
+ printf(" SHM\n");
+ printf(" max_blocks: %u\n", shm_capa.max_blocks);
+ printf(" max_size: %" PRIu64 " MB\n",
+ shm_capa.max_size / MB);
+ printf(" max_align: %" PRIu64 " B\n", shm_capa.max_align);
+
+ printf("\n");
+ printf(" POOL\n");
+ printf(" max_pools: %u\n", pool_capa.max_pools);
+ printf(" buf.max_pools: %u\n", pool_capa.buf.max_pools);
+ printf(" buf.max_align: %" PRIu32 " B\n",
+ pool_capa.buf.max_align);
+ printf(" buf.max_size: %" PRIu32 " kB\n",
+ pool_capa.buf.max_size / KB);
+ printf(" buf.max_num: %" PRIu32 "\n",
+ pool_capa.buf.max_num);
+ printf(" pkt.max_pools: %u\n", pool_capa.pkt.max_pools);
+ printf(" pkt.max_len: %" PRIu32 " kB\n",
+ pool_capa.pkt.max_len / KB);
+ printf(" pkt.max_num: %" PRIu32 "\n",
+ pool_capa.pkt.max_num);
+ printf(" pkt.max_segs: %" PRIu32 "\n",
+ pool_capa.pkt.max_segs_per_pkt);
+ printf(" pkt.max_seg_len: %" PRIu32 " B\n",
+ pool_capa.pkt.max_seg_len);
+ printf(" pkt.max_uarea: %" PRIu32 " B\n",
+ pool_capa.pkt.max_uarea_size);
+ printf(" tmo.max_pools: %u\n", pool_capa.tmo.max_pools);
+ printf(" tmo.max_num: %" PRIu32 "\n",
+ pool_capa.tmo.max_num);
+
+ printf("\n");
+ printf(" QUEUE\n");
+ printf(" max queues: %" PRIu32 "\n",
+ queue_capa.max_queues);
+ printf(" plain.max_num: %" PRIu32 "\n",
+ queue_capa.plain.max_num);
+ printf(" plain.max_size: %" PRIu32 "\n",
+ queue_capa.plain.max_size);
+ printf(" plain.lf.max_num: %" PRIu32 "\n",
+ queue_capa.plain.lockfree.max_num);
+ printf(" plain.lf.max_size: %" PRIu32 "\n",
+ queue_capa.plain.lockfree.max_size);
+ printf(" plain.wf.max_num: %" PRIu32 "\n",
+ queue_capa.plain.waitfree.max_num);
+ printf(" plain.wf.max_size: %" PRIu32 "\n",
+ queue_capa.plain.waitfree.max_size);
+
+ printf("\n");
+ printf(" SCHEDULER\n");
+ printf(" max ordered locks: %" PRIu32 "\n",
+ queue_capa.max_ordered_locks);
+ printf(" max groups: %u\n", queue_capa.max_sched_groups);
+ printf(" priorities: %u\n", queue_capa.sched_prios);
+ printf(" sched.max_num: %" PRIu32 "\n",
+ queue_capa.sched.max_num);
+ printf(" sched.max_size: %" PRIu32 "\n",
+ queue_capa.sched.max_size);
+ printf(" sched.lf.max_num: %" PRIu32 "\n",
+ queue_capa.sched.lockfree.max_num);
+ printf(" sched.lf.max_size: %" PRIu32 "\n",
+ queue_capa.sched.lockfree.max_size);
+ printf(" sched.wf.max_num: %" PRIu32 "\n",
+ queue_capa.sched.waitfree.max_num);
+ printf(" sched.wf.max_size: %" PRIu32 "\n",
+ queue_capa.sched.waitfree.max_size);
+
+ printf("\n");
+ printf(" TIMER\n");
+ printf(" highest resolution: %" PRIu64 " nsec\n",
+ timer_capa.highest_res_ns);
+
+ printf("\n");
+ printf(" CRYPTO\n");
+ printf(" max sessions: %" PRIu32 "\n",
+ crypto_capa.max_sessions);
+ printf(" sync mode support: %s\n",
+ support_level(crypto_capa.sync_mode));
+ printf(" async mode support: %s\n",
+ support_level(crypto_capa.async_mode));
+ printf(" cipher algorithms: ");
+ print_cipher_algos(crypto_capa.ciphers);
+ printf("\n");
+ printf(" auth algorithms: ");
+ print_auth_algos(crypto_capa.auths);
+ printf("\n");
+
+ printf("\n");
+ printf("***********************************************************\n");
+ printf("\n");
+
+ if (odp_term_local()) {
+ printf("Local term failed.\n");
+ return -1;
+ }
+
+ if (odp_term_global(inst)) {
+ printf("Global term failed.\n");
+ return -1;
+ }
+
+ return 0;
+}
-----------------------------------------------------------------------
Summary of changes:
example/Makefile.am | 1 +
example/m4/configure.m4 | 1 +
example/{hello => sysinfo}/.gitignore | 2 +-
example/sysinfo/Makefile.am | 9 +
example/sysinfo/odp_sysinfo.c | 293 +++++++++++++++++++++
platform/linux-generic/Makefile.am | 2 +-
.../linux-generic/arch/aarch64/odp_sysinfo_parse.c | 212 +++++++++++++++
.../linux-generic/arch/default/odp_sysinfo_parse.c | 8 +-
.../linux-generic/arch/mips64/odp_sysinfo_parse.c | 4 +-
.../linux-generic/arch/powerpc/odp_sysinfo_parse.c | 4 +-
.../linux-generic/arch/x86/odp_sysinfo_parse.c | 30 ++-
.../linux-generic/include/odp_config_internal.h | 5 +
platform/linux-generic/include/odp_global_data.h | 7 +-
.../linux-generic/include/odp_sysinfo_internal.h | 1 -
platform/linux-generic/odp_system_info.c | 24 +-
15 files changed, 569 insertions(+), 34 deletions(-)
copy example/{hello => sysinfo}/.gitignore (50%)
create mode 100644 example/sysinfo/Makefile.am
create mode 100644 example/sysinfo/odp_sysinfo.c
create mode 100644 platform/linux-generic/arch/aarch64/odp_sysinfo_parse.c
hooks/post-receive
--
8 years, 1 month
- 1
- 0
[COMMIT] branch master updated. v1.19.0.2_tigermoth-5-g0330e736
by git＠git-us.linaro.org
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 0330e7369aa682ac2c2feb2bcb197e52dc1810fb (commit)
via 7c72d611d8d568358d4a7849057e42708cbb10c3 (commit)
from 9ccda90b1788836848ecc5977d9cd8a807ee20c9 (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 0330e7369aa682ac2c2feb2bcb197e52dc1810fb
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Fri Jun 29 15:51:25 2018 +0300
example: use ODP_THREAD_COUNT_MAX as max worker count
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-by: Bogdan Pricope <bogdan.pricope(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/example/classifier/odp_classifier.c b/example/classifier/odp_classifier.c
index cdcb35bb..3403647b 100644
--- a/example/classifier/odp_classifier.c
+++ b/example/classifier/odp_classifier.c
@@ -20,7 +20,7 @@
/** @def MAX_WORKERS
* @brief Maximum number of worker threads
*/
-#define MAX_WORKERS 32
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/** @def SHM_PKT_POOL_SIZE
* @brief Size of the shared memory block
diff --git a/example/generator/odp_generator.c b/example/generator/odp_generator.c
index 706c071a..0785e3ec 100644
--- a/example/generator/odp_generator.c
+++ b/example/generator/odp_generator.c
@@ -22,7 +22,8 @@
#include <odp/helper/odph_api.h>
-#define MAX_WORKERS 32 /* Max number of workers */
+/* Max number of workers */
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
#define POOL_NUM_PKT 2048 /* Number of packets in packet pool */
#define POOL_PKT_LEN 1856 /* Max packet length */
#define DEFAULT_PKT_INTERVAL 1000 /* Interval between each packet */
diff --git a/example/ipsec/odp_ipsec.c b/example/ipsec/odp_ipsec.c
index 6371437b..2624af5d 100644
--- a/example/ipsec/odp_ipsec.c
+++ b/example/ipsec/odp_ipsec.c
@@ -63,7 +63,8 @@ static int create_stream_db_entry(char *input ODP_UNUSED)
}
#endif
-#define MAX_WORKERS 32 /**< maximum number of worker threads */
+/* maximum number of worker threads */
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/**
* Parsed command line application arguments
diff --git a/example/ipsec_api/odp_ipsec.c b/example/ipsec_api/odp_ipsec.c
index 4e1d4b51..f827eeeb 100644
--- a/example/ipsec_api/odp_ipsec.c
+++ b/example/ipsec_api/odp_ipsec.c
@@ -63,7 +63,8 @@ static int create_stream_db_entry(char *input ODP_UNUSED)
}
#endif
-#define MAX_WORKERS 32 /**< maximum number of worker threads */
+/* maximum number of worker threads */
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/**
* Parsed command line application arguments
diff --git a/example/ipsec_offload/odp_ipsec_offload.c b/example/ipsec_offload/odp_ipsec_offload.c
index 492740c6..63c8f126 100644
--- a/example/ipsec_offload/odp_ipsec_offload.c
+++ b/example/ipsec_offload/odp_ipsec_offload.c
@@ -45,7 +45,8 @@
#include <odp_ipsec_offload_fwd_db.h>
#include <odp_ipsec_offload_cache.h>
-#define MAX_WORKERS 32 /**< maximum number of worker threads */
+/* maximum number of worker threads */
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/**
* Parsed command line application arguments
diff --git a/example/l3fwd/odp_l3fwd.c b/example/l3fwd/odp_l3fwd.c
index c4b62341..34e2bfce 100644
--- a/example/l3fwd/odp_l3fwd.c
+++ b/example/l3fwd/odp_l3fwd.c
@@ -23,7 +23,7 @@
#define POOL_SEG_LEN 1856
#define MAX_PKT_BURST 32
-#define MAX_NB_WORKER 32
+#define MAX_NB_WORKER (ODP_THREAD_COUNT_MAX - 1)
#define MAX_NB_PKTIO 32
#define MAX_NB_QUEUE 32
#define MAX_NB_QCONFS 1024
diff --git a/example/packet/odp_pktio.c b/example/packet/odp_pktio.c
index 999eceb5..7755efcb 100644
--- a/example/packet/odp_pktio.c
+++ b/example/packet/odp_pktio.c
@@ -18,7 +18,7 @@
/** @def MAX_WORKERS
* @brief Maximum number of worker threads
*/
-#define MAX_WORKERS 32
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/** @def SHM_PKT_POOL_SIZE
* @brief Size of the shared memory block
diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c
index fd8df6eb..18771ea4 100644
--- a/example/switch/odp_switch.c
+++ b/example/switch/odp_switch.c
@@ -14,7 +14,7 @@
#include <odp/helper/odph_api.h>
/** Maximum number of worker threads */
-#define MAX_WORKERS 32
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/** Size of the shared memory block */
#define SHM_PKT_POOL_SIZE 8192
diff --git a/example/timer/odp_timer_test.c b/example/timer/odp_timer_test.c
index 115c6a6d..9e431b47 100644
--- a/example/timer/odp_timer_test.c
+++ b/example/timer/odp_timer_test.c
@@ -19,8 +19,8 @@
/* GNU lib C */
#include <getopt.h>
-
-#define MAX_WORKERS 32 /**< Max worker threads */
+/* Max worker threads */
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
#define NUM_TMOS 10000 /**< Number of timers */
#define WAIT_NUM 10 /**< Max tries to rx last tmo per worker */
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
diff --git a/test/performance/odp_l2fwd.c b/test/performance/odp_l2fwd.c
index fa6507cf..16336392 100644
--- a/test/performance/odp_l2fwd.c
+++ b/test/performance/odp_l2fwd.c
@@ -25,7 +25,7 @@
#include <odp/helper/odph_api.h>
/* Maximum number of worker threads */
-#define MAX_WORKERS 32
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/* Size of the shared memory block */
#define POOL_PKT_NUM (16 * 1024)
diff --git a/test/performance/odp_pktio_ordered.c b/test/performance/odp_pktio_ordered.c
index 4c1b4260..e884d38a 100644
--- a/test/performance/odp_pktio_ordered.c
+++ b/test/performance/odp_pktio_ordered.c
@@ -79,7 +79,7 @@
#define MAX_NUM_PKT (8 * 1024)
/** Maximum number of worker threads */
-#define MAX_WORKERS 64
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
/** Buffer size of the packet pool buffer in bytes*/
#define PKT_POOL_BUF_SIZE 1856
diff --git a/test/performance/odp_pktio_perf.c b/test/performance/odp_pktio_perf.c
index 41886997..7ddf8250 100644
--- a/test/performance/odp_pktio_perf.c
+++ b/test/performance/odp_pktio_perf.c
@@ -39,7 +39,7 @@
#define PKT_BUF_NUM (32 * 1024)
#define MAX_NUM_IFACES 2
#define TEST_HDR_MAGIC 0x92749451
-#define MAX_WORKERS 128
+#define MAX_WORKERS (ODP_THREAD_COUNT_MAX - 1)
#define BATCH_LEN_MAX 32
/* Packet rate at which to start when using binary search */
commit 7c72d611d8d568358d4a7849057e42708cbb10c3
Author: Matias Elo <matias.elo(a)nokia.com>
Date: Thu Jun 28 15:59:34 2018 +0300
example: use min number of workers by default
Use minimum worker count by default in all example applications.
Signed-off-by: Matias Elo <matias.elo(a)nokia.com>
Reviewed-by: Bogdan Pricope <bogdan.pricope(a)linaro.org>
Reviewed-by: Bill Fischofer <bill.fischofer(a)linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org>
diff --git a/example/classifier/odp_classifier.c b/example/classifier/odp_classifier.c
index 3afe7645..cdcb35bb 100644
--- a/example/classifier/odp_classifier.c
+++ b/example/classifier/odp_classifier.c
@@ -70,7 +70,7 @@ typedef struct {
int policy_count; /**< global policy count */
int appl_mode; /**< application mode */
odp_atomic_u64_t total_packets; /**< total received packets */
- int cpu_count; /**< Number of CPUs to use */
+ unsigned int cpu_count; /**< Number of CPUs to use */
uint32_t time; /**< Number of seconds to run */
char *if_name; /**< pointer to interface names */
} appl_args_t;
@@ -519,9 +519,8 @@ int main(int argc, char *argv[])
/* Print both system and application information */
print_info(NO_PATH(argv[0]), args);
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (args->cpu_count)
+ if (args->cpu_count && args->cpu_count < MAX_WORKERS)
num_workers = args->cpu_count;
/* Get default worker cpumask */
@@ -807,6 +806,8 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
/* let helper collect its own arguments (e.g. --odph_proc) */
argc = odph_parse_options(argc, argv);
+ appl_args->cpu_count = 1; /* Use one worker by default */
+
while (1) {
opt = getopt_long(argc, argv, shortopts,
longopts, &long_index);
@@ -919,8 +920,7 @@ static void usage(char *progname)
"<mask bits> PMR mask bits to be applied on the PMR term value\n"
"\n"
"Optional OPTIONS\n"
- " -c, --count <number> CPU count.\n"
- " default: CPU core count.\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
"\n"
" -m, --mode 0: Packet Drop mode. Received packets will be dropped\n"
" !0: Packet ICMP mode. Received packets will be sent back\n"
diff --git a/example/generator/odp_generator.c b/example/generator/odp_generator.c
index 1a6bb911..706c071a 100644
--- a/example/generator/odp_generator.c
+++ b/example/generator/odp_generator.c
@@ -1169,9 +1169,7 @@ int main(int argc, char *argv[])
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &args->appl);
- /* Default to max number of workers, unless user specified number of
- * workers or cpumask */
- num_workers = MAX_WORKERS;
+ num_workers = 1;
num_workers = odp_cpumask_default_worker(&cpumask, num_workers);
if (args->appl.num_workers) {
@@ -1580,6 +1578,7 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
appl_args->dstport_end = 0;
appl_args->csum = 0;
appl_args->sched = 0;
+ appl_args->num_workers = -1;
while (1) {
opt = getopt_long(argc, argv, shortopts, longopts, &long_index);
@@ -1596,9 +1595,11 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
num_workers = odp_cpumask_default_worker(&cpumask, 0);
odp_cpumask_and(&cpumask_and, &cpumask_args, &cpumask);
if (odp_cpumask_count(&cpumask_and) <
- odp_cpumask_count(&cpumask_args)) {
+ odp_cpumask_count(&cpumask_args) ||
+ odp_cpumask_count(&cpumask_args) > MAX_WORKERS) {
EXAMPLE_ERR("Wrong cpu mask, max cpu's:%d\n",
- num_workers);
+ num_workers < MAX_WORKERS ?
+ num_workers : MAX_WORKERS);
exit(EXIT_FAILURE);
}
break;
@@ -1748,6 +1749,12 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
}
}
+ if (appl_args->num_workers < 0)
+ appl_args->num_workers = 0;
+ else if (appl_args->num_workers == 0 ||
+ appl_args->num_workers > MAX_WORKERS)
+ appl_args->num_workers = MAX_WORKERS;
+
if (appl_args->if_count == 0 || appl_args->mode == -1) {
usage(argv[0]);
exit(EXIT_FAILURE);
@@ -1834,7 +1841,7 @@ static void usage(char *progname)
" -i, --interval wait interval ms between sending each packet\n"
" default is 1000ms. 0 for flood mode\n"
" -w, --workers specify number of workers need to be assigned to application\n"
- " default is to assign all\n"
+ " default is 1, 0 for all available\n"
" -n, --count the number of packets to be send\n"
" -c, --cpumask to set on cores\n"
" -x, --udp_tx_burst size of UDP TX burst\n"
diff --git a/example/ipsec/odp_ipsec.c b/example/ipsec/odp_ipsec.c
index 1b21773e..6371437b 100644
--- a/example/ipsec/odp_ipsec.c
+++ b/example/ipsec/odp_ipsec.c
@@ -69,7 +69,7 @@ static int create_stream_db_entry(char *input ODP_UNUSED)
* Parsed command line application arguments
*/
typedef struct {
- int cpu_count;
+ unsigned int cpu_count;
int if_count; /**< Number of interfaces to be used */
char **if_names; /**< Array of pointers to interface names */
crypto_api_mode_e mode; /**< Crypto API preferred mode */
@@ -1247,9 +1247,8 @@ main(int argc, char *argv[])
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &args->appl);
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (args->appl.cpu_count)
+ if (args->appl.cpu_count && args->appl.cpu_count < MAX_WORKERS)
num_workers = args->appl.cpu_count;
/* Get default worker cpumask */
@@ -1398,6 +1397,7 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
printf("\nParsing command line options\n");
+ appl_args->cpu_count = 1; /* use one worker by default */
appl_args->mode = 0; /* turn off async crypto API by default */
while (!rc) {
@@ -1568,7 +1568,7 @@ static void usage(char *progname)
" -a 192.168.111.2:192.168.222.2:md5:201:a731649644c5dee92cbd9c2e7e188ee6\n"
"\n"
"Optional OPTIONS\n"
- " -c, --count <number> CPU count.\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
" -h, --help Display help and exit.\n"
" environment variables: ODP_IPSEC_USE_POLL_QUEUES\n"
" to enable use of poll queues instead of scheduled (default)\n"
diff --git a/example/ipsec_api/odp_ipsec.c b/example/ipsec_api/odp_ipsec.c
index 6142011b..4e1d4b51 100644
--- a/example/ipsec_api/odp_ipsec.c
+++ b/example/ipsec_api/odp_ipsec.c
@@ -69,7 +69,7 @@ static int create_stream_db_entry(char *input ODP_UNUSED)
* Parsed command line application arguments
*/
typedef struct {
- int cpu_count;
+ unsigned int cpu_count;
int if_count; /**< Number of interfaces to be used */
char **if_names; /**< Array of pointers to interface names */
odp_ipsec_op_mode_t mode; /**< IPsec operation mode */
@@ -945,9 +945,8 @@ main(int argc, char *argv[])
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &args->appl);
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (args->appl.cpu_count)
+ if (args->appl.cpu_count && args->appl.cpu_count < MAX_WORKERS)
num_workers = args->appl.cpu_count;
/* Get default worker cpumask */
@@ -1095,6 +1094,8 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
/* let helper collect its own arguments (e.g. --odph_proc) */
argc = odph_parse_options(argc, argv);
+ appl_args->cpu_count = 1; /* use one worker by default */
+
printf("\nParsing command line options\n");
while (!rc) {
@@ -1268,7 +1269,7 @@ static void usage(char *progname)
" -a 192.168.111.2:192.168.222.2:md5:201:a731649644c5dee92cbd9c2e7e188ee6\n"
"\n"
"Optional OPTIONS\n"
- " -c, --count <number> CPU count.\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
" -h, --help Display help and exit.\n"
" environment variables: ODP_IPSEC_USE_POLL_QUEUES\n"
" to enable use of poll queues instead of scheduled (default)\n"
diff --git a/example/ipsec_offload/odp_ipsec_offload.c b/example/ipsec_offload/odp_ipsec_offload.c
index 890de682..492740c6 100644
--- a/example/ipsec_offload/odp_ipsec_offload.c
+++ b/example/ipsec_offload/odp_ipsec_offload.c
@@ -51,7 +51,7 @@
* Parsed command line application arguments
*/
typedef struct {
- int cpu_count;
+ unsigned int cpu_count;
int flows;
int if_count; /**< Number of interfaces to be used */
char **if_names; /**< Array of pointers to interface names */
@@ -558,9 +558,8 @@ main(int argc, char *argv[])
if (odp_ipsec_config(&config))
EXAMPLE_ABORT("Error: IPSec not configured.\n");
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (args->appl.cpu_count && args->appl.cpu_count <= MAX_WORKERS)
+ if (args->appl.cpu_count && args->appl.cpu_count < MAX_WORKERS)
num_workers = args->appl.cpu_count;
/*
@@ -661,6 +660,7 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
{NULL, 0, NULL, 0}
};
+ appl_args->cpu_count = 1; /* use one worker by default */
appl_args->flows = 1;
appl_args->queue_type = ODP_SCHED_SYNC_ATOMIC;
@@ -842,7 +842,7 @@ static void usage(char *progname)
"\n"
"Optional OPTIONS\n"
" -f, --flows <number> routes count.\n"
- " -c, --count <number> CPU count.\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
" -q specify the queue type\n"
" 0: ODP_SCHED_SYNC_PARALLEL\n"
" 1: ODP_SCHED_SYNC_ATOMIC\n"
diff --git a/example/l3fwd/odp_l3fwd.c b/example/l3fwd/odp_l3fwd.c
index b12348cc..c4b62341 100644
--- a/example/l3fwd/odp_l3fwd.c
+++ b/example/l3fwd/odp_l3fwd.c
@@ -71,9 +71,9 @@ typedef struct {
char *if_names[MAX_NB_PKTIO];
int if_count;
char *route_str[MAX_NB_ROUTE];
- int worker_count;
+ unsigned int worker_count;
struct l3fwd_qconf_s qconf_config[MAX_NB_QCONFS];
- int qconf_count;
+ unsigned int qconf_count;
uint32_t duration; /* seconds to run */
uint8_t hash_mode; /* 1:hash, 0:lpm */
uint8_t dest_mac_changed[MAX_NB_PKTIO]; /* 1: dest mac from cmdline */
@@ -490,7 +490,7 @@ static void print_usage(char *progname)
" -d, --duration Seconds to run and print stats\n"
" optional, default as 0, run forever\n"
" -t, --thread Number of threads to do forwarding\n"
- " optional, default as availbe worker cpu count\n"
+ " 0=all available, default=1\n"
" -q, --queue Configure rx queue(s) for port\n"
" optional, format: [(port, queue, thread),...]\n"
" for example: -q '(0, 0, 1),(1,0,2)'\n"
@@ -507,7 +507,8 @@ static void parse_cmdline_args(int argc, char *argv[], app_args_t *args)
int long_index;
char *token, *local;
size_t len, route_index = 0;
- int i, mem_failure = 0;
+ int mem_failure = 0;
+ unsigned int i;
static struct option longopts[] = {
{"interface", required_argument, NULL, 'i'}, /* return 'i' */
@@ -521,6 +522,8 @@ static void parse_cmdline_args(int argc, char *argv[], app_args_t *args)
{NULL, 0, NULL, 0}
};
+ args->worker_count = 1; /* use one worker by default */
+
while (1) {
opt = getopt_long(argc, argv, "+s:t:d:i:r:q:e:h",
longopts, &long_index);
@@ -679,8 +682,8 @@ static void print_info(char *progname, app_args_t *args)
*/
static void setup_worker_qconf(app_args_t *args)
{
- int nb_worker, if_count, pktio;
- int i, j, rxq_idx;
+ int j, rxq_idx, pktio;
+ unsigned int i, nb_worker, if_count;
struct thread_arg_s *arg;
struct l3fwd_pktio_s *port;
uint8_t queue_mask[MAX_NB_PKTIO][MAX_NB_QUEUE];
@@ -841,7 +844,8 @@ static void setup_worker_qconf(app_args_t *args)
static void print_qconf_table(app_args_t *args)
{
- int i, j, k, qid, if_idx;
+ unsigned int i;
+ int j, k, qid, if_idx;
char buf[32];
struct thread_arg_s *thr_arg;
@@ -1038,9 +1042,8 @@ int main(int argc, char **argv)
setup_fwd_db();
dump_fwd_db();
- /* Dicide available workers */
nb_worker = MAX_NB_WORKER;
- if (args->worker_count)
+ if (args->worker_count && args->worker_count < MAX_NB_WORKER)
nb_worker = args->worker_count;
nb_worker = odp_cpumask_default_worker(&cpumask, nb_worker);
args->worker_count = nb_worker;
diff --git a/example/packet/odp_pktio.c b/example/packet/odp_pktio.c
index fcce92b1..999eceb5 100644
--- a/example/packet/odp_pktio.c
+++ b/example/packet/odp_pktio.c
@@ -63,7 +63,7 @@
* Parsed command line application arguments
*/
typedef struct {
- int cpu_count; /**< Number of CPUs to use */
+ unsigned int cpu_count; /**< Number of CPUs to use */
int if_count; /**< Number of interfaces to be used */
char **if_names; /**< Array of pointers to interface names */
int mode; /**< Packet IO mode */
@@ -376,9 +376,8 @@ int main(int argc, char *argv[])
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &args->appl);
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (args->appl.cpu_count)
+ if (args->appl.cpu_count && args->appl.cpu_count < MAX_WORKERS)
num_workers = args->appl.cpu_count;
/* Get default worker cpumask */
@@ -572,6 +571,7 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
/* let helper collect its own arguments (e.g. --odph_proc) */
argc = odph_parse_options(argc, argv);
+ appl_args->cpu_count = 1; /* use one worker by default */
appl_args->mode = APPL_MODE_PKT_SCHED;
appl_args->time = 0; /**< loop forever */
@@ -712,7 +712,7 @@ static void usage(char *progname)
" -i, --interface Eth interfaces (comma-separated, no spaces)\n"
"\n"
"Optional OPTIONS\n"
- " -c, --count <number> CPU count.\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
" -t, --time <seconds> Number of seconds to run.\n"
" -m, --mode 0: Receive and send directly (no queues)\n"
" 1: Receive and send via queues.\n"
diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c
index 26fcbbcc..fd8df6eb 100644
--- a/example/switch/odp_switch.c
+++ b/example/switch/odp_switch.c
@@ -52,7 +52,7 @@ typedef union {
* Parsed command line application arguments
*/
typedef struct {
- int cpu_count; /**< Number of CPUs to be used */
+ unsigned int cpu_count; /**< Number of CPUs to be used */
unsigned if_count; /**< Number of interfaces to be used */
int num_workers; /**< Number of worker threads */
char **if_names; /**< Array of pointers to interface names */
@@ -725,7 +725,7 @@ static void usage(char *progname)
" Interface count min 2, max %i\n"
"\n"
"Optional OPTIONS:\n"
- " -c, --count <number> CPU count.\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
" -t, --time <number> Time in seconds to run.\n"
" -a, --accuracy <number> Statistics print interval in seconds\n"
" (default is 10 second).\n"
@@ -762,6 +762,7 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
/* let helper collect its own arguments (e.g. --odph_proc) */
argc = odph_parse_options(argc, argv);
+ appl_args->cpu_count = 1; /* use one worker by default */
appl_args->time = 0; /* loop forever if time to run is 0 */
appl_args->accuracy = 10; /* get and print pps stats second */
@@ -916,9 +917,8 @@ int main(int argc, char **argv)
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (gbl_args->appl.cpu_count)
+ if (gbl_args->appl.cpu_count && gbl_args->appl.cpu_count < MAX_WORKERS)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
diff --git a/example/timer/odp_timer_test.c b/example/timer/odp_timer_test.c
index 45eea792..115c6a6d 100644
--- a/example/timer/odp_timer_test.c
+++ b/example/timer/odp_timer_test.c
@@ -27,7 +27,7 @@
/** Test arguments */
typedef struct {
- int cpu_count; /**< CPU count*/
+ unsigned int cpu_count; /**< CPU count*/
int resolution_us; /**< Timeout resolution in usec*/
int min_us; /**< Minimum timeout in usec*/
int max_us; /**< Maximum timeout in usec*/
@@ -237,7 +237,7 @@ static void print_usage(void)
{
printf("\n\nUsage: ./odp_example [options]\n");
printf("Options:\n");
- printf(" -c, --count <number> CPU count\n");
+ printf(" -c, --count <number> CPU count, 0=all available, default=1\n");
printf(" -r, --resolution <us> timeout resolution in usec\n");
printf(" -m, --min <us> minimum timeout in usec\n");
printf(" -x, --max <us> maximum timeout in usec\n");
@@ -280,7 +280,7 @@ static void parse_args(int argc, char *argv[], test_args_t *args)
/* defaults */
odp_timer_capability(ODP_CLOCK_CPU, &timer_capa);
- args->cpu_count = 0; /* all CPU's */
+ args->cpu_count = 1;
args->resolution_us = MAX(10000,
timer_capa.highest_res_ns /
ODP_TIME_USEC_IN_NS);
@@ -391,9 +391,8 @@ int main(int argc, char *argv[])
memset(thread_tbl, 0, sizeof(thread_tbl));
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (gbls->args.cpu_count)
+ if (gbls->args.cpu_count && gbls->args.cpu_count < MAX_WORKERS)
num_workers = gbls->args.cpu_count;
/* Get default worker cpumask */
diff --git a/test/performance/odp_l2fwd.c b/test/performance/odp_l2fwd.c
index ff14ab2f..fa6507cf 100644
--- a/test/performance/odp_l2fwd.c
+++ b/test/performance/odp_l2fwd.c
@@ -75,7 +75,7 @@ static inline int sched_mode(pktin_mode_t in_mode)
*/
typedef struct {
int extra_check; /* Some extra checks have been enabled */
- int cpu_count;
+ unsigned int cpu_count;
int if_count; /* Number of interfaces to be used */
int addr_count; /* Number of dst addresses to be used */
int num_workers; /* Number of worker threads */
@@ -1125,7 +1125,7 @@ static void usage(char *progname)
" -o, --out_mode <arg> Packet output mode\n"
" 0: Direct mode: PKTOUT_MODE_DIRECT (default)\n"
" 1: Queue mode: PKTOUT_MODE_QUEUE\n"
- " -c, --count <num> CPU count.\n"
+ " -c, --count <num> CPU count, 0=all available, default=1\n"
" -t, --time <sec> Time in seconds to run.\n"
" -a, --accuracy <sec> Time in seconds get print statistics\n"
" (default is 1 second).\n"
@@ -1188,6 +1188,7 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
appl_args->time = 0; /* loop forever if time to run is 0 */
appl_args->accuracy = 1; /* get and print pps stats second */
+ appl_args->cpu_count = 1; /* use one worker by default */
appl_args->dst_change = 1; /* change eth dst address by default */
appl_args->src_change = 1; /* change eth src address by default */
appl_args->num_groups = 0; /* use default group */
@@ -1492,9 +1493,8 @@ int main(int argc, char *argv[])
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (gbl_args->appl.cpu_count)
+ if (gbl_args->appl.cpu_count && gbl_args->appl.cpu_count < MAX_WORKERS)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
diff --git a/test/performance/odp_pktio_ordered.c b/test/performance/odp_pktio_ordered.c
index ec6c4faa..4c1b4260 100644
--- a/test/performance/odp_pktio_ordered.c
+++ b/test/performance/odp_pktio_ordered.c
@@ -134,7 +134,7 @@ typedef enum pktin_mode_t {
* Parsed command line application arguments
*/
typedef struct {
- int cpu_count; /**< CPU count */
+ unsigned int cpu_count; /**< CPU count */
int if_count; /**< Number of interfaces to be used */
int addr_count; /**< Number of dst addresses to be used */
int num_rx_q; /**< Number of input queues per interface */
@@ -826,7 +826,7 @@ static void usage(char *progname)
" -r, --num_rx_q Number of RX queues per interface\n"
" -f, --num_flows Number of packet flows\n"
" -e, --extra_input <number> Number of extra input processing rounds\n"
- " -c, --count <number> CPU count.\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
" -t, --time <number> Time in seconds to run.\n"
" -a, --accuracy <number> Statistics print interval in seconds\n"
" (default is 1 second).\n"
@@ -872,6 +872,7 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
appl_args->time = 0; /* loop forever if time to run is 0 */
appl_args->accuracy = DEF_STATS_INT;
+ appl_args->cpu_count = 1; /* use one worker by default */
appl_args->num_rx_q = DEF_NUM_RX_QUEUES;
appl_args->num_flows = DEF_NUM_FLOWS;
appl_args->extra_rounds = DEF_EXTRA_ROUNDS;
@@ -997,12 +998,6 @@ static void parse_args(int argc, char *argv[], appl_args_t *appl_args)
}
}
- if (appl_args->cpu_count > MAX_WORKERS) {
- printf("Too many workers requested %d, max: %d\n",
- appl_args->cpu_count, MAX_WORKERS);
- exit(EXIT_FAILURE);
- }
-
if (appl_args->num_flows > MAX_FLOWS) {
printf("Too many flows requested %d, max: %d\n",
appl_args->num_flows, MAX_FLOWS);
@@ -1136,9 +1131,8 @@ int main(int argc, char *argv[])
/* Print both system and application information */
print_info(NO_PATH(argv[0]), &gbl_args->appl);
- /* Default to system CPU count unless user specified */
num_workers = MAX_WORKERS;
- if (gbl_args->appl.cpu_count)
+ if (gbl_args->appl.cpu_count && gbl_args->appl.cpu_count < MAX_WORKERS)
num_workers = gbl_args->appl.cpu_count;
/* Get default worker cpumask */
diff --git a/test/performance/odp_pktio_perf.c b/test/performance/odp_pktio_perf.c
index 2791856a..41886997 100644
--- a/test/performance/odp_pktio_perf.c
+++ b/test/performance/odp_pktio_perf.c
@@ -70,7 +70,7 @@
/** Parsed command line application arguments */
typedef struct {
- int cpu_count; /* CPU count */
+ unsigned int cpu_count; /* CPU count */
int num_tx_workers;/* Number of CPUs to use for transmit */
int duration; /* Number of seconds to run each iteration
of the test for */
@@ -918,8 +918,7 @@ static int test_term(void)
static void usage(void)
{
printf("\nUsage: odp_pktio_perf [options]\n\n");
- printf(" -c, --count <number> CPU count\n");
- printf(" default: all available\n");
+ printf(" -c, --count <number> CPU count, 0=all available, default=2\n");
printf(" -t, --txcount <number> Number of CPUs to use for TX\n");
printf(" default: cpu_count+1/2\n");
printf(" -b, --txbatch <length> Number of packets per TX batch\n");
@@ -963,7 +962,7 @@ static void parse_args(int argc, char *argv[], test_args_t *args)
/* let helper collect its own arguments (e.g. --odph_proc) */
argc = odph_parse_options(argc, argv);
- args->cpu_count = 0; /* all CPUs */
+ args->cpu_count = 2;
args->num_tx_workers = 0; /* defaults to cpu_count+1/2 */
args->tx_batch_len = BATCH_LEN_MAX;
args->rx_batch_len = BATCH_LEN_MAX;
diff --git a/test/performance/odp_sched_latency.c b/test/performance/odp_sched_latency.c
index 7e98db18..64a21983 100644
--- a/test/performance/odp_sched_latency.c
+++ b/test/performance/odp_sched_latency.c
@@ -74,7 +74,7 @@ typedef struct {
/** Test arguments */
typedef struct {
- int cpu_count; /**< CPU count */
+ unsigned int cpu_count; /**< CPU count */
odp_schedule_sync_t sync_type; /**< Scheduler sync type */
struct {
int queues; /**< Number of scheduling queues */
@@ -265,7 +265,7 @@ static void print_results(test_globals_t *globals)
test_stat_t total;
test_args_t *args;
uint64_t avg;
- int i, j;
+ unsigned int i, j;
args = &globals->args;
stype = globals->args.sync_type;
@@ -500,7 +500,7 @@ static void usage(void)
"\n"
"Usage: ./odp_sched_latency [options]\n"
"Optional OPTIONS:\n"
- " -c, --count <number> CPU count\n"
+ " -c, --count <number> CPU count, 0=all available, default=1\n"
" -l, --lo-prio-queues <number> Number of low priority scheduled queues\n"
" -t, --hi-prio-queues <number> Number of high priority scheduled queues\n"
" -m, --lo-prio-events-per-queue <number> Number of events per low priority queue\n"
@@ -552,6 +552,7 @@ static void parse_args(int argc, char *argv[], test_args_t *args)
/* Let helper collect its own arguments (e.g. --odph_proc) */
argc = odph_parse_options(argc, argv);
+ args->cpu_count = 1;
args->sync_type = ODP_SCHED_SYNC_PARALLEL;
args->sample_per_prio = SAMPLE_EVENT_PER_PRIO;
args->prio[LO_PRIO].queues = LO_PRIO_QUEUES;
diff --git a/test/performance/odp_scheduling.c b/test/performance/odp_scheduling.c
index d2fbf894..3b75f635 100644
--- a/test/performance/odp_scheduling.c
+++ b/test/performance/odp_scheduling.c
@@ -51,7 +51,7 @@ typedef struct {
/** Test arguments */
typedef struct {
- int cpu_count; /**< CPU count */
+ unsigned int cpu_count; /**< CPU count */
int fairness; /**< Check fairness */
} test_args_t;
@@ -735,7 +735,7 @@ static void print_usage(void)
{
printf("\n\nUsage: ./odp_example [options]\n");
printf("Options:\n");
- printf(" -c, --count <number> CPU count, 0=all available, default=0\n");
+ printf(" -c, --count <number> CPU count, 0=all available, default=1\n");
printf(" -h, --help this help\n");
printf(" -f, --fair collect fairness statistics\n");
printf("\n\n");
@@ -765,6 +765,8 @@ static void parse_args(int argc, char *argv[], test_args_t *args)
/* let helper collect its own arguments (e.g. --odph_proc) */
argc = odph_parse_options(argc, argv);
+ args->cpu_count = 1; /* use one worker by default */
+
while (1) {
opt = getopt_long(argc, argv, shortopts, longopts, &long_index);
-----------------------------------------------------------------------
Summary of changes:
example/classifier/odp_classifier.c | 12 ++++++------
example/generator/odp_generator.c | 22 +++++++++++++++-------
example/ipsec/odp_ipsec.c | 11 ++++++-----
example/ipsec_api/odp_ipsec.c | 12 +++++++-----
example/ipsec_offload/odp_ipsec_offload.c | 11 ++++++-----
example/l3fwd/odp_l3fwd.c | 23 +++++++++++++----------
example/packet/odp_pktio.c | 10 +++++-----
example/switch/odp_switch.c | 10 +++++-----
example/timer/odp_timer_test.c | 13 ++++++-------
test/performance/odp_l2fwd.c | 10 +++++-----
test/performance/odp_pktio_ordered.c | 16 +++++-----------
test/performance/odp_pktio_perf.c | 9 ++++-----
test/performance/odp_sched_latency.c | 7 ++++---
test/performance/odp_scheduling.c | 6 ++++--
14 files changed, 91 insertions(+), 81 deletions(-)
hooks/post-receive
--
8 years, 1 month
- 1
- 0