- Acc - mailweb.openeuler.org

[PATCH v2 0/8] ce instruction for SM4
by Qi Tao 20 Mar '24

20 Mar '24

*** BLURB HERE *** Qi Tao (2): cipher: add support for SM4(ECB) algorithm in CE instruction cipher: fix sm4 ce code defect Wenkai Lin (2): cipher: add support for SM4 CBC and CTR modes in CE instruction uadk: fix calloc zero size problem Yang Shen (3): uadk/cipher: isa_ce - support SM4 cbc_cts mode uadk/cipher: isa_ce - fix memcpy overwrite uadk/cipher: isa - fix code style Yuzeng Zhuang (1): cipher: add support for SM4 CFB and XTS modes in CE instruction Makefile.am | 5 +- drv/isa_ce_sm4.c | 472 +++++++++ drv/isa_ce_sm4.h | 62 ++ drv/isa_ce_sm4_armv8.S | 2296 ++++++++++++++++++++++++++++++++++++++++ wd_cipher.c | 4 +- 5 files changed, 2835 insertions(+), 4 deletions(-) create mode 100644 drv/isa_ce_sm4.c create mode 100644 drv/isa_ce_sm4.h create mode 100644 drv/isa_ce_sm4_armv8.S -- 2.33.0

1 8

[PATCH 8/8] uadk/cipher: isa - fix code style
by Qi Tao 19 Mar '24

19 Mar '24

From: Yang Shen <shenyang39(a)huawei.com> Code the cbc_cts mode as openssl code style. Signed-off-by: Yang Shen <shenyang39(a)huawei.com> --- drv/isa_ce_sm4_armv8.S | 201 +++++++++++++++++++---------------------- 1 file changed, 94 insertions(+), 107 deletions(-) diff --git a/drv/isa_ce_sm4_armv8.S b/drv/isa_ce_sm4_armv8.S index 2f9477a..6ebf39b 100644 --- a/drv/isa_ce_sm4_armv8.S +++ b/drv/isa_ce_sm4_armv8.S @@ -24,11 +24,6 @@ .inst 0xce60c800 | (.L\vm << 16) | (.L\vn << 5) | .L\vd .endm -.macro adr_l, dst, sym - adrp \dst, \sym - add \dst, \dst, :lo12:\sym -.endm - .text .align 6 .Lck: @@ -517,63 +512,62 @@ sm4_v8_cbc_encrypt: .align 5 sm4_v8_cbc_cts_encrypt: AARCH64_VALID_CALL_TARGET - ld1 {v24.16b-v27.16b}, [x3], #64; - ld1 {v28.16b-v31.16b}, [x3]; - - sub x5, x2, #16 - - ld1 {v20.16b}, [x4] - - ld1 {v0.16b}, [x0] - eor v20.16b, v20.16b, v0.16b - rev32 v20.16b, v20.16b; - sm4e v20.4s, v24.4s; - sm4e v20.4s, v25.4s; - sm4e v20.4s, v26.4s; - sm4e v20.4s, v27.4s; - sm4e v20.4s, v28.4s; - sm4e v20.4s, v29.4s; - sm4e v20.4s, v30.4s; - sm4e v20.4s, v31.4s; - rev64 v20.4s, v20.4s; - ext v20.16b, v20.16b, v20.16b, #8; - rev32 v20.16b, v20.16b; + ld1 {v0.4s,v1.4s,v2.4s,v3.4s}, [x3], #64 + ld1 {v4.4s,v5.4s,v6.4s,v7.4s}, [x3] + sub x5, x2, #16 + + ld1 {v8.4s}, [x4] + + ld1 {v10.4s}, [x0] + eor v8.16b, v8.16b, v10.16b + rev32 v8.16b, v8.16b; + sm4e v8.4s, v0.4s; + sm4e v8.4s, v1.4s; + sm4e v8.4s, v2.4s; + sm4e v8.4s, v3.4s; + sm4e v8.4s, v4.4s; + sm4e v8.4s, v5.4s; + sm4e v8.4s, v6.4s; + sm4e v8.4s, v7.4s; + rev64 v8.4s, v8.4s; + ext v8.16b, v8.16b, v8.16b, #8; + rev32 v8.16b, v8.16b; /* load permute table */ - adr x6, .Lcts_permute_table - add x7, x6, #32 - add x6, x6, x5 - sub x7, x7, x5 - ld1 {v3.16b}, [x6] - ld1 {v4.16b}, [x7] + adr x6, .cts_permute_table + add x7, x6, #32 + add x6, x6, x5 + sub x7, x7, x5 + ld1 {v13.4s}, [x6] + ld1 {v14.4s}, [x7] /* overlapping loads */ - add x0, x0, x5 - ld1 {v1.16b}, [x0] + add x0, x0, x5 + ld1 {v11.4s}, [x0] /* create Cn from En-1 */ - tbl v0.16b, {v20.16b}, v3.16b + tbl v10.16b, {v8.16b}, v13.16b /* padding Pn with zeros */ - tbl v1.16b, {v1.16b}, v4.16b - - eor v1.16b, v1.16b, v20.16b - rev32 v1.16b, v1.16b; - sm4e v1.4s, v24.4s; - sm4e v1.4s, v25.4s; - sm4e v1.4s, v26.4s; - sm4e v1.4s, v27.4s; - sm4e v1.4s, v28.4s; - sm4e v1.4s, v29.4s; - sm4e v1.4s, v30.4s; - sm4e v1.4s, v31.4s; - rev64 v1.4s, v1.4s; - ext v1.16b, v1.16b, v1.16b, #8; - rev32 v1.16b, v1.16b; + tbl v11.16b, {v11.16b}, v14.16b + + eor v11.16b, v11.16b, v8.16b + rev32 v11.16b, v11.16b; + sm4e v11.4s, v0.4s; + sm4e v11.4s, v1.4s; + sm4e v11.4s, v2.4s; + sm4e v11.4s, v3.4s; + sm4e v11.4s, v4.4s; + sm4e v11.4s, v5.4s; + sm4e v11.4s, v6.4s; + sm4e v11.4s, v7.4s; + rev64 v11.4s, v11.4s; + ext v11.16b, v11.16b, v11.16b, #8; + rev32 v11.16b, v11.16b; /* overlapping stores */ - add x5, x1, x5 - st1 {v0.16b}, [x5] - st1 {v1.16b}, [x1] + add x5, x1, x5 + st1 {v10.16b}, [x5] + st1 {v11.16b}, [x1] ret .size sm4_v8_cbc_cts_encrypt,.-sm4_v8_cbc_cts_encrypt @@ -582,76 +576,69 @@ sm4_v8_cbc_cts_encrypt: .type sm4_v8_cbc_cts_decrypt,%function .align 5 sm4_v8_cbc_cts_decrypt: - ld1 {v24.16b-v27.16b}, [x3], #64; - ld1 {v28.16b-v31.16b}, [x3]; + AARCH64_VALID_CALL_TARGET + ld1 {v0.4s,v1.4s,v2.4s,v3.4s}, [x3], #64 + ld1 {v4.4s,v5.4s,v6.4s,v7.4s}, [x3] - sub x5, x2, #16 + sub x5, x2, #16 - ld1 {v20.16b}, [x4] + ld1 {v8.4s}, [x4] /* load permute table */ - adr_l x6, .Lcts_permute_table - add x7, x6, #32 - add x6, x6, x5 - sub x7, x7, x5 - ld1 {v3.16b}, [x6] - ld1 {v4.16b}, [x7] + adr x6, .cts_permute_table + add x7, x6, #32 + add x6, x6, x5 + sub x7, x7, x5 + ld1 {v13.4s}, [x6] + ld1 {v14.4s}, [x7] /* overlapping loads */ - ld1 {v0.16b}, [x0], x5 - ld1 {v1.16b}, [x0] - - rev32 v0.16b, v0.16b; - sm4e v0.4s, v24.4s; - sm4e v0.4s, v25.4s; - sm4e v0.4s, v26.4s; - sm4e v0.4s, v27.4s; - sm4e v0.4s, v28.4s; - sm4e v0.4s, v29.4s; - sm4e v0.4s, v30.4s; - sm4e v0.4s, v31.4s; - rev64 v0.4s, v0.4s; - ext v0.16b, v0.16b, v0.16b, #8; - rev32 v0.16b, v0.16b; + ld1 {v10.16b}, [x0], x5 + ld1 {v11.16b}, [x0] + + rev32 v10.16b, v10.16b; + sm4e v10.4s, v0.4s; + sm4e v10.4s, v1.4s; + sm4e v10.4s, v2.4s; + sm4e v10.4s, v3.4s; + sm4e v10.4s, v4.4s; + sm4e v10.4s, v5.4s; + sm4e v10.4s, v6.4s; + sm4e v10.4s, v7.4s; + rev64 v10.4s, v10.4s; + ext v10.16b, v10.16b, v10.16b, #8; + rev32 v10.16b, v10.16b; /* select the first Ln bytes of Xn to create Pn */ - tbl v2.16b, {v0.16b}, v3.16b - eor v2.16b, v2.16b, v1.16b + tbl v12.16b, {v10.16b}, v13.16b + eor v12.16b, v12.16b, v11.16b /* overwrite the first Ln bytes with Cn to create En-1 */ - tbx v0.16b, {v1.16b}, v4.16b - - rev32 v0.16b, v0.16b; - sm4e v0.4s, v24.4s; - sm4e v0.4s, v25.4s; - sm4e v0.4s, v26.4s; - sm4e v0.4s, v27.4s; - sm4e v0.4s, v28.4s; - sm4e v0.4s, v29.4s; - sm4e v0.4s, v30.4s; - sm4e v0.4s, v31.4s; - rev64 v0.4s, v0.4s; - ext v0.16b, v0.16b, v0.16b, #8; - rev32 v0.16b, v0.16b; - - eor v0.16b, v0.16b, v20.16b + tbx v10.16b, {v11.16b}, v14.16b + + rev32 v10.16b, v10.16b; + sm4e v10.4s, v0.4s; + sm4e v10.4s, v1.4s; + sm4e v10.4s, v2.4s; + sm4e v10.4s, v3.4s; + sm4e v10.4s, v4.4s; + sm4e v10.4s, v5.4s; + sm4e v10.4s, v6.4s; + sm4e v10.4s, v7.4s; + rev64 v10.4s, v10.4s; + ext v10.16b, v10.16b, v10.16b, #8; + rev32 v10.16b, v10.16b; + + eor v10.16b, v10.16b, v8.16b /* overlapping stores */ - add x5, x1, x5 - st1 {v2.16b}, [x5] - st1 {v0.16b}, [x1] + add x5, x1, x5 + st1 {v12.16b}, [x5] + st1 {v10.16b}, [x1] ret .size sm4_v8_cbc_cts_decrypt,.-sm4_v8_cbc_cts_decrypt -.Lcts_permute_table: - .byte 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff - .byte 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff - .byte 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 - .byte 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf - .byte 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff - .byte 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff - .globl sm4_v8_ecb_encrypt .type sm4_v8_ecb_encrypt,%function .align 5 -- 2.33.0

