From: Weili Qian <qianweili(a)huawei.com>
The internal asynchronous polling interface is not
used in any scenario, remove it.
Upstream: YES
Feature or Bugfix：Bugfix
AR:AR20230706877890
DTS:DTS2026042322013
Signed-off-by: Weili Qian <qianweili(a)huawei.com>
---
include/wd_aead.h | 3 +-
include/wd_cipher.h | 3 +-
include/wd_comp.h | 3 +-
include/wd_digest.h | 3 +-
include/wd_ecc.h | 3 +-
include/wd_rsa.h | 3 +-
include/wd_util.h | 37 ----
wd_aead.c | 24 +--
wd_cipher.c | 24 +--
wd_comp.c | 28 +--
wd_dh.c | 24 +--
wd_digest.c | 24 +--
wd_ecc.c | 24 +--
wd_rsa.c | 24 +--
wd_util.c | 418 +-------------------------------------------
15 files changed, 70 insertions(+), 575 deletions(-)
diff --git a/include/wd_aead.h b/include/wd_aead.h
index 4b5095f..3585c86 100644
--- a/include/wd_aead.h
+++ b/include/wd_aead.h
@@ -254,7 +254,8 @@ void wd_aead_ctx_num_uninit(void);
* @type: operation type.
* @mode: 0: sync mode, 1: async mode
* @num: return ctx num.
- * @is_enable return enable inner poll flag.
+ * @is_enable: return enable inner poll flag, inner poll is not
+ * supported, and is_enable will always be 0.
*
* If the current algorithm library does not require the type parameter,
* the type parameter is invalid. The function returns 0 to indicate that
diff --git a/include/wd_cipher.h b/include/wd_cipher.h
index a6f8be1..383d315 100644
--- a/include/wd_cipher.h
+++ b/include/wd_cipher.h
@@ -218,7 +218,8 @@ void wd_cipher_ctx_num_uninit(void);
* @type: operation type.
* @mode: 0: sync mode, 1: async mode
* @num: return ctx num.
- * @is_enable return enable inner poll flag.
+ * @is_enable: return enable inner poll flag, inner poll is not
+ * supported, and is_enable will always be 0.
*/
int wd_cipher_get_env_param(__u32 node, __u32 type, __u32 mode,
__u32 *num, __u8 *is_enable);
diff --git a/include/wd_comp.h b/include/wd_comp.h
index 8579f93..890799a 100644
--- a/include/wd_comp.h
+++ b/include/wd_comp.h
@@ -252,7 +252,8 @@ void wd_comp_ctx_num_uninit(void);
* @type: operation type.
* @mode: 0: sync mode, 1: async mode
* @num: return ctx num.
- * @is_enable return enable inner poll flag.
+ * @is_enable: return enable inner poll flag, inner poll is not
+ * supported, and is_enable will always be 0.
*
* If the current algorithm library does not require the type parameter,
* the type parameter is invalid. The function returns 0 to indicate that
diff --git a/include/wd_digest.h b/include/wd_digest.h
index 42a95db..410c7f9 100644
--- a/include/wd_digest.h
+++ b/include/wd_digest.h
@@ -278,7 +278,8 @@ void wd_digest_ctx_num_uninit(void);
* @type: operation type.
* @mode: 0: sync mode, 1: async mode
* @num: return ctx num.
- * @is_enable return enable inner poll flag.
+ * @is_enable: return enable inner poll flag, inner poll is not
+ * supported, and is_enable will always be 0.
*/
int wd_digest_get_env_param(__u32 node, __u32 type, __u32 mode,
__u32 *num, __u8 *is_enable);
diff --git a/include/wd_ecc.h b/include/wd_ecc.h
index 18c1c0d..d868951 100644
--- a/include/wd_ecc.h
+++ b/include/wd_ecc.h
@@ -548,7 +548,8 @@ void wd_ecc_ctx_num_uninit(void);
* @type: operation type.
* @mode: 0: sync mode, 1: async mode
* @num: return ctx num.
- * @is_enable return enable inner poll flag.
+ * @is_enable: return enable inner poll flag, inner poll is not
+ * supported, and is_enable will always be 0.
*/
int wd_ecc_get_env_param(__u32 node, __u32 type, __u32 mode,
__u32 *num, __u8 *is_enable);
diff --git a/include/wd_rsa.h b/include/wd_rsa.h
index 9c91432..b0ead0a 100644
--- a/include/wd_rsa.h
+++ b/include/wd_rsa.h
@@ -239,7 +239,8 @@ void wd_rsa_ctx_num_uninit(void);
* @type: operation type.
* @mode: 0: sync mode, 1: async mode
* @num: return ctx num.
- * @is_enable return enable inner poll flag.
+ * @is_enable: return enable inner poll flag, inner poll is not
+ * supported, and is_enable will always be 0.
*/
int wd_rsa_get_env_param(__u32 node, __u32 type, __u32 mode,
__u32 *num, __u8 *is_enable);
diff --git a/include/wd_util.h b/include/wd_util.h
index 42270d9..c24c554 100644
--- a/include/wd_util.h
+++ b/include/wd_util.h
@@ -78,16 +78,10 @@ struct wd_env_config_per_numa {
/* Resource begin */
struct uacce_dev *dev;
int dev_num;
- /* This can be made statically currently */
- unsigned long async_poll_num;
- void *async_task_queue_array;
};
struct wd_env_config {
struct wd_env_config_per_numa *config_per_numa;
- /* Let's make it as a gobal config, not per numa */
- bool enable_internal_poll;
-
/* resource config */
struct wd_sched *sched;
bool internal_sched;
@@ -273,28 +267,6 @@ int wd_check_datalist(struct wd_datalist *head, __u64 size);
*/
int wd_parse_ctx_num(struct wd_env_config *config, const char *s);
-/*
- * wd_parse_async_poll_en() - Parse async polling thread related environment
- * variable and store it.
- * @config: Pointer of wd_env_config which is used to store environment
- * variable information.
- * @s: Related environment variable string.
- *
- * More information, please see docs/wd_environment_variable.
- */
-int wd_parse_async_poll_en(struct wd_env_config *config, const char *s);
-
-/*
- * wd_parse_async_poll_num() - Parse async polling thread related environment
- * variable and store it.
- * @config: Pointer of wd_env_config which is used to store environment
- * variable information.
- * @s: Related environment variable string.
- *
- * More information, please see docs/wd_environment_variable.
- */
-int wd_parse_async_poll_num(struct wd_env_config *config, const char *s);
-
/*
* wd_alg_env_init() - Init wd algorithm environment variable configurations.
* This is a help function which can be used by specific
@@ -323,15 +295,6 @@ int wd_alg_env_init(struct wd_env_config *env_config,
void wd_alg_env_uninit(struct wd_env_config *env_config,
const struct wd_alg_ops *ops);
-/*
- * wd_add_task_to_async_queue() - Add an async request to its related async
- * task queue.
- * @config: Pointer of wd_env_config which is used to store environment
- * variable information.
- * @idx: Index of ctx in config.
- */
-int wd_add_task_to_async_queue(struct wd_env_config *config, __u32 idx);
-
/*
* dump_env_info() - dump wd algorithm ctx info.
* @config: Pointer of wd_env_config which is used to store environment
diff --git a/wd_aead.c b/wd_aead.c
index 748bf95..3e993a1 100644
--- a/wd_aead.c
+++ b/wd_aead.c
@@ -957,9 +957,6 @@ int wd_do_aead_async(handle_t h_sess, struct wd_aead_req *req)
}
wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx);
- ret = wd_add_task_to_async_queue(&wd_aead_env_config, idx);
- if (ret)
- goto fail_with_msg;
return 0;
@@ -1039,15 +1036,10 @@ int wd_aead_poll(__u32 expt, __u32 *count)
return sched->poll_policy(h_ctx, expt, count);
}
-static const struct wd_config_variable table[] = {
- { .name = "WD_AEAD_CTX_NUM",
- .def_val = "sync:2@0,async:2@0",
- .parse_fn = wd_parse_ctx_num
- },
- { .name = "WD_AEAD_ASYNC_POLL_EN",
- .def_val = "0",
- .parse_fn = wd_parse_async_poll_en
- }
+static const struct wd_config_variable table = {
+ .name = "WD_AEAD_CTX_NUM",
+ .def_val = "sync:2@0,async:2@0",
+ .parse_fn = wd_parse_ctx_num
};
static const struct wd_alg_ops wd_aead_ops = {
@@ -1062,8 +1054,8 @@ int wd_aead_env_init(struct wd_sched *sched)
{
wd_aead_env_config.sched = sched;
- return wd_alg_env_init(&wd_aead_env_config, table,
- &wd_aead_ops, ARRAY_SIZE(table), NULL);
+ return wd_alg_env_init(&wd_aead_env_config, &table,
+ &wd_aead_ops, 1, NULL);
}
void wd_aead_env_uninit(void)
@@ -1080,8 +1072,8 @@ int wd_aead_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode)
if (ret)
return ret;
- return wd_alg_env_init(&wd_aead_env_config, table,
- &wd_aead_ops, ARRAY_SIZE(table), &ctx_attr);
+ return wd_alg_env_init(&wd_aead_env_config, &table,
+ &wd_aead_ops, 1, &ctx_attr);
}
void wd_aead_ctx_num_uninit(void)
diff --git a/wd_cipher.c b/wd_cipher.c
index abedfb3..a4d6c63 100644
--- a/wd_cipher.c
+++ b/wd_cipher.c
@@ -800,9 +800,6 @@ int wd_do_cipher_async(handle_t h_sess, struct wd_cipher_req *req)
}
wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx);
- ret = wd_add_task_to_async_queue(&wd_cipher_env_config, idx);
- if (ret)
- goto fail_with_msg;
return 0;
@@ -883,15 +880,10 @@ int wd_cipher_poll(__u32 expt, __u32 *count)
return sched->poll_policy(h_ctx, expt, count);
}
-static const struct wd_config_variable table[] = {
- { .name = "WD_CIPHER_CTX_NUM",
- .def_val = "sync:2@0,async:2@0",
- .parse_fn = wd_parse_ctx_num
- },
- { .name = "WD_CIPHER_ASYNC_POLL_EN",
- .def_val = "0",
- .parse_fn = wd_parse_async_poll_en
- }
+static const struct wd_config_variable table = {
+ .name = "WD_CIPHER_CTX_NUM",
+ .def_val = "sync:2@0,async:2@0",
+ .parse_fn = wd_parse_ctx_num
};
static const struct wd_alg_ops wd_cipher_ops = {
@@ -906,8 +898,8 @@ int wd_cipher_env_init(struct wd_sched *sched)
{
wd_cipher_env_config.sched = sched;
- return wd_alg_env_init(&wd_cipher_env_config, table,
- &wd_cipher_ops, ARRAY_SIZE(table), NULL);
+ return wd_alg_env_init(&wd_cipher_env_config, &table,
+ &wd_cipher_ops, 1, NULL);
}
void wd_cipher_env_uninit(void)
@@ -924,8 +916,8 @@ int wd_cipher_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode)
if (ret)
return ret;
- return wd_alg_env_init(&wd_cipher_env_config, table,
- &wd_cipher_ops, ARRAY_SIZE(table), &ctx_attr);
+ return wd_alg_env_init(&wd_cipher_env_config, &table,
+ &wd_cipher_ops, 1, &ctx_attr);
}
void wd_cipher_ctx_num_uninit(void)
diff --git a/wd_comp.c b/wd_comp.c
index 247eadd..84fb079 100644
--- a/wd_comp.c
+++ b/wd_comp.c
@@ -880,9 +880,6 @@ int wd_do_comp_async(handle_t h_sess, struct wd_comp_req *req)
}
wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx);
- ret = wd_add_task_to_async_queue(&wd_comp_env_config, idx);
- if (unlikely(ret))
- goto fail_with_msg;
return 0;
@@ -908,19 +905,10 @@ int wd_comp_poll(__u32 expt, __u32 *count)
return sched->poll_policy(h_sched_ctx, expt, count);
}
-static const struct wd_config_variable table[] = {
- { .name = "WD_COMP_CTX_NUM",
- .def_val = "sync-comp:1@0,sync-decomp:1@0,async-comp:1@0,async-decomp:1@0",
- .parse_fn = wd_parse_ctx_num
- },
- { .name = "WD_COMP_ASYNC_POLL_EN",
- .def_val = "0",
- .parse_fn = wd_parse_async_poll_en
- },
- { .name = "WD_COMP_ASYNC_POLL_NUM",
- .def_val = "1@0",
- .parse_fn = wd_parse_async_poll_num
- }
+static const struct wd_config_variable table = {
+ .name = "WD_COMP_CTX_NUM",
+ .def_val = "sync-comp:1@0,sync-decomp:1@0,async-comp:1@0,async-decomp:1@0",
+ .parse_fn = wd_parse_ctx_num
};
static const struct wd_alg_ops wd_comp_ops = {
@@ -935,8 +923,8 @@ int wd_comp_env_init(struct wd_sched *sched)
{
wd_comp_env_config.sched = sched;
- return wd_alg_env_init(&wd_comp_env_config, table,
- &wd_comp_ops, ARRAY_SIZE(table), NULL);
+ return wd_alg_env_init(&wd_comp_env_config, &table,
+ &wd_comp_ops, 1, NULL);
}
void wd_comp_env_uninit(void)
@@ -958,8 +946,8 @@ int wd_comp_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode)
if (ret)
return ret;
- return wd_alg_env_init(&wd_comp_env_config, table,
- &wd_comp_ops, ARRAY_SIZE(table), &ctx_attr);
+ return wd_alg_env_init(&wd_comp_env_config, &table,
+ &wd_comp_ops, 1, &ctx_attr);
}
void wd_comp_ctx_num_uninit(void)
diff --git a/wd_dh.c b/wd_dh.c
index 3395060..7837114 100644
--- a/wd_dh.c
+++ b/wd_dh.c
@@ -441,9 +441,6 @@ int wd_do_dh_async(handle_t sess, struct wd_dh_req *req)
}
wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx);
- ret = wd_add_task_to_async_queue(&wd_dh_env_config, idx);
- if (ret)
- goto fail_with_msg;
return WD_SUCCESS;
@@ -654,15 +651,10 @@ void wd_dh_free_sess(handle_t sess)
free(sess_t);
}
-static const struct wd_config_variable table[] = {
- { .name = "WD_DH_CTX_NUM",
- .def_val = "sync:2@0,async:2@0",
- .parse_fn = wd_parse_ctx_num
- },
- { .name = "WD_DH_ASYNC_POLL_EN",
- .def_val = "0",
- .parse_fn = wd_parse_async_poll_en
- }
+static const struct wd_config_variable table = {
+ .name = "WD_DH_CTX_NUM",
+ .def_val = "sync:2@0,async:2@0",
+ .parse_fn = wd_parse_ctx_num
};
static const struct wd_alg_ops wd_dh_ops = {
@@ -677,8 +669,8 @@ int wd_dh_env_init(struct wd_sched *sched)
{
wd_dh_env_config.sched = sched;
- return wd_alg_env_init(&wd_dh_env_config, table,
- &wd_dh_ops, ARRAY_SIZE(table), NULL);
+ return wd_alg_env_init(&wd_dh_env_config, &table,
+ &wd_dh_ops, 1, NULL);
}
void wd_dh_env_uninit(void)
@@ -695,8 +687,8 @@ int wd_dh_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode)
if (ret)
return ret;
- return wd_alg_env_init(&wd_dh_env_config, table,
- &wd_dh_ops, ARRAY_SIZE(table), &ctx_attr);
+ return wd_alg_env_init(&wd_dh_env_config, &table,
+ &wd_dh_ops, 1, &ctx_attr);
}
void wd_dh_ctx_num_uninit(void)
diff --git a/wd_digest.c b/wd_digest.c
index 8e5bf94..bd3dd05 100644
--- a/wd_digest.c
+++ b/wd_digest.c
@@ -746,9 +746,6 @@ int wd_do_digest_async(handle_t h_sess, struct wd_digest_req *req)
}
wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx);
- ret = wd_add_task_to_async_queue(&wd_digest_env_config, idx);
- if (ret)
- goto fail_with_msg;
return 0;
@@ -830,15 +827,10 @@ int wd_digest_poll(__u32 expt, __u32 *count)
return sched->poll_policy(h_ctx, expt, count);
}
-static const struct wd_config_variable table[] = {
- { .name = "WD_DIGEST_CTX_NUM",
- .def_val = "sync:2@0,async:2@0",
- .parse_fn = wd_parse_ctx_num
- },
- { .name = "WD_DIGEST_ASYNC_POLL_EN",
- .def_val = "0",
- .parse_fn = wd_parse_async_poll_en
- }
+static const struct wd_config_variable table = {
+ .name = "WD_DIGEST_CTX_NUM",
+ .def_val = "sync:2@0,async:2@0",
+ .parse_fn = wd_parse_ctx_num
};
static const struct wd_alg_ops wd_digest_ops = {
@@ -853,8 +845,8 @@ int wd_digest_env_init(struct wd_sched *sched)
{
wd_digest_env_config.sched = sched;
- return wd_alg_env_init(&wd_digest_env_config, table,
- &wd_digest_ops, ARRAY_SIZE(table), NULL);
+ return wd_alg_env_init(&wd_digest_env_config, &table,
+ &wd_digest_ops, 1, NULL);
}
void wd_digest_env_uninit(void)
@@ -871,8 +863,8 @@ int wd_digest_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode)
if (ret)
return ret;
- return wd_alg_env_init(&wd_digest_env_config, table,
- &wd_digest_ops, ARRAY_SIZE(table), &ctx_attr);
+ return wd_alg_env_init(&wd_digest_env_config, &table,
+ &wd_digest_ops, 1, &ctx_attr);
}
void wd_digest_ctx_num_uninit(void)
diff --git a/wd_ecc.c b/wd_ecc.c
index c31495f..4c77a04 100644
--- a/wd_ecc.c
+++ b/wd_ecc.c
@@ -2319,9 +2319,6 @@ int wd_do_ecc_async(handle_t sess, struct wd_ecc_req *req)
}
wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx);
- ret = wd_add_task_to_async_queue(&wd_ecc_env_config, idx);
- if (ret)
- goto fail_with_msg;
return WD_SUCCESS;
@@ -2401,15 +2398,10 @@ int wd_ecc_poll(__u32 expt, __u32 *count)
return wd_ecc_setting.sched.poll_policy(h_sched_sess, expt, count);
}
-static const struct wd_config_variable table[] = {
- { .name = "WD_ECC_CTX_NUM",
- .def_val = "sync:2@0,async:2@0",
- .parse_fn = wd_parse_ctx_num
- },
- { .name = "WD_ECC_ASYNC_POLL_EN",
- .def_val = "0",
- .parse_fn = wd_parse_async_poll_en
- }
+static const struct wd_config_variable table = {
+ .name = "WD_ECC_CTX_NUM",
+ .def_val = "sync:2@0,async:2@0",
+ .parse_fn = wd_parse_ctx_num
};
static const struct wd_alg_ops wd_ecc_ops = {
@@ -2424,8 +2416,8 @@ int wd_ecc_env_init(struct wd_sched *sched)
{
wd_ecc_env_config.sched = sched;
- return wd_alg_env_init(&wd_ecc_env_config, table,
- &wd_ecc_ops, ARRAY_SIZE(table), NULL);
+ return wd_alg_env_init(&wd_ecc_env_config, &table,
+ &wd_ecc_ops, 1, NULL);
}
void wd_ecc_env_uninit(void)
@@ -2442,8 +2434,8 @@ int wd_ecc_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode)
if (ret)
return ret;
- return wd_alg_env_init(&wd_ecc_env_config, table,
- &wd_ecc_ops, ARRAY_SIZE(table), &ctx_attr);
+ return wd_alg_env_init(&wd_ecc_env_config, &table,
+ &wd_ecc_ops, 1, &ctx_attr);
}
void wd_ecc_ctx_num_uninit(void)
diff --git a/wd_rsa.c b/wd_rsa.c
index c020514..2242fed 100644
--- a/wd_rsa.c
+++ b/wd_rsa.c
@@ -502,9 +502,6 @@ int wd_do_rsa_async(handle_t sess, struct wd_rsa_req *req)
}
wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx);
- ret = wd_add_task_to_async_queue(&wd_rsa_env_config, idx);
- if (ret)
- goto fail_with_msg;
return WD_SUCCESS;
@@ -1266,15 +1263,10 @@ void wd_rsa_get_prikey(handle_t sess, struct wd_rsa_prikey **prikey)
*prikey = ((struct wd_rsa_sess *)sess)->prikey;
}
-static const struct wd_config_variable table[] = {
- { .name = "WD_RSA_CTX_NUM",
- .def_val = "sync:2@0,async:2@0",
- .parse_fn = wd_parse_ctx_num
- },
- { .name = "WD_RSA_ASYNC_POLL_EN",
- .def_val = "0",
- .parse_fn = wd_parse_async_poll_en
- }
+static const struct wd_config_variable table = {
+ .name = "WD_RSA_CTX_NUM",
+ .def_val = "sync:2@0,async:2@0",
+ .parse_fn = wd_parse_ctx_num
};
static const struct wd_alg_ops wd_rsa_ops = {
@@ -1289,8 +1281,8 @@ int wd_rsa_env_init(struct wd_sched *sched)
{
wd_rsa_env_config.sched = sched;
- return wd_alg_env_init(&wd_rsa_env_config, table,
- &wd_rsa_ops, ARRAY_SIZE(table), NULL);
+ return wd_alg_env_init(&wd_rsa_env_config, &table,
+ &wd_rsa_ops, 1, NULL);
}
void wd_rsa_env_uninit(void)
@@ -1307,8 +1299,8 @@ int wd_rsa_ctx_num_init(__u32 node, __u32 type, __u32 num, __u8 mode)
if (ret)
return ret;
- return wd_alg_env_init(&wd_rsa_env_config, table,
- &wd_rsa_ops, ARRAY_SIZE(table), &ctx_attr);
+ return wd_alg_env_init(&wd_rsa_env_config, &table,
+ &wd_rsa_ops, 1, &ctx_attr);
}
void wd_rsa_ctx_num_uninit(void)
diff --git a/wd_util.c b/wd_util.c
index f97b558..c174d7c 100644
--- a/wd_util.c
+++ b/wd_util.c
@@ -8,7 +8,6 @@
#include <dirent.h>
#include <dlfcn.h>
#include <pthread.h>
-#include <semaphore.h>
#include <string.h>
#include <ctype.h>
#include "wd_sched.h"
@@ -72,27 +71,6 @@ static const char *wd_env_name[WD_TYPE_MAX] = {
"WD_JOIN_GATHER_CTX_NUM",
};
-struct async_task {
- __u32 idx;
-};
-
-struct async_task_queue {
- struct async_task *head;
- int depth;
- /* the producer offset of task queue */
- int prod;
- /* the consumer offset of task queue */
- int cons;
- int cur_task;
- int left_task;
- int end;
- sem_t empty_sem;
- sem_t full_sem;
- pthread_mutex_t lock;
- pthread_t tid;
- int (*alg_poll_ctx)(__u32, __u32, __u32 *);
-};
-
struct drv_lib_list {
void *dlhandle;
struct drv_lib_list *next;
@@ -784,17 +762,6 @@ static int str_to_bool(const char *s, bool *target)
return 0;
}
-int wd_parse_async_poll_en(struct wd_env_config *config, const char *s)
-{
- int ret;
-
- ret = str_to_bool(s, &config->enable_internal_poll);
- if (ret)
- WD_ERR("failed to parse async poll enable flag(%s)!\n", s);
-
- return ret;
-}
-
static int parse_num_on_numa(const char *s, int *num, int *node)
{
char *sep, *start, *left;
@@ -1036,41 +1003,6 @@ int wd_parse_ctx_num(struct wd_env_config *config, const char *s)
return parse_ctx_num(config, s);
}
-int wd_parse_async_poll_num(struct wd_env_config *config, const char *s)
-{
- struct wd_env_config_per_numa *config_numa;
- char *left, *section, *start;
- int node, poll_num, ret;
-
- if (!config->enable_internal_poll) {
- WD_ERR("internal poll not enabled, skip parse poll number!\n");
- return 0;
- }
-
- start = strdup(s);
- if (!start)
- return -ENOMEM;
-
- left = start;
- while ((section = strsep(&left, ","))) {
- ret = parse_num_on_numa(section, &poll_num, &node);
- if (ret)
- goto out;
- config_numa = wd_get_config_numa(config, node);
- if (!config_numa) {
- ret = -WD_EINVAL;
- goto out;
- }
- config_numa->async_poll_num = poll_num;
- }
-
- free(start);
- return 0;
-out:
- free(start);
- return ret;
-}
-
static int wd_parse_env(struct wd_env_config *config)
{
const struct wd_config_variable *var;
@@ -1119,8 +1051,6 @@ static int wd_parse_ctx_attr(struct wd_env_config *env_config,
/* Use default sched and disable internal poll */
env_config->sched = NULL;
- env_config->enable_internal_poll = 0;
- config_numa->async_poll_num = 0;
return 0;
}
@@ -1348,21 +1278,17 @@ static int wd_init_sched_config(struct wd_env_config *config,
{
struct wd_env_config_per_numa *config_numa;
int i, j, ret, max_node, type_num;
- void *func = NULL;
type_num = config->op_type_num;
max_node = numa_max_node() + 1;
if (max_node <= 0)
return -WD_EINVAL;
- if (!config->enable_internal_poll)
- func = alg_poll_ctx;
-
config->internal_sched = false;
if (!config->sched) {
WD_ERR("no sched is specified, alloc a default sched!\n");
config->sched = wd_sched_rr_alloc(SCHED_POLICY_RR, type_num,
- max_node, func);
+ max_node, alg_poll_ctx);
if (!config->sched)
return -WD_ENOMEM;
@@ -1389,339 +1315,6 @@ err_release_sched:
return ret;
}
-static struct async_task_queue *find_async_queue(struct wd_env_config *config,
- __u32 idx)
-{
- struct wd_env_config_per_numa *config_numa;
- struct wd_ctx_range **ctx_table;
- struct async_task_queue *head;
- unsigned long offset = 0;
- __u32 i, num = 0;
-
- FOREACH_NUMA(i, config, config_numa) {
- num += config_numa->sync_ctx_num + config_numa->async_ctx_num;
- if (idx < num)
- break;
- }
-
- if (i == config->numa_num) {
- WD_ERR("failed to find a proper numa node!\n");
- return NULL;
- }
-
- if (!config_numa->async_poll_num) {
- WD_ERR("invalid: async_poll_num of numa is zero!\n");
- return NULL;
- }
-
- ctx_table = config_numa->ctx_table;
- for (i = 0; i < config_numa->op_type_num; i++) {
- if (idx <= ctx_table[CTX_MODE_ASYNC][i].end &&
- idx >= ctx_table[CTX_MODE_ASYNC][i].begin) {
- offset = (idx - ctx_table[CTX_MODE_ASYNC][i].begin) %
- config_numa->async_poll_num;
- break;
- }
- }
-
- if (i == config_numa->op_type_num) {
- WD_ERR("failed to find async queue for ctx: idx %u!\n", idx);
- return NULL;
- }
-
- head = (struct async_task_queue *)config_numa->async_task_queue_array;
-
- return head + offset;
-}
-
-int wd_add_task_to_async_queue(struct wd_env_config *config, __u32 idx)
-{
- struct async_task_queue *task_queue;
- struct async_task *task;
- int curr_prod, ret;
-
- if (!config->enable_internal_poll)
- return 0;
-
- task_queue = find_async_queue(config, idx);
- if (!task_queue)
- return -WD_EINVAL;
-
- ret = sem_wait(&task_queue->empty_sem);
- if (ret) {
- WD_ERR("failed to wait empty_sem!\n");
- return ret;
- }
-
- pthread_mutex_lock(&task_queue->lock);
-
- /* get an available async task and fill ctx idx */
- curr_prod = task_queue->prod;
- task = task_queue->head + curr_prod;
- task->idx = idx;
-
- /* update global information of task queue */
- task_queue->prod = (curr_prod + 1) % task_queue->depth;
- task_queue->cur_task++;
- task_queue->left_task--;
-
- pthread_mutex_unlock(&task_queue->lock);
-
- ret = sem_post(&task_queue->full_sem);
- if (ret) {
- WD_ERR("failed to post full_sem!\n");
- goto err_out;
- }
-
- return 0;
-
-err_out:
- pthread_mutex_lock(&task_queue->lock);
- task_queue->left_task++;
- task_queue->cur_task--;
- task_queue->prod = curr_prod;
- pthread_mutex_unlock(&task_queue->lock);
- sem_post(&task_queue->empty_sem);
-
- return ret;
-}
-
-static void *async_poll_process_func(void *args)
-{
- struct async_task_queue *task_queue = args;
- struct async_task *head, *task;
- __u32 count;
- int cons, ret;
-
- while (1) {
- if (sem_wait(&task_queue->full_sem)) {
- if (errno == EINTR) {
- continue;
- }
- }
- if (__atomic_load_n(&task_queue->end, __ATOMIC_ACQUIRE)) {
- __atomic_store_n(&task_queue->end, 0, __ATOMIC_RELEASE);
- goto out;
- }
-
- pthread_mutex_lock(&task_queue->lock);
-
- /* async sending message isn't submitted yet */
- if (task_queue->cons == task_queue->prod) {
- pthread_mutex_unlock(&task_queue->lock);
- sem_post(&task_queue->full_sem);
- continue;
- }
-
- cons = task_queue->cons;
- head = task_queue->head;
- task = head + cons;
-
- task_queue->cons = (cons + 1) % task_queue->depth;
- task_queue->cur_task--;
- task_queue->left_task++;
-
- pthread_mutex_unlock(&task_queue->lock);
-
- ret = task_queue->alg_poll_ctx(task->idx, 1, &count);
- if (ret < 0) {
- pthread_mutex_lock(&task_queue->lock);
- task_queue->cons = cons;
- task_queue->cur_task++;
- task_queue->left_task--;
- pthread_mutex_unlock(&task_queue->lock);
- if (ret == -WD_EAGAIN) {
- sem_post(&task_queue->full_sem);
- continue;
- } else
- goto out;
- }
-
- if (sem_post(&task_queue->empty_sem))
- goto out;
- }
-out:
- return NULL;
-}
-
-static int wd_init_one_task_queue(struct async_task_queue *task_queue,
- void *alg_poll_ctx)
-
-{
- struct async_task *head;
- pthread_t thread_id;
- pthread_attr_t attr;
- int depth, ret;
-
- task_queue->depth = depth = WD_ASYNC_DEF_QUEUE_DEPTH;
-
- head = calloc(task_queue->depth, sizeof(*head));
- if (!head)
- return -WD_ENOMEM;
-
- task_queue->head = head;
- task_queue->left_task = depth;
- task_queue->alg_poll_ctx = alg_poll_ctx;
-
- if (sem_init(&task_queue->empty_sem, 0, depth)) {
- WD_ERR("failed to init empty_sem!\n");
- goto err_free_head;
- }
-
- if (sem_init(&task_queue->full_sem, 0, 0)) {
- WD_ERR("failed to init full_sem!\n");
- goto err_uninit_empty_sem;
- }
-
- if (pthread_mutex_init(&task_queue->lock, NULL)) {
- WD_ERR("failed to init task queue's mutex lock!\n");
- goto err_uninit_full_sem;
- }
-
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- task_queue->tid = 0;
- if (pthread_create(&thread_id, &attr, async_poll_process_func,
- task_queue)) {
- WD_ERR("failed to create poll thread!\n");
- goto err_destory_mutex;
- }
-
- task_queue->tid = thread_id;
- pthread_attr_destroy(&attr);
-
- return 0;
-
-err_destory_mutex:
- pthread_attr_destroy(&attr);
- pthread_mutex_destroy(&task_queue->lock);
-err_uninit_full_sem:
- sem_destroy(&task_queue->full_sem);
-err_uninit_empty_sem:
- sem_destroy(&task_queue->empty_sem);
-err_free_head:
- free(head);
- ret = -errno;
- return ret;
-}
-
-static void wd_uninit_one_task_queue(struct async_task_queue *task_queue)
-{
- /*
- * If there's no async task, async_poll_process_func() is sleeping
- * on task_queue->full_sem. It'll cause that threads could not
- * be end and memory leak.
- */
- sem_post(&task_queue->full_sem);
- __atomic_store_n(&task_queue->end, 1, __ATOMIC_RELEASE);
- while (__atomic_load_n(&task_queue->end, __ATOMIC_ACQUIRE))
- sched_yield();
-
- pthread_mutex_destroy(&task_queue->lock);
- sem_destroy(&task_queue->full_sem);
- sem_destroy(&task_queue->empty_sem);
- free(task_queue->head);
- task_queue->head = NULL;
-}
-
-static int wd_init_async_polling_thread_per_numa(struct wd_env_config *config,
- struct wd_env_config_per_numa *config_numa,
- void *alg_poll_ctx)
-{
- struct async_task_queue *task_queue, *queue_head;
- int i, j, ret;
- double num;
-
- if (!config_numa->async_ctx_num)
- return 0;
-
- if (!config_numa->async_poll_num) {
- WD_ERR("invalid async poll num (%lu) is set.\n",
- config_numa->async_poll_num);
- WD_ERR("change to default value: %d\n", WD_ASYNC_DEF_POLL_NUM);
- config_numa->async_poll_num = WD_ASYNC_DEF_POLL_NUM;
- }
-
- num = MIN(config_numa->async_poll_num, config_numa->async_ctx_num);
-
- /* make max task queues as the number of async ctxs */
- queue_head = calloc(config_numa->async_ctx_num, sizeof(*queue_head));
- if (!queue_head)
- return -WD_ENOMEM;
-
- task_queue = queue_head;
- for (i = 0; i < num; task_queue++, i++) {
- ret = wd_init_one_task_queue(task_queue, alg_poll_ctx);
- if (ret) {
- for (j = 0; j < i; task_queue++, j++)
- wd_uninit_one_task_queue(task_queue);
- free(queue_head);
- return ret;
- }
- }
-
- config_numa->async_task_queue_array = (void *)queue_head;
-
- return 0;
-}
-
-static void wd_uninit_async_polling_thread_per_numa(struct wd_env_config *cfg,
- struct wd_env_config_per_numa *config_numa)
-{
- struct async_task_queue *task_queue, *head;
- double num;
- int i;
-
- if (!config_numa || !config_numa->async_task_queue_array)
- return;
-
- head = config_numa->async_task_queue_array;
- task_queue = head;
- num = MIN(config_numa->async_poll_num, config_numa->async_ctx_num);
-
- for (i = 0; i < num; task_queue++, i++)
- wd_uninit_one_task_queue(task_queue);
- free(head);
- config_numa->async_task_queue_array = NULL;
-}
-
-static int wd_init_async_polling_thread(struct wd_env_config *config,
- void *alg_poll_ctx)
-{
- struct wd_env_config_per_numa *config_numa;
- int i, ret;
-
- if (!config->enable_internal_poll)
- return 0;
-
- FOREACH_NUMA(i, config, config_numa) {
- ret = wd_init_async_polling_thread_per_numa(config, config_numa,
- alg_poll_ctx);
- if (ret)
- goto out;
- }
-
- return 0;
-
-out:
- FOREACH_NUMA(i, config, config_numa)
- wd_uninit_async_polling_thread_per_numa(config, config_numa);
-
- return ret;
-}
-
-static void wd_uninit_async_polling_thread(struct wd_env_config *config)
-{
- struct wd_env_config_per_numa *config_numa;
- int i;
-
- if (!config->enable_internal_poll)
- return;
-
- FOREACH_NUMA(i, config, config_numa)
- wd_uninit_async_polling_thread_per_numa(config, config_numa);
-}
-
static int wd_init_resource(struct wd_env_config *config,
const struct wd_alg_ops *ops)
{
@@ -1739,14 +1332,8 @@ static int wd_init_resource(struct wd_env_config *config,
if (ret)
goto err_uninit_sched;
- ret = wd_init_async_polling_thread(config, ops->alg_poll_ctx);
- if (ret)
- goto err_uninit_alg;
-
return 0;
-err_uninit_alg:
- ops->alg_uninit();
err_uninit_sched:
wd_uninit_sched_config(config);
err_uninit_ctx:
@@ -1757,7 +1344,6 @@ err_uninit_ctx:
static void wd_uninit_resource(struct wd_env_config *config,
const struct wd_alg_ops *ops)
{
- wd_uninit_async_polling_thread(config);
ops->alg_uninit();
wd_uninit_sched_config(config);
wd_free_ctx(config);
@@ -1811,7 +1397,7 @@ int wd_alg_get_env_param(struct wd_env_config *env_config,
return -WD_EINVAL;
}
- *is_enable = env_config->enable_internal_poll;
+ *is_enable = 0;
config_numa = wd_get_config_numa(env_config, attr.node);
if (!config_numa)
--
2.43.0