1 0

[PATCH 0/8] add support for CE instruction
by Qi Tao 19 Mar '24

19 Mar '24

*** BLURB HERE *** Qi Tao (2): cipher: add support for SM4(ECB) algorithm in CE instruction cipher: fix sm4 ce code defect Wenkai Lin (2): cipher: add support for SM4 CBC and CTR modes in CE instruction uadk: fix calloc zero size problem Yang Shen (3): uadk/cipher: isa_ce - support SM4 cbc_cts mode uadk/cipher: isa_ce - fix memcpy overwrite uadk/cipher: isa - fix code style Yuzeng Zhuang (1): cipher: add support for SM4 CFB and XTS modes in CE instruction Makefile.am | 5 +- drv/isa_ce_sm4.c | 473 +++++++++ drv/isa_ce_sm4.h | 62 ++ drv/isa_ce_sm4_armv8.S | 2296 ++++++++++++++++++++++++++++++++++++++++ wd_cipher.c | 4 +- wd_util.c | 5 + 6 files changed, 2841 insertions(+), 4 deletions(-) create mode 100644 drv/isa_ce_sm4.c create mode 100644 drv/isa_ce_sm4.h create mode 100644 drv/isa_ce_sm4_armv8.S -- 2.33.0

1 8

[PATCH 1/2] uadk/digest: modify spelling errors
by Zhiqi Song 15 Mar '24

15 Mar '24

Modify spelling errors related to digest stream mode. Signed-off-by: Zhiqi Song <songzhiqi1(a)huawei.com> --- drv/hash_mb/hash_mb.c | 4 ++-- drv/hisi_sec.c | 8 ++++---- drv/isa_ce_sm3.c | 4 ++-- include/drv/wd_digest_drv.h | 6 +++--- v1/test/hisi_sec_test/test_hisi_sec.c | 4 ++-- v1/test/hisi_sec_test_sgl/test_hisi_sec_sgl.c | 4 ++-- wd_digest.c | 2 +- 7 files changed, 16 insertions(+), 16 deletions(-) diff --git a/drv/hash_mb/hash_mb.c b/drv/hash_mb/hash_mb.c index 0f27c11..4750062 100644 --- a/drv/hash_mb/hash_mb.c +++ b/drv/hash_mb/hash_mb.c @@ -406,7 +406,7 @@ static int hash_do_partial(struct hash_mb_poll_queue *poll_queue, int ret = WD_SUCCESS; switch (bd_type) { - case HASH_FRIST_BLOCK: + case HASH_FIRST_BLOCK: ret = hash_first_block_process(d_msg, job, poll_queue->ops->iv_bytes); break; case HASH_MIDDLE_BLOCK: @@ -434,7 +434,7 @@ static void hash_mb_init_iv(struct hash_mb_poll_queue *poll_queue, job->opad.opad_size = 0; switch (bd_type) { - case HASH_FRIST_BLOCK: + case HASH_FIRST_BLOCK: memcpy(job->result_digest, poll_queue->ops->iv_data, poll_queue->ops->iv_bytes); if (d_msg->mode != WD_DIGEST_HMAC) return; diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c index 2eaac51..e66fb00 100644 --- a/drv/hisi_sec.c +++ b/drv/hisi_sec.c @@ -1536,7 +1536,7 @@ static int fill_digest_long_hash(handle_t h_qp, struct wd_digest_msg *msg, if (ret) return ret; - if (block_type == HASH_FRIST_BLOCK) { + if (block_type == HASH_FIRST_BLOCK) { /* Long hash first */ sqe->ai_apd_cs = AI_GEN_INNER; sqe->ai_apd_cs |= AUTHPAD_NOPAD << AUTHPAD_OFFSET; @@ -1618,7 +1618,7 @@ static int digest_bd2_type_check(struct wd_digest_msg *msg) enum hash_block_type type = get_hash_block_type(msg); /* Long hash first and middle bd */ - if (type == HASH_FRIST_BLOCK || type == HASH_MIDDLE_BLOCK) { + if (type == HASH_FIRST_BLOCK || type == HASH_MIDDLE_BLOCK) { WD_ERR("hardware v2 not supports 0 size in long hash!\n"); return -WD_EINVAL; } @@ -1636,7 +1636,7 @@ static int digest_bd3_type_check(struct wd_digest_msg *msg) { enum hash_block_type type = get_hash_block_type(msg); /* Long hash first and middle bd */ - if (type == HASH_FRIST_BLOCK || type == HASH_MIDDLE_BLOCK) { + if (type == HASH_FIRST_BLOCK || type == HASH_MIDDLE_BLOCK) { WD_ERR("invalid: hardware v3 not supports 0 size in long hash!\n"); return -WD_EINVAL; } @@ -1889,7 +1889,7 @@ static int fill_digest_long_hash3(handle_t h_qp, struct wd_digest_msg *msg, if (ret) return ret; - if (block_type == HASH_FRIST_BLOCK) { + if (block_type == HASH_FIRST_BLOCK) { /* Long hash first */ sqe->auth_mac_key |= AI_GEN_INNER << SEC_AI_GEN_OFFSET_V3; sqe->stream_scene.stream_auth_pad = AUTHPAD_NOPAD; diff --git a/drv/isa_ce_sm3.c b/drv/isa_ce_sm3.c index 2789a08..5fc7acc 100644 --- a/drv/isa_ce_sm3.c +++ b/drv/isa_ce_sm3.c @@ -188,7 +188,7 @@ static int do_sm3_ce(struct wd_digest_msg *msg, __u8 *out_digest) sm3_ce_update(&sctx, data, data_len, sm3_ce_block_compress); sm3_ce_final(&sctx, out_digest, sm3_ce_block_compress); break; - case HASH_FRIST_BLOCK: + case HASH_FIRST_BLOCK: sm3_ce_init(&sctx); sm3_ce_update(&sctx, data, data_len, sm3_ce_block_compress); trans_output_result(out_digest, sctx.word_reg); @@ -306,7 +306,7 @@ static int do_hmac_sm3_ce(struct wd_digest_msg *msg, __u8 *out_hmac) sm3_ce_hmac_update(&hctx, data, data_len); sm3_ce_hmac_final(&hctx, out_hmac); break; - case HASH_FRIST_BLOCK: + case HASH_FIRST_BLOCK: sm3_ce_hmac_init(&hctx, key, key_len); sm3_ce_hmac_update(&hctx, data, data_len); trans_output_result(out_hmac, hctx.sctx.word_reg); diff --git a/include/drv/wd_digest_drv.h b/include/drv/wd_digest_drv.h index 7d86b65..5e3e821 100644 --- a/include/drv/wd_digest_drv.h +++ b/include/drv/wd_digest_drv.h @@ -12,7 +12,7 @@ extern "C" { #endif enum hash_block_type { - HASH_FRIST_BLOCK, + HASH_FIRST_BLOCK, HASH_MIDDLE_BLOCK, HASH_END_BLOCK, HASH_SINGLE_BLOCK, @@ -66,13 +66,13 @@ static inline enum hash_block_type get_hash_block_type(struct wd_digest_msg *msg { /* * [has_next , iv_bytes] - * [ 1 , 0 ] = long hash(frist bd) + * [ 1 , 0 ] = long hash(first bd) * [ 1 , 1 ] = long hash(middle bd) * [ 0 , 1 ] = long hash(end bd) * [ 0 , 0 ] = block hash(single bd) */ if (msg->has_next && !msg->iv_bytes) - return HASH_FRIST_BLOCK; + return HASH_FIRST_BLOCK; else if (msg->has_next && msg->iv_bytes) return HASH_MIDDLE_BLOCK; else if (!msg->has_next && msg->iv_bytes) diff --git a/v1/test/hisi_sec_test/test_hisi_sec.c b/v1/test/hisi_sec_test/test_hisi_sec.c index be4ee9d..05c91ad 100644 --- a/v1/test/hisi_sec_test/test_hisi_sec.c +++ b/v1/test/hisi_sec_test/test_hisi_sec.c @@ -1463,7 +1463,7 @@ static int sec_cipher_async_test(int thread_num, __u64 lcore_mask, SEC_TST_PRT("%s(): create pool fail!\n", __func__); return -ENOMEM; } - /* frist create the async poll thread! */ + /* first create the async poll thread! */ test_thrds_data[0].pool = pool; test_thrds_data[0].q = &q; test_thrds_data[0].thread_num = 1; @@ -2070,7 +2070,7 @@ static int sec_aead_async_test(int thd_num, __u64 lcore_mask, SEC_TST_PRT("%s(): create pool fail!\n", __func__); return -ENOMEM; } - /* frist create the async poll thread! */ + /* first create the async poll thread! */ test_thrds_data[0].pool = pool; test_thrds_data[0].q = &q; test_thrds_data[0].thread_num = 1; diff --git a/v1/test/hisi_sec_test_sgl/test_hisi_sec_sgl.c b/v1/test/hisi_sec_test_sgl/test_hisi_sec_sgl.c index b7513d1..ba5cdfa 100644 --- a/v1/test/hisi_sec_test_sgl/test_hisi_sec_sgl.c +++ b/v1/test/hisi_sec_test_sgl/test_hisi_sec_sgl.c @@ -1733,7 +1733,7 @@ static int sec_cipher_async_test(int thread_num, __u64 lcore_mask, SEC_TST_PRT("%s(): create pool fail!\n", __func__); return -ENOMEM; } - /* frist create the async poll thread! */ + /* first create the async poll thread! */ test_thrds_data[0].pool = pool; test_thrds_data[0].q = &q; test_thrds_data[0].thread_num = 1; @@ -2640,7 +2640,7 @@ static int sec_aead_async_test(int thd_num, __u64 lcore_mask, return -ENOMEM; } - /* frist create the async poll thread! */ + /* first create the async poll thread! */ test_thrds_data[0].pool = pool; test_thrds_data[0].q = &q; test_thrds_data[0].thread_num = 1; diff --git a/wd_digest.c b/wd_digest.c index dfe709b..4832de8 100644 --- a/wd_digest.c +++ b/wd_digest.c @@ -55,7 +55,7 @@ struct wd_digest_stream_data { /* Total data length for stream mode */ __u64 long_data_len; /* - * Notify the stream message state, zero is frist message, + * Notify the stream message state, zero is first message, * non-zero is middle or final message. */ int msg_state; -- 2.30.0

1 0

[PATCH 0/4] Support sm3 ce instruction
by Zhiqi Song 12 Mar '24

12 Mar '24

1. Support sync sm3 ce instruction. 2. Some cleanup and bugfix. Zhiqi Song (4): uadk: remove redundant header file in makefile uadk/isa-ce: support sm3 ce instruction uadk: fix control range of environmemt variable uadk/util: use default sched_type for instruction task Makefile.am | 20 +- configure.ac | 3 + drv/isa_ce_sm3.c | 401 ++++++++++++++++++++ drv/isa_ce_sm3.h | 86 +++++ drv/isa_ce_sm3_armv8.S | 765 ++++++++++++++++++++++++++++++++++++++ include/drv/arm_arch_ce.h | 199 ++++++++++ include/wd_alg.h | 43 +++ include/wd_sched.h | 2 +- wd_alg.c | 32 +- wd_digest.c | 2 +- wd_sched.c | 2 +- wd_util.c | 92 ++++- 12 files changed, 1619 insertions(+), 28 deletions(-) create mode 100644 drv/isa_ce_sm3.c create mode 100644 drv/isa_ce_sm3.h create mode 100644 drv/isa_ce_sm3_armv8.S create mode 100644 include/drv/arm_arch_ce.h -- 2.33.0

1 4

[PATCH] uadk: add zlibwrapper test
by Wenkai Lin 11 Mar '24

11 Mar '24

add zlibwrapper sample test Signed-off-by: Wenkai Lin <linwenkai6(a)hisilicon.com> --- test/zlibwrapper.c | 410 +++++++++++++++++++++++++++++++++++++++++++++ test/zlibwrapper.h | 15 ++ 2 files changed, 425 insertions(+) create mode 100644 test/zlibwrapper.c create mode 100644 test/zlibwrapper.h diff --git a/test/zlibwrapper.c b/test/zlibwrapper.c new file mode 100644 index 0000000..20c053f --- /dev/null +++ b/test/zlibwrapper.c @@ -0,0 +1,410 @@ +#include "acc_v2_common.h" +#include "acc_v2_util.h" +#include <assert.h> + +#define RESERVE_MM 1024 +#define SIZE_1K 1024 + +static int stream_chunk = 1024 * 128; + +struct create_comp_data { + int threadid; + long long loop; + int numa_id; + bool sync; + bool use_env; + char *infile; + char *outfile; + char *alg; + enum wd_comp_op_type op; + acc_source_mode src_type; + acc_mem_mode mem_type; + comp_check_type check_type; + + size_t input_size; + size_t output_size; + int count; + int thread_num; + int cmode; + int win_sz; + int win_bs; + int comp_lv; + int debug; + int result; + struct v2_setup_util *util; + handle_t mp, bp; + bool perf_flag; + unsigned long perf; + double ops; +}; + +static int test_uadk_zlib_deflate(z_stream *zstrmp, void *src, size_t src_len, void *dest, + size_t *dst_len, int level, int windowbits) +{ + __u32 chunk = stream_chunk; + z_stream zstrm = {0}; + int ret, flush, have; + + if (zstrmp == NULL) { + zstrmp = &zstrm; + } + ret = wd_deflate_init(&zstrm, level, windowbits); + if (ret) { + LOG(ERR, "fail to init deflate.\n"); + return ret; + } + + zstrm.next_in = src; + do { + if (src_len > chunk) { + zstrm.avail_in = chunk; + src_len -= chunk; + } else { + zstrm.avail_in = src_len; + src_len = 0; + } + + flush = src_len ? Z_SYNC_FLUSH : Z_FINISH; + + /* + * Run wd_deflate() on input until output buffer not full, + * finish compression if all of source has been read in. + */ + do { + zstrm.avail_out = chunk; + zstrm.next_out = dest; + ret = wd_deflate(&zstrm, flush); + if (ret < 0) { + LOG(ERR, "Error: wd_deflate fail, ret = %d", ret); + return ret; + } + have = chunk - zstrm.avail_out; + dest += have; + } while (zstrm.avail_in > 0); + + /* done when last data in file processed */ + } while (flush != Z_FINISH); + + LOG(DBG, "zstrm.total_out is %lld\n", zstrm.total_out); + *dst_len = zstrm.total_out; + + (void)wd_deflate_end(&zstrm); + if (ret != Z_STREAM_END) { + ret = Z_ERRNO; + } else { + ret = Z_OK; + } + return ret; +} + +static int test_uadk_zlib_inflate(z_stream *zstrmp, void *src, size_t src_len, void *dest, + size_t *dst_len, int windowbits) +{ + __u32 chunk = stream_chunk; + z_stream zstrm = {0}; + int ret, have; + + if (zstrmp == NULL) { + zstrmp = &zstrm; + } + ret = wd_inflate_init(&zstrm, windowbits); + if (ret) { + LOG(ERR, "fail to init inflate.\n"); + return ret; + } + + zstrm.next_in = src; + do { + if (src_len > chunk) { + zstrm.avail_in = chunk; + src_len -= chunk; + } else { + zstrm.avail_in = src_len; + src_len = 0; + } + /* + * Run wd_deflate() on input until output buffer not full, + * finish compression if all of source has been read in. + */ + do { + zstrm.avail_out = chunk; + zstrm.next_out = dest; + ret = wd_inflate(&zstrm, Z_SYNC_FLUSH); + if (ret < 0) { + LOG(ERR, "Error: wd_deflate fail, ret = %d", ret); + return ret; + } + have = chunk - zstrm.avail_out; + dest += have; + } while (zstrm.avail_in > 0); + + /* done when last data in file processed */ + } while (ret != Z_STREAM_END); + + LOG(DBG, "zstrm.total_out is %lld\n", zstrm.total_out); + *dst_len = zstrm.total_out; + + (void)wd_inflate_end(&zstrm); + if (ret != Z_STREAM_END) { + ret = Z_ERRNO; + } else { + ret = Z_OK; + } + return ret; +} + +/* report a zlib or i/o error */ +static void zerr(int ret) +{ +} + +static int zlibwrapper_data_process(struct create_comp_data *data) +{ + z_stream zstrm = {0}, *zstrmp; + struct timeval begin_tval; + struct timeval end_tval; + unsigned long Perf = 0; + size_t output_size = 0; + size_t input_size = 0; + int cnt = data->count; + double time_used = 0; + char *output = NULL; + char *input = NULL; + double speed = 0; + double ops = 0; + int ret = AGF; + + input_size = data->input_size; + ret = v2_key_from_random(2, &input, input_size); + if (ret) { + LOG(ERR, "Error: generate_key_from_random failed!\n"); + ret = RSF; + goto err; + } + + if (data->op == WD_DIR_COMPRESS) { + output_size = (input_size * COMPRESS_TIMES) + RESERVE_MM; + } else { + output_size = (input_size * DECOMPRESS_TIMES) + RESERVE_MM; + } + output = malloc(output_size); + if (output == NULL) { + LOG(ERR, "Error: output malloc failed!\n"); + ret = RSF; + goto err; + } + memset(output, 0, output_size); + data->input_size = input_size; + data->output_size = output_size; + gettimeofday(&begin_tval, NULL); + + if (data->use_env) { + zstrmp = &zstrm; + if (data->threadid == 0) { + data->win_bs = ZLIB_MAX_WBITS; + } else if (data->threadid == 1) { + data->win_bs = GZIP_MAX_WBITS; + } else { + data->win_bs = DEFLATE_MAX_WBITS; + } + } else { + zstrmp = NULL; + } + if (data->loop > 0) { + LOG(NTC, "Notice: Start comp loop test.\n"); + while (1) { + if (data->op == WD_DIR_COMPRESS) { + ret = test_uadk_zlib_deflate(zstrmp, input, input_size, output, + &output_size, data->comp_lv, data->win_bs); + } else { + ret = test_uadk_zlib_inflate(zstrmp, input, input_size, output, &output_size, data->win_bs); + } + if (ret != Z_OK) { + zerr(ret); + return ret; + } + cnt++; + if (data->loop > 0) { + gettimeofday(&end_tval, NULL); + time_used = (double)((end_tval.tv_sec - begin_tval.tv_sec) * S_TO_US_TIME + + end_tval.tv_usec - begin_tval.tv_usec); + if (time_used >= data->loop * S_TO_US_TIME) + break; + } + } + } + while (data->count--) { + if (data->op == WD_DIR_COMPRESS) { + ret = test_uadk_zlib_deflate(zstrmp, input, input_size, output, &output_size, data->comp_lv, data->win_bs); + } else { + ret = test_uadk_zlib_inflate(zstrmp, input, input_size, output, &output_size, data->win_bs); + } + if (ret != Z_OK) { + zerr(ret); + return ret; + } + } +err: + data->result = ret; + if (input) { + free(input); + } + if (output) { + free(output); + } + return ret; +} + +static int zlibwrapper_setup(struct create_comp_data *data) +{ + int thread_num = data->thread_num; + unsigned long total_perf = 0; + int i = 0, start_thread = 0; + int debug = data->debug; + double total_ops = 0; + int ret = RSF; + + if (0 == thread_num) { + data->threadid = -1; + data->sync = true; + data->result = 0; + ret = zlibwrapper_data_process(data); + if (0 != ret) { + LOG(ERR, "Error: single process comp compute test failed, ret = %d \n", ret); + return ret; + } + total_perf = data->perf; + total_ops = data->ops; + } else { + LOG(INF, "Info: do multiple threads comp compute test. \n"); + struct create_comp_data thread_data[thread_num]; + pthread_t thread_process[thread_num]; + + for (i = start_thread; i < thread_num; i++) { + memcpy(&thread_data[i], data, sizeof(struct create_comp_data)); + thread_data[i].threadid = i; + thread_data[i].result = 0; + thread_data[i].debug = debug; + ret = pthread_create(&thread_process[i], NULL, (void *)zlibwrapper_data_process, (void *)&thread_data[i]); + if (ret) { + LOG(ERR, "Error: create data process thread failed, ret = %d \n", ret); + ret = THF; + return ret; + } + } + for (i = 0; i < thread_num; i++) { + ret = pthread_join(thread_process[i], NULL); + if (ret) { + LOG(ERR, "Error: join thread[%d] failed, return ret => %d \n", i, ret); + ret = THF; + return ret; + } + } + for (i = start_thread; i < thread_num; i++) { + total_perf += thread_data[i].perf; + total_ops += thread_data[i].ops; + if (0 != thread_data[i].result) { + LOG(ERR, "Error: thread[%d] run failed, return ret => %d \n", i, thread_data[i].result); + ret = THF; + return ret; + } + } + } + PRINTF_PERF(data->alg, thread_num, data->loop, total_perf, total_ops); + + return ret; +} + +int wd_zlibwrapper_test(void *param) +{ + struct acc_v2_common_param *g_acc_param = (struct acc_v2_common_param *)param; + char *infile = g_acc_param->comm_param.infile; + char a[10], b[10], c[10], d[10]; + char fileName[FILE_NAME_LEN]; + struct create_comp_data data; + size_t input_size = 0; + char *src = NULL; + int ret = AGF; + + memset(&data, 0, sizeof(struct create_comp_data)); + + data.comp_lv = WD_COMP_L8; + if (sscanf(g_acc_param->comm_param.alg_mode, "%[^-]-%[^-]-%[^-]-%s", a, b, c, d) == 4) + data.comp_lv = atoi(d); + else if (sscanf(g_acc_param->comm_param.alg_mode, "%[^-]-%[^-]-%s", a, b, c) != 3) { + LOG(ERR, "Error: comp alg_mode invalid \n"); + return AGF; + } + + if (!strcmp(a, "compress")) { + data.op = WD_DIR_COMPRESS; + } else if (!strcmp(a, "decompress")) { + data.op = WD_DIR_DECOMPRESS; + } else { + LOG(ERR, "Error: comp op is compress or decompress ? \n"); + return AGF; + } + if (!strcmp(b, "stream")) + data.cmode = 0; + else if (!strcmp(b, "block")) + LOG(ERR, "Error: zlibwrapper not support block\n"); + else { + LOG(ERR, "Error: comp mode is stream or block ? \n"); + return AGF; + } + + if (data.cmode == 0 && g_acc_param->comm_param.async) { + LOG(ERR, "Error: stream mode is not support async\n"); + return AGF; + } + if (strcmp(c, "4K") == 0) + data.win_sz = WD_COMP_WS_4K; + else if (strcmp(c, "8K") == 0) + data.win_sz = WD_COMP_WS_8K; + else if (strcmp(c, "16K") == 0) + data.win_sz = WD_COMP_WS_16K; + else if (strcmp(c, "24K") == 0) + data.win_sz = WD_COMP_WS_24K; + else if (strcmp(c, "32K") == 0) + data.win_sz = WD_COMP_WS_32K; + else { + LOG(ERR, "Error: windows size?\n"); + return AGF; + } + if (g_acc_param->comm_param.src_mode == SRC_RANDOM) { + if (sscanf(g_acc_param->comm_param.alg_key_size, "%ld", &input_size) != 1) { + LOG(ERR, "Error: comp size format invalid \n"); + return AGF; + } + } else { + LOG(ERR, "Error: comp not support do-openssl\n"); + return AGF; + } + data.input_size = input_size; + LOG (INF, "Info: input_size: %ld\n", data.input_size); + + { + data.alg = g_acc_param->comm_param.alg_name; + data.sync = !g_acc_param->comm_param.async; + data.loop = g_acc_param->comm_param.loop; + data.src_type = g_acc_param->comm_param.src_mode; + data.mem_type = g_acc_param->mem_mode; + data.use_env = g_acc_param->use_env; + data.numa_id = g_acc_param->numa_id; + data.count = g_acc_param->comm_param.count; + data.infile = g_acc_param->comm_param.infile; + data.outfile = g_acc_param->comm_param.outfile; + data.thread_num = g_acc_param->comm_param.thread_num; + data.perf_flag = g_acc_param->comm_param.perf_flag; + data.win_bs = g_acc_param->windowbits; + data.debug = log_lvl; + } + + if (data.use_env) { + data.thread_num = 3; + } + + ret = zlibwrapper_setup(&data); + + return ret; +} diff --git a/test/zlibwrapper.h b/test/zlibwrapper.h new file mode 100644 index 0000000..33395b1 --- /dev/null +++ b/test/zlibwrapper.h @@ -0,0 +1,15 @@ +#ifndef KP_TOOLS_ZLIBWRAPPER_H +#define KP_TOOLS_ZLIBWRAPPER_H + +#include "wd_zlibwrapper.h" + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ +#define FILE_NAME_LEN 500 +#define TOOLS_NAME_LEN 50 +#define ZLIB_MAX_WBITS 15 +#define GZIP_MAX_WBITS 31 +#define DEFLATE_MAX_WBITS -15 + +int wd_zlibwrapper_test(void *param); + +#endif -- 2.33.0

1 0

[PATCH 0/4] Support sm3 ce instruction
by Zhiqi Song 11 Mar '24

11 Mar '24

1. Support sync sm3 ce instruction. 2. Some cleanup and bugfix. Zhiqi Song (4): uadk: remove redundant header file in makefile uadk/isa-ce: support sm3 ce instruction uadk: fix control range of environmemt variable uadk/util: use default sched_type for instruction task Makefile.am | 20 +- configure.ac | 3 + drv/isa_ce_sm3.c | 401 ++++++++++++++++++++ drv/isa_ce_sm3.h | 86 +++++ drv/isa_ce_sm3_armv8.S | 765 ++++++++++++++++++++++++++++++++++++++ include/drv/arm_arch_ce.h | 199 ++++++++++ include/wd_alg.h | 43 +++ include/wd_sched.h | 2 +- wd_alg.c | 32 +- wd_digest.c | 2 +- wd_sched.c | 2 +- wd_util.c | 92 ++++- 12 files changed, 1619 insertions(+), 28 deletions(-) create mode 100644 drv/isa_ce_sm3.c create mode 100644 drv/isa_ce_sm3.h create mode 100644 drv/isa_ce_sm3_armv8.S create mode 100644 include/drv/arm_arch_ce.h -- 2.33.0

1 4

[PATCH 00/11] sync uadk_tool patch to linaro
by Qi Tao 11 Mar '24

11 Mar '24

*** BLURB HERE *** Chenghai Huang (3): uadk tool: fix the logic for counting retransmissions when busy uadk/tools - support the nosva test of a specified device uadk tool: fix the msg pool release bug of async zip benchmark Longfang Liu (1): uadk_tool: fix aead performance test issue Qi Tao (4): uadk_tool: support sm4 ce benchmark test uadk_tool: modify the description of the zip and sec uadk_tool: fix switch-case statement error uadk_tool: fix queue application failure from multiple devices Weili Qian (1): uadk_tool: support sm3/md5 multibuff benchmark test Yang Shen (1): uadk/tools - support designated device testing Zhiqi Song (1): uadk_tool: support sm3 ce benchmark and function test uadk_tool/Makefile.am | 1 + uadk_tool/benchmark/hpre_uadk_benchmark.c | 151 ++++++++-- uadk_tool/benchmark/hpre_wd_benchmark.c | 8 + uadk_tool/benchmark/sec_uadk_benchmark.c | 211 ++++++++++++-- uadk_tool/benchmark/sec_wd_benchmark.c | 26 ++ uadk_tool/benchmark/trng_wd_benchmark.c | 8 + uadk_tool/benchmark/uadk_benchmark.c | 125 +++++--- uadk_tool/benchmark/uadk_benchmark.h | 42 +-- uadk_tool/benchmark/zip_uadk_benchmark.c | 335 +++++++++++++++------- uadk_tool/benchmark/zip_wd_benchmark.c | 40 ++- uadk_tool/test/test_sec.c | 35 ++- 11 files changed, 747 insertions(+), 235 deletions(-) -- 2.33.0

1 11

acclib 例会
by openEuler conference 06 Mar '24

06 Mar '24

您好！ sig-AccLib 邀请您参加 2024-03-20 11:00 召开的Zoom会议会议主题：acclib 例会会议链接：https://us06web.zoom.us/j/82635780668?pwd=n0uTqzYc0RaCmo7X8znzuwworbLYZa.1 会议纪要：https://etherpad.openeuler.org/p/sig-AccLib-meetings 更多资讯尽在：https://www.openeuler.org/zh/ Hello! sig-AccLib invites you to attend the Zoom conference will be held at 2024-03-20 11:00, The subject of the conference is acclib 例会, You can join the meeting at https://us06web.zoom.us/j/82635780668?pwd=n0uTqzYc0RaCmo7X8znzuwworbLYZa.1. Add topics at https://etherpad.openeuler.org/p/sig-AccLib-meetings. More information: https://www.openeuler.org/en/

1 0

[PATCH] uadk: sample - add test case for compression
by Yang Shen 06 Mar '24

06 Mar '24

1. Support test fork. 2. Support test wd_comp_init2. 3. Support test zlibwrapper. Signed-off-by: Yang Shen <shenyang39(a)huawei.com> --- sample/uadk_comp.c | 364 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 353 insertions(+), 11 deletions(-) diff --git a/sample/uadk_comp.c b/sample/uadk_comp.c index 908c7bcb..1d259f0b 100644 --- a/sample/uadk_comp.c +++ b/sample/uadk_comp.c @@ -7,6 +7,7 @@ #include "wd_alg_common.h" #include "wd_comp.h" #include "wd_sched.h" +#include "wd_zlibwrapper.h" #define SCHED_RR_NAME "sched_rr" @@ -19,6 +20,8 @@ #define required_argument 1 #define optional_argument 2 +#define MAX_THREAD 1024 + struct request_config { char algname[MAX_ALG_LEN]; enum wd_comp_alg_type alg; @@ -42,6 +45,11 @@ struct acc_alg_item { int alg; }; +struct comp_sample_data { + int size; + char data[128]; +}; + static struct request_config config = { .complv = WD_COMP_L8, .optype = WD_DIR_COMPRESS, @@ -52,6 +60,8 @@ static struct request_config config = { static struct request_data data; +static pthread_t threads[MAX_THREAD]; + static struct acc_alg_item alg_options[] = { {"zlib", WD_ZLIB}, {"gzip", WD_GZIP}, @@ -60,6 +70,11 @@ static struct acc_alg_item alg_options[] = { {"", WD_COMP_ALG_MAX} }; +static struct comp_sample_data sample_data = { + .size = 20, + .data = "Welcome to use uadk!", +}; + static void cowfail(char *s) { fprintf(stderr, "" @@ -74,6 +89,313 @@ static void cowfail(char *s) "\n", s); } +static void *initthread(void *data) +{ + int ret; + + ret = wd_comp_init2("zlib", 0, TASK_HW); + if (ret) + fprintf(stderr, "%s: something is wrong, ret = %d!", __func__, ret); + + return NULL; +} + +static int test_fork(void) +{ + int ret; + + pthread_create(&threads[0], NULL, initthread, NULL); + + sleep(2); + ret = fork(); + if (ret == 0) + ret = wd_comp_init2("zlib", 0, TASK_HW); + else + ret = pthread_join(threads[0], NULL); + + wd_comp_uninit2(); + + return ret; +} + +static int test_uadk_init2(void) +{ + struct wd_comp_sess_setup setup[2] = {0}; + struct sched_params param[2] = {0}; + struct wd_comp_req req[2] = {0}; + handle_t h_sess[2]; + void *src, *dst; + int ret; + + ret = wd_comp_init2("zlib", 0, TASK_HW); + if (ret) + return ret; + + setup[0].alg_type = WD_ZLIB; + setup[0].op_type = WD_DIR_COMPRESS; + setup[0].comp_lv = 1; + setup[0].win_sz = 1; + param[0].type = WD_DIR_COMPRESS; + setup[0].sched_param = &param[0]; + + h_sess[0] = wd_comp_alloc_sess(&setup[0]); + if (!h_sess[0]) { + fprintf(stderr, "%s fail to alloc comp sess.\n", __func__); + ret = -WD_EINVAL; + goto out_uninit; + } + + setup[1].alg_type = WD_ZLIB; + setup[1].op_type = WD_DIR_DECOMPRESS; + setup[1].comp_lv = 1; + setup[1].win_sz = 1; + param[1].type = WD_DIR_DECOMPRESS; + setup[1].sched_param = &param[1]; + h_sess[1] = wd_comp_alloc_sess(&setup[1]); + if (!h_sess[1]) { + fprintf(stderr, "%s fail to alloc decomp sess.\n", __func__); + ret = -WD_EINVAL; + goto out_free_comp_sess; + } + + src = calloc(1, sizeof(char) * 128); + if (!src) { + ret = -WD_ENOMEM; + goto out_free_decomp_sess; + } + + dst = calloc(1, sizeof(char) * 128); + if (!dst) { + ret = -WD_ENOMEM; + goto out_free_src; + } + + req[0].src = sample_data.data; + req[0].src_len = sample_data.size; + req[0].op_type = WD_DIR_COMPRESS; + req[0].dst = dst; + req[0].dst_len = 128; + + ret = wd_do_comp_sync(h_sess[0], &req[0]); + if (ret) + goto out_free_dst; + + req[1].src = dst; + req[1].src_len = req[0].dst_len; + req[1].op_type = WD_DIR_DECOMPRESS; + req[1].dst = src; + req[1].dst_len = 128; + + ret = wd_do_comp_sync(h_sess[1], &req[1]); + + ret = strcmp(sample_data.data, src); + if (ret) + fprintf(stderr, "decompress fail\n"); + else + fprintf(stderr, "good\n"); + +out_free_dst: + free(dst); +out_free_src: + free(src); +out_free_decomp_sess: + wd_comp_free_sess(h_sess[1]); +out_free_comp_sess: + wd_comp_free_sess(h_sess[0]); +out_uninit: + wd_comp_uninit2(); + return ret; +} + +static int test_uadk_zlib_deflate(void *src, int src_len, void *dest, int dst_len) +{ + __u32 chunk = 128 * 1024; + z_stream zstrm = {0}; + int ret, flush, have; + + ret = wd_comp_init2("zlib", 0, TASK_HW); + if (ret) { + fprintf(stderr, "%s fail to init wd_comp.\n", __func__); + return ret; + } + + ret = wd_deflate_init(&zstrm, 0, 15); + if (ret) { + fprintf(stderr, "%s fail to init deflate.\n", __func__); + return ret; + } + + zstrm.next_in = src; + do { + if (src_len > chunk) { + zstrm.avail_in = chunk; + src_len -= chunk; + } else { + zstrm.avail_in = src_len; + src_len = 0; + } + + flush = src_len ? Z_SYNC_FLUSH : Z_FINISH; + + /* + * Run wd_deflate() on input until output buffer not full, + * finish compression if all of source has been read in. + */ + do { + zstrm.avail_out = chunk; + zstrm.next_out = dest; + ret = wd_deflate(&zstrm, flush); + have = chunk - zstrm.avail_out; + dest += have; + } while (zstrm.avail_in > 0); + + /* done when last data in file processed */ + } while (flush != Z_FINISH); + + ret = ret == Z_STREAM_END ? zstrm.total_out : ret; + + (void)wd_deflate_end(&zstrm); + + return ret; +} + +static int test_uadk_zlib_inflate(void *src, int src_len, void *dest, int dst_len) +{ + __u32 chunk = 128 * 1024; + // __u32 chunk = 1024 * 1024 * 2; + z_stream zstrm = {0}; + int ret, have; + + ret = wd_inflate_init(&zstrm, 15); + if (ret) { + fprintf(stderr, "%s fail to init inflate.\n", __func__); + return ret; + } + + zstrm.next_in = src; + do { + if (src_len > chunk) { + zstrm.avail_in = chunk; + src_len -= chunk; + } else { + zstrm.avail_in = src_len; + src_len = 0; + } + /* + * Run wd_deflate() on input until output buffer not full, + * finish compression if all of source has been read in. + */ + do { + zstrm.avail_out = chunk; + zstrm.next_out = dest; + ret = wd_inflate(&zstrm, Z_SYNC_FLUSH); + have = chunk - zstrm.avail_out; + dest += have; + } while (zstrm.avail_in > 0); + + /* done when last data in file processed */ + } while (ret != Z_STREAM_END); + + ret = ret == Z_STREAM_END ? zstrm.total_out : ret; + + (void)wd_inflate_end(&zstrm); + + return ret; +} + +static int test_uadk_zlib(void) +{ + void *src, *dst, *src2; + FILE *source = stdin; + FILE *dest = stdout; + int ret, fd, sz; + struct stat s; + + fd = fileno(source); + ret = fstat(fd, &s); + if (ret < 0) { + fprintf(stderr, "%s fstat error!\n", __func__); + return ret; + } + + src = calloc(1, sizeof(char) * s.st_size); + if (!src) { + fprintf(stderr, "%s calloc error!\n", __func__); + return -WD_ENOMEM; + } + + src2 = calloc(1, sizeof(char) * s.st_size * 2); + if (!src2) { + fprintf(stderr, "%s calloc2 error!\n", __func__); + ret = -WD_ENOMEM; + goto free_src; + } + + dst = calloc(1, sizeof(char) * s.st_size * 2); + if (!dst) { + fprintf(stderr, "%s calloc error!\n", __func__); + ret = -WD_ENOMEM; + goto free_src2; + } + + sz = fread(src, 1, s.st_size, source); + if (sz != s.st_size) { + fprintf(stderr, "%s read file sz != file.size!\n", __func__); + ret = -WD_EINVAL; + goto free_dst; + } + + ret = test_uadk_zlib_deflate(src, sz, dst, sz * 2); + if (ret < 0) { + fprintf(stderr, "%s do deflate fail ret %d\n", __func__, ret); + goto free_dst; + } + + ret = fwrite(dst, 1, ret, dest); + if (ret < 0) + fprintf(stderr, "%s file write fail ret %d\n", __func__, ret); + + ret = test_uadk_zlib_inflate(dst, ret, src2, sz * 2); + if (ret < 0) { + fprintf(stderr, "%s do inflate fail ret %d\n", __func__, ret); + goto free_dst; + } + + ret = memcmp(src, src2, sz); + if (!ret) + fprintf(stderr, "%s good!\n", __func__); + +free_dst: + free(dst); +free_src2: + free(src2); +free_src: + free(src); + return ret; +} + +static int test_func(int test_mode) +{ + int ret; + + switch (test_mode) { + case 0: + ret = test_fork(); + break; + case 1: + ret = test_uadk_init2(); + break; + case 2: + ret = test_uadk_zlib(); + break; + default: + ret = -WD_EINVAL; + break; + } + + return ret; +} + static struct uacce_dev_list* get_dev_list(char *alg_name) { struct uacce_dev_list *list, *p, *head = NULL, *prev = NULL; @@ -147,7 +469,7 @@ static struct wd_sched *uadk_comp_sched_init(void) sched = wd_sched_rr_alloc(SCHED_POLICY_RR, 2, 2, lib_poll_func); if (!sched) { - printf("%s fail to alloc sched.\n", __func__); + fprintf(stderr, "%s fail to alloc sched.\n", __func__); return NULL; } sched->name = SCHED_RR_NAME; @@ -388,31 +710,31 @@ static int operation(FILE *source, FILE *dest) ret = uadk_comp_ctx_init(); if (ret) { - fprintf(stderr, "%s fail to init ctx!\n", __func__); + fprintf(stderr, "%s fail to init ctx! %d\n", __func__, ret); return ret; } ret = uadk_comp_sess_init(); if (ret) { - fprintf(stderr, "%s fail to init sess!\n", __func__); + fprintf(stderr, "%s fail to init sess! %d\n", __func__, ret); goto out_ctx_uninit; } ret = uadk_comp_request_init(source); if (ret) { - fprintf(stderr, "%s fail to init request!\n", __func__); + fprintf(stderr, "%s fail to init request! %d\n", __func__, ret); goto out_sess_uninit; } ret = uadk_do_comp(); if (ret) { - fprintf(stderr, "%s fail to do request!\n", __func__); + fprintf(stderr, "%s fail to do request! %d\n", __func__, ret); goto out_sess_uninit; } ret = uadk_comp_write_file(dest); if (ret) - fprintf(stderr, "%s fail to write result!\n", __func__); + fprintf(stderr, "%s fail to write result! %d\n", __func__, ret); uadk_comp_request_uninit(); @@ -445,9 +767,10 @@ static void print_help(void) int main(int argc, char *argv[]) { + int ret, c, test_mode; int option_index = 0; int help = 0; - int ret, c; + int test = 0; static struct option long_options[] = { {"help", no_argument, 0, 0}, @@ -455,6 +778,9 @@ int main(int argc, char *argv[]) {"complv", required_argument, 0, 2}, {"optype", required_argument, 0, 3}, {"winsize", required_argument, 0, 4}, + {"fork", no_argument, 0, 5}, + {"init2", no_argument, 0, 6}, + {"zlib", no_argument, 0, 7}, {0, 0, 0, 0} }; @@ -470,8 +796,8 @@ int main(int argc, char *argv[]) case 1: config.list = get_dev_list(optarg); if (!config.list) { - cowfail("Can't find your algorithm!\n"); help = 1; + cowfail("Can't find your algorithm!\n"); } else { strcpy(config.algname, optarg); } @@ -485,9 +811,21 @@ int main(int argc, char *argv[]) case 4: config.winsize = strtol(optarg, NULL, 0); break; + case 5: + test = 1; + test_mode = 0; + break; + case 6: + test = 1; + test_mode = 1; + break; + case 7: + test = 1; + test_mode = 2; + break; default: help = 1; - cowfail("bad input test parameter!\n"); + cowfail("Bad input test parameter!\n"); break; } } @@ -497,9 +835,13 @@ int main(int argc, char *argv[]) exit(-1); } - ret = operation(stdin, stdout); + if (test == 1) + ret = test_func(test_mode); + else + ret = operation(stdin, stdout); + if (ret) - cowfail("So sad for we do something wrong!\n"); + cowfail("So sad for someting wrong!\n"); return ret; } -- 2.33.0

1 0

2025

2024

2023

2022

Acc