diff options
36 files changed, 1633 insertions, 1070 deletions
diff --git a/scanner/expr_matcher/adapter_hs/adapter_hs.cpp b/scanner/expr_matcher/adapter_hs/adapter_hs.cpp index d978df4..4bfd6c4 100644 --- a/scanner/expr_matcher/adapter_hs/adapter_hs.cpp +++ b/scanner/expr_matcher/adapter_hs/adapter_hs.cpp @@ -404,6 +404,9 @@ static void hs_lit_stream_reset(struct hs_lit_stream *hs_lit_stream) scratches[hs_lit_stream->thread_id], matched_event_cb, hs_lit_stream->matched_pat); } + + utarray_clear(hs_lit_stream->matched_pat->pattern_ids); + bloom_reset(hs_lit_stream->matched_pat->ref_bloom); } static void hs_regex_stream_reset(struct hs_regex_stream *hs_regex_stream) @@ -418,6 +421,9 @@ static void hs_regex_stream_reset(struct hs_regex_stream *hs_regex_stream) scratches[hs_regex_stream->thread_id], matched_event_cb, hs_regex_stream->matched_pat); } + + utarray_clear(hs_regex_stream->matched_pat->pattern_ids); + bloom_reset(hs_regex_stream->matched_pat->ref_bloom); } static int gather_hit_pattern_id(struct matched_pattern *matched_pat, @@ -436,8 +442,6 @@ static int gather_hit_pattern_id(struct matched_pattern *matched_pat, } *n_pattern_id = array_index; - utarray_clear(matched_pat->pattern_ids); - bloom_reset(matched_pat->ref_bloom); return 0; } diff --git a/scanner/expr_matcher/adapter_rs/adapter_rs.cpp b/scanner/expr_matcher/adapter_rs/adapter_rs.cpp index 795c3e9..8b49f8e 100644 --- a/scanner/expr_matcher/adapter_rs/adapter_rs.cpp +++ b/scanner/expr_matcher/adapter_rs/adapter_rs.cpp @@ -282,8 +282,6 @@ static int gather_hit_pattern_id(struct matched_pattern *matched_pat, } *n_pattern_id = array_index; - utarray_clear(matched_pat->pattern_ids); - bloom_reset(matched_pat->ref_bloom); return 0; } @@ -365,6 +363,9 @@ int rs_lit_engine_scan(void *rs_lit_engine, int thread_id, struct rs_lit_stream *rs_lit_stream = rs_lit_inst->streams[thread_id]; assert(rs_lit_stream != NULL); + utarray_clear(rs_lit_stream->matched_pat->pattern_ids); + bloom_reset(rs_lit_stream->matched_pat->ref_bloom); + if (rs_lit_inst->rs_db != NULL) { int ret = rs_scan(rs_lit_inst->rs_db, thread_id, data, data_len, 0, matched_event_cb, rs_lit_stream->matched_pat); @@ -536,6 +537,9 @@ int rs_regex_engine_scan(void *rs_regex_engine, int thread_id, struct rs_regex_stream *rs_regex_stream = rs_regex_inst->streams[thread_id]; assert(rs_regex_stream != NULL); + utarray_clear(rs_regex_stream->matched_pat->pattern_ids); + bloom_reset(rs_regex_stream->matched_pat->ref_bloom); + if (rs_regex_inst->rs_db != NULL) { int ret = rs_scan(rs_regex_inst->rs_db, thread_id, data, data_len, 0, matched_event_cb, rs_regex_stream->matched_pat); diff --git a/scanner/expr_matcher/expr_matcher.cpp b/scanner/expr_matcher/expr_matcher.cpp index 3a8f9e9..eed5d1e 100644 --- a/scanner/expr_matcher/expr_matcher.cpp +++ b/scanner/expr_matcher/expr_matcher.cpp @@ -270,9 +270,10 @@ void expr_matcher_free(struct expr_matcher *matcher) FREE(matcher); } -struct expr_matcher *expr_matcher_new(struct expr_rule *rules, size_t n_rule, - enum expr_engine_type engine_type, - size_t n_thread, struct log_handle *logger) +struct expr_matcher * +expr_matcher_new(struct expr_rule *rules, size_t n_rule, + enum expr_engine_type engine_type, + size_t n_thread, struct log_handle *logger) { if (NULL == rules || 0 == n_rule || 0 == n_thread || (engine_type != EXPR_ENGINE_TYPE_HS && @@ -443,7 +444,8 @@ next: int expr_matcher_match(struct expr_matcher *matcher, int thread_id, const char *data, size_t data_len, struct expr_scan_result *result_array, - size_t array_size, size_t *n_hit_result) + size_t array_size, size_t *n_hit_result, + size_t *n_hit_pattern) { if (NULL == matcher || thread_id < 0 || NULL == data || 0 == data_len || NULL == result_array || 0 == array_size || NULL == n_hit_result) { @@ -451,21 +453,21 @@ int expr_matcher_match(struct expr_matcher *matcher, int thread_id, } int err_count = 0; - unsigned long long lit_pattern_ids[MAX_HIT_PATTERN_NUM]; - unsigned long long regex_pattern_ids[MAX_HIT_PATTERN_NUM]; - size_t n_lit_pattern = 0; - size_t n_regex_pattern = 0; - size_t n_pattern = 0; + unsigned long long lit_pat_ids[MAX_HIT_PATTERN_NUM]; + unsigned long long regex_pat_ids[MAX_HIT_PATTERN_NUM]; + size_t lit_pat_cnt = 0; + size_t regex_pat_cnt = 0; + size_t pat_cnt = 0; int ret = engine_ops[matcher->engine_type].engine_scan(matcher->lit_runtime, thread_id, - data, data_len, lit_pattern_ids, - MAX_HIT_PATTERN_NUM, &n_lit_pattern); + data, data_len, lit_pat_ids, + MAX_HIT_PATTERN_NUM, &lit_pat_cnt); if (ret < 0) { err_count++; } ret = hs_regex_engine_scan(matcher->regex_runtime, thread_id, data, data_len, - regex_pattern_ids, MAX_HIT_PATTERN_NUM, &n_regex_pattern); + regex_pat_ids, MAX_HIT_PATTERN_NUM, ®ex_pat_cnt); if (ret < 0) { err_count++; } @@ -474,20 +476,22 @@ int expr_matcher_match(struct expr_matcher *matcher, int thread_id, return -1; } - n_pattern = n_lit_pattern + n_regex_pattern; - if (n_pattern > MAX_HIT_PATTERN_NUM) { - n_pattern = MAX_HIT_PATTERN_NUM; + pat_cnt = lit_pat_cnt + regex_pat_cnt; + *n_hit_pattern = pat_cnt; + + if (pat_cnt > MAX_HIT_PATTERN_NUM) { + pat_cnt = MAX_HIT_PATTERN_NUM; } size_t j = 0; - for (size_t i = n_lit_pattern; i < n_pattern; i++, j++) { - lit_pattern_ids[i] = regex_pattern_ids[j]; + for (size_t i = lit_pat_cnt; i < pat_cnt; i++, j++) { + lit_pat_ids[i] = regex_pat_ids[j]; } struct bool_expr_match *match_buff = matcher->bool_match_buffs[thread_id]; return expr_matcher_bool_matcher_match(matcher->bm, match_buff, MAX_HIT_PATTERN_NUM, - lit_pattern_ids, n_pattern, result_array, + lit_pat_ids, pat_cnt, result_array, array_size, n_hit_result); } @@ -534,29 +538,31 @@ expr_matcher_stream_open(struct expr_matcher *matcher, int thread_id) int expr_matcher_stream_match(struct expr_matcher_stream *stream, const char *data, size_t data_len, struct expr_scan_result *result_array, - size_t array_size, size_t *n_hit_result) + size_t array_size, size_t *n_hit_result, + size_t *n_hit_pattern) { - if (NULL == stream || NULL == data || 0 == data_len || NULL == result_array - || 0 == array_size || NULL == n_hit_result) { + if (NULL == stream || NULL == data || 0 == data_len || + NULL == result_array || 0 == array_size || + NULL == n_hit_result) { return -1; } int err_count = 0; - unsigned long long lit_pattern_ids[MAX_HIT_PATTERN_NUM]; - unsigned long long regex_pattern_ids[MAX_HIT_PATTERN_NUM]; - size_t n_lit_pattern = 0; - size_t n_regex_pattern = 0; - size_t n_pattern = 0; + unsigned long long lit_pat_ids[MAX_HIT_PATTERN_NUM]; + unsigned long long regex_pat_ids[MAX_HIT_PATTERN_NUM]; + size_t lit_pat_cnt = 0; + size_t regex_pat_cnt = 0; + size_t pat_cnt = 0; int ret = engine_ops[stream->engine_type].scan_stream(stream->lit_stream, data, data_len, - lit_pattern_ids, MAX_HIT_PATTERN_NUM, - &n_lit_pattern); + lit_pat_ids, MAX_HIT_PATTERN_NUM, + &lit_pat_cnt); if (ret < 0) { err_count++; } - ret = hs_regex_stream_scan(stream->regex_stream, data, data_len, regex_pattern_ids, - MAX_HIT_PATTERN_NUM, &n_regex_pattern); + ret = hs_regex_stream_scan(stream->regex_stream, data, data_len, regex_pat_ids, + MAX_HIT_PATTERN_NUM, ®ex_pat_cnt); if (ret < 0) { err_count++; } @@ -565,22 +571,23 @@ int expr_matcher_stream_match(struct expr_matcher_stream *stream, return -1; } - n_pattern = n_lit_pattern + n_regex_pattern; - if (n_pattern > MAX_HIT_PATTERN_NUM) { - n_pattern = MAX_HIT_PATTERN_NUM; + pat_cnt = lit_pat_cnt + regex_pat_cnt; + *n_hit_pattern = pat_cnt; + if (pat_cnt > MAX_HIT_PATTERN_NUM) { + pat_cnt = MAX_HIT_PATTERN_NUM; } size_t j = 0; - for (size_t i = n_lit_pattern; i < n_pattern; i++, j++) { - lit_pattern_ids[i] = regex_pattern_ids[j]; + for (size_t i = lit_pat_cnt; i < pat_cnt; i++, j++) { + lit_pat_ids[i] = regex_pat_ids[j]; } struct expr_matcher *matcher = stream->ref_matcher; struct bool_expr_match *match_buff = matcher->bool_match_buffs[stream->thread_id]; return expr_matcher_bool_matcher_match(matcher->bm, match_buff, MAX_HIT_PATTERN_NUM, - lit_pattern_ids, n_pattern, result_array, - array_size, n_hit_result); + lit_pat_ids, pat_cnt, result_array, array_size, + n_hit_result); } void expr_matcher_stream_close(struct expr_matcher_stream *stream) diff --git a/scanner/expr_matcher/expr_matcher.h b/scanner/expr_matcher/expr_matcher.h index 260fa7c..d7a9cd3 100644 --- a/scanner/expr_matcher/expr_matcher.h +++ b/scanner/expr_matcher/expr_matcher.h @@ -88,9 +88,10 @@ int expr_matcher_verify_regex_expression(const char *regex_expr, * @param n_worker_threads: the number of scan threads which will call adapter_rs_scan() * */ -struct expr_matcher *expr_matcher_new(struct expr_rule *rules, size_t n_rule, - enum expr_engine_type type, size_t n_thread, - struct log_handle *logger); +struct expr_matcher * +expr_matcher_new(struct expr_rule *rules, size_t n_rule, + enum expr_engine_type type, size_t n_thread, + struct log_handle *logger); void expr_matcher_free(struct expr_matcher *matcher); @@ -107,7 +108,8 @@ void expr_matcher_free(struct expr_matcher *matcher); int expr_matcher_match(struct expr_matcher *matcher, int thread_id, const char *data, size_t data_len, struct expr_scan_result *result_array, - size_t array_size, size_t *n_hit_result); + size_t array_size, size_t *n_hit_result, + size_t *n_hit_pattern); /** * @brief @@ -121,7 +123,8 @@ expr_matcher_stream_open(struct expr_matcher *matcher, int thread_id); int expr_matcher_stream_match(struct expr_matcher_stream *stream, const char *data, size_t data_len, struct expr_scan_result *result_array, - size_t array_size, size_t *n_hit_result); + size_t array_size, size_t *n_hit_result, + size_t *n_hit_pattern); /** * @brief diff --git a/src/inc_internal/maat_bool_plugin.h b/src/inc_internal/maat_bool_plugin.h index 3cc4f86..f3be8f5 100644 --- a/src/inc_internal/maat_bool_plugin.h +++ b/src/inc_internal/maat_bool_plugin.h @@ -57,9 +57,9 @@ int bool_plugin_runtime_get_ex_data(void *bool_plugin_runtime, unsigned long lon long long bool_plugin_runtime_update_err_count(void *bool_plugin_runtime); -void bool_plugin_runtime_scan_inc(void *bool_plugin_runtime, int thread_id); +void bool_plugin_runtime_scan_times_inc(void *bool_plugin_runtime, int thread_id); -long long bool_plugin_runtime_scan_count(void *bool_plugin_runtime); +long long bool_plugin_runtime_scan_times(void *bool_plugin_runtime); #ifdef __cplusplus } diff --git a/src/inc_internal/maat_expr.h b/src/inc_internal/maat_expr.h index d510d92..81d781a 100644 --- a/src/inc_internal/maat_expr.h +++ b/src/inc_internal/maat_expr.h @@ -52,32 +52,38 @@ long long expr_runtime_get_version(void *expr_runtime); int expr_runtime_scan(struct expr_runtime *expr_rt, int thread_id, const char *data, size_t data_len, int vtable_id, struct maat_state *state); -struct expr_matcher_stream *expr_runtime_stream_open(struct expr_runtime *expr_rt, int thread_id); +struct expr_runtime_stream *expr_runtime_stream_open(struct expr_runtime *expr_rt, int thread_id); -int expr_runtime_stream_scan(struct expr_runtime *expr_rt, struct expr_matcher_stream *s_handle, - const char *data, size_t data_len, int vtable_id, struct maat_state *state); +int expr_runtime_stream_scan(struct expr_runtime_stream *expr_rt_stream, const char *data, + size_t data_len, int vtable_id, struct maat_state *state); -void expr_runtime_stream_close(struct expr_runtime *expr_rt, int thread_id, - struct expr_matcher_stream *stream); +void expr_runtime_stream_close(struct expr_runtime_stream *expr_rt_stream); int expr_runtime_set_scan_district(struct expr_runtime *expr_rt, const char *district, size_t district_len, long long *district_id); -void expr_runtime_hit_inc(struct expr_runtime *expr_rt, int thread_id); - void expr_runtime_perf_stat(struct expr_runtime *flag_rt, size_t scan_len, struct timespec *start, struct timespec *end, int thread_id); -long long expr_runtime_scan_count(void *expr_runtime); +long long expr_runtime_scan_times(void *expr_runtime); long long expr_runtime_scan_cpu_time(void *expr_runtime); -long long expr_runtime_hit_count(void *expr_runtime); +long long expr_runtime_scan_bytes(struct expr_runtime *expr_rt); -long long expr_runtime_update_err_count(void *expr_runtime); +long long expr_runtime_hit_times(void *expr_runtime); -long long expr_runtime_scan_bytes(struct expr_runtime *expr_rt); +void expr_runtime_hit_times_inc(struct expr_runtime *expr_rt, int thread_id); + +void expr_runtime_stream_hit_times_inc(struct expr_runtime_stream *expr_rt_stream, + int thread_id); + +long long expr_runtime_hit_item_num(void *expr_runtime); + +long long expr_runtime_hit_pattern_num(void *expr_runtime); + +long long expr_runtime_update_err_count(void *expr_runtime); #ifdef __cplusplus } diff --git a/src/inc_internal/maat_flag.h b/src/inc_internal/maat_flag.h index 99c088d..b67d458 100644 --- a/src/inc_internal/maat_flag.h +++ b/src/inc_internal/maat_flag.h @@ -53,16 +53,20 @@ int flag_runtime_scan(struct flag_runtime *flag_rt, int thread_id, long long fla int flag_runtime_set_scan_district(struct flag_runtime *flag_rt, const char *district, size_t district_len, long long *district_id); -void flag_runtime_hit_inc(struct flag_runtime *flag_rt, int thread_id); + void flag_runtime_perf_stat(struct flag_runtime *flag_rt, struct timespec *start, struct timespec *end, int thread_id); -long long flag_runtime_scan_count(void *flag_runtime); +long long flag_runtime_scan_times(void *flag_runtime); long long flag_runtime_scan_cpu_time(void *flag_runtime); -long long flag_runtime_hit_count(void *flag_runtime); +long long flag_runtime_hit_times(void *flag_runtime); + +void flag_runtime_hit_times_inc(struct flag_runtime *flag_rt, int thread_id); + +long long flag_runtime_hit_item_num(void *flag_runtime); long long flag_runtime_update_err_count(void *flag_runtime); diff --git a/src/inc_internal/maat_fqdn_plugin.h b/src/inc_internal/maat_fqdn_plugin.h index 2fc2f3b..71b7983 100644 --- a/src/inc_internal/maat_fqdn_plugin.h +++ b/src/inc_internal/maat_fqdn_plugin.h @@ -61,9 +61,9 @@ void fqdn_rule_free(struct FQDN_rule *fqdn_rule); long long fqdn_plugin_runtime_update_err_count(void *fqdn_plugin_runtime); -void fqdn_plugin_runtime_scan_inc(void *fqdn_plugin_runtime, int thread_id); +void fqdn_plugin_runtime_scan_times_inc(void *fqdn_plugin_runtime, int thread_id); -long long fqdn_plugin_runtime_scan_count(void *fqdn_plugin_runtime); +long long fqdn_plugin_runtime_scan_times(void *fqdn_plugin_runtime); #ifdef __cplusplus } diff --git a/src/inc_internal/maat_interval.h b/src/inc_internal/maat_interval.h index b9b3039..5b86475 100644 --- a/src/inc_internal/maat_interval.h +++ b/src/inc_internal/maat_interval.h @@ -52,16 +52,18 @@ int interval_runtime_scan(struct interval_runtime *interval_rt, int thread_id, int interval_runtime_set_scan_district(struct interval_runtime *interval_rt, const char *district, size_t district_len, long long *district_id); -void interval_runtime_hit_inc(struct interval_runtime *interval_rt, int thread_id); - void interval_runtime_perf_stat(struct interval_runtime *interval_rt, struct timespec *start, struct timespec *end, int thread_id); -long long interval_runtime_scan_count(void *interval_runtime); +long long interval_runtime_scan_times(void *interval_runtime); long long interval_runtime_scan_cpu_time(void *interval_runtime); -long long interval_runtime_hit_count(void *interval_runtime); +void interval_runtime_hit_times_inc(struct interval_runtime *interval_rt, int thread_id); + +long long interval_runtime_hit_times(void *interval_runtime); + +long long interval_runtime_hit_item_num(void *interval_runtime); long long interval_runtime_update_err_cnt(void *interval_runtime); diff --git a/src/inc_internal/maat_ip.h b/src/inc_internal/maat_ip.h index 6827e8b..1f42668 100644 --- a/src/inc_internal/maat_ip.h +++ b/src/inc_internal/maat_ip.h @@ -45,16 +45,18 @@ int ip_runtime_scan(struct ip_runtime *ip_rt, int thread_id, int ip_type, uint8_t *ip_addr, uint16_t port, int proto, int vtable_id, struct maat_state *state); -void ip_runtime_hit_inc(struct ip_runtime *ip_rt, int thread_id); - void ip_runtime_perf_stat(struct ip_runtime *ip_rt, struct timespec *start, struct timespec *end, int thread_id); -long long ip_runtime_scan_count(void *ip_runtime); +long long ip_runtime_scan_times(void *ip_runtime); long long ip_runtime_scan_cpu_time(void *ip_runtime); -long long ip_runtime_hit_count(void *ip_runtime); +void ip_runtime_hit_times_inc(struct ip_runtime *ip_rt, int thread_id); + +long long ip_runtime_hit_times(void *ip_runtime); + +long long ip_runtime_hit_item_num(void *ip_runtime); long long ip_runtime_update_err_count(void *ip_runtime); diff --git a/src/inc_internal/maat_ip_plugin.h b/src/inc_internal/maat_ip_plugin.h index 3e65355..2a713a0 100644 --- a/src/inc_internal/maat_ip_plugin.h +++ b/src/inc_internal/maat_ip_plugin.h @@ -57,9 +57,9 @@ int ip_plugin_runtime_get_ex_data(void *ip_plugin_runtime, const struct ip_addr long long ip_plugin_runtime_update_err_count(void *ip_plugin_runtime); -void ip_plugin_runtime_scan_inc(void *ip_plugin_rt, int thread_id); +void ip_plugin_runtime_scan_times_inc(void *ip_plugin_rt, int thread_id); -long long ip_plugin_runtime_scan_count(void *ip_plugin_runtime); +long long ip_plugin_runtime_scan_times(void *ip_plugin_runtime); #ifdef __cplusplus } diff --git a/src/inc_internal/maat_ipport_plugin.h b/src/inc_internal/maat_ipport_plugin.h index 6dc2452..7d911d7 100644 --- a/src/inc_internal/maat_ipport_plugin.h +++ b/src/inc_internal/maat_ipport_plugin.h @@ -59,9 +59,9 @@ int ipport_plugin_runtime_get_ex_data(void *ipport_plugin_runtime, const struct long long ipport_plugin_runtime_update_err_count(void *ipport_plugin_runtime); -void ipport_plugin_runtime_scan_inc(void *ipport_plugin_rt, int thread_id); +void ipport_plugin_runtime_scan_times_inc(void *ipport_plugin_rt, int thread_id); -long long ipport_plugin_runtime_scan_count(void *ipport_plugin_runtime); +long long ipport_plugin_runtime_scan_times(void *ipport_plugin_runtime); #ifdef __cplusplus } diff --git a/src/inc_internal/maat_plugin.h b/src/inc_internal/maat_plugin.h index bdd4b4a..388c423 100644 --- a/src/inc_internal/maat_plugin.h +++ b/src/inc_internal/maat_plugin.h @@ -73,9 +73,9 @@ const char *plugin_runtime_cached_row_get(void *plugin_runtime, size_t index); void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema, const char *key, size_t key_len); -void plugin_runtime_scan_inc(void *plugin_runtime, int thread_id); +void plugin_runtime_scan_times_inc(void *plugin_runtime, int thread_id); -long long plugin_runtime_scan_count(void *plugin_runtime); +long long plugin_runtime_scan_times(void *plugin_runtime); #ifdef __cplusplus } diff --git a/src/inc_internal/maat_rule.h b/src/inc_internal/maat_rule.h index d05be1a..71ce688 100644 --- a/src/inc_internal/maat_rule.h +++ b/src/inc_internal/maat_rule.h @@ -153,8 +153,8 @@ struct maat_stat { long long *thread_call_cnt; - long long *stream_num; - long long *hit_cnt; + long long *stream_cnt; + long long *hit_compile_cnt; long long *maat_state_cnt; long long *compile_state_cnt; long long *maat_state_free_cnt; @@ -191,7 +191,7 @@ struct maat { struct maat_state { struct maat *maat_inst; struct compile_state *compile_state; - int scan_cnt; + int Nth_scan; int district_id; //-1: Any District; -2: Unkonwn District; uint16_t thread_id; int16_t compile_table_id; diff --git a/src/inc_internal/maat_table.h b/src/inc_internal/maat_table.h index 494ba91..6ab6573 100644 --- a/src/inc_internal/maat_table.h +++ b/src/inc_internal/maat_table.h @@ -58,7 +58,7 @@ void table_manager_runtime_destroy(struct table_manager *tbl_mgr); void table_manager_destroy(struct table_manager *tbl_mgr); size_t table_manager_table_size(struct table_manager *tbl_mgr); -size_t table_manager_table_count(struct table_manager *tbl_mgr); +size_t table_manager_table_num(struct table_manager *tbl_mgr); int table_manager_get_table_id(struct table_manager *tbl_mgr, const char *table_name); /** @@ -105,13 +105,14 @@ void table_manager_commit_runtime(struct table_manager *tbl_mgr, int table_id, long long table_manager_runtime_rule_count(struct table_manager *tbl_mgr, int table_id); -long long table_manager_runtime_scan_count(struct table_manager *tbl_mgr, int table_id); +long long table_manager_runtime_scan_times(struct table_manager *tbl_mgr, int table_id); long long table_manager_runtime_scan_cpu_time(struct table_manager *tbl_mgr, int table_id); -long long table_manager_runtime_hit_count(struct table_manager *tbl_mgr, int table_id); +long long table_manager_runtime_hit_item_num(struct table_manager *tbl_mgr, int table_id); -long long table_manager_runtime_update_err_count(struct table_manager *tbl_mgr, int table_id); +long long table_manager_runtime_update_err_count(struct table_manager *tbl_mgr, + int table_id); #ifdef __cplusplus } diff --git a/src/maat_api.c b/src/maat_api.c index 4a77d36..b322a38 100644 --- a/src/maat_api.c +++ b/src/maat_api.c @@ -57,7 +57,7 @@ enum logic_not_flag { struct maat_stream { struct maat *ref_maat_inst; - struct expr_matcher_stream *handle; //each physical table open one stream + struct expr_runtime_stream *expr_rt_stream; //each physical table open one stream long long last_full_version; long long expr_rt_version; struct log_handle *logger; @@ -888,7 +888,7 @@ void *maat_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, int thread_id = _get_tid(maat_inst); if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) { - plugin_runtime_scan_inc(runtime, thread_id); + plugin_runtime_scan_times_inc(runtime, thread_id); } void *ret = NULL; @@ -922,7 +922,7 @@ int maat_ip_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, int thread_id = _get_tid(maat_inst); if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) { - ip_plugin_runtime_scan_inc(ip_plugin_rt, thread_id); + ip_plugin_runtime_scan_times_inc(ip_plugin_rt, thread_id); } return ip_plugin_runtime_get_ex_data(ip_plugin_rt, ip_addr, ex_data_array, array_size); @@ -949,7 +949,7 @@ int maat_ipport_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, int thread_id = _get_tid(maat_inst); if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) { - ipport_plugin_runtime_scan_inc(ipport_plugin_rt, thread_id); + ipport_plugin_runtime_scan_times_inc(ipport_plugin_rt, thread_id); } return ipport_plugin_runtime_get_ex_data(ipport_plugin_rt, ip_addr, port, @@ -977,7 +977,7 @@ int maat_fqdn_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, int thread_id = _get_tid(maat_inst); if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) { - fqdn_plugin_runtime_scan_inc(fqdn_plugin_rt, thread_id); + fqdn_plugin_runtime_scan_times_inc(fqdn_plugin_rt, thread_id); } return fqdn_plugin_runtime_get_ex_data(fqdn_plugin_rt, fqdn, ex_data_array, array_size); @@ -1004,7 +1004,7 @@ int maat_bool_plugin_table_get_ex_data(struct maat *maat_inst, int table_id, int thread_id = _get_tid(maat_inst); if (thread_id >= 0 && thread_id < maat_inst->opts.nr_worker_thread) { - bool_plugin_runtime_scan_inc(bool_plugin_rt, thread_id); + bool_plugin_runtime_scan_times_inc(bool_plugin_rt, thread_id); } return bool_plugin_runtime_get_ex_data(bool_plugin_rt, item_ids, n_item, @@ -1035,7 +1035,7 @@ static int flag_scan(struct table_manager *tbl_mgr, int thread_id, long long fla return group_hit_cnt; } - flag_runtime_hit_inc((struct flag_runtime *)flag_rt, thread_id); + flag_runtime_hit_times_inc((struct flag_runtime *)flag_rt, thread_id); return group_hit_cnt; } @@ -1065,7 +1065,7 @@ static int interval_scan(struct table_manager *tbl_mgr, int thread_id, long long return group_hit_cnt; } - interval_runtime_hit_inc((struct interval_runtime *)interval_rt, thread_id); + interval_runtime_hit_times_inc((struct interval_runtime *)interval_rt, thread_id); return group_hit_cnt; } @@ -1091,7 +1091,7 @@ static int ipv4_scan(struct table_manager *tbl_mgr, int thread_id, uint32_t ip_a return group_hit_cnt; } - ip_runtime_hit_inc((struct ip_runtime *)ip_rt, thread_id); + ip_runtime_hit_times_inc((struct ip_runtime *)ip_rt, thread_id); return group_hit_cnt; } @@ -1117,7 +1117,7 @@ static int ipv6_scan(struct table_manager *tbl_mgr, int thread_id, return group_hit_cnt; } - ip_runtime_hit_inc((struct ip_runtime *)ip_rt, thread_id); + ip_runtime_hit_times_inc((struct ip_runtime *)ip_rt, thread_id); return group_hit_cnt; } @@ -1148,43 +1148,7 @@ static int string_scan(struct table_manager *tbl_mgr, int thread_id, return group_hit_cnt; } - expr_runtime_hit_inc((struct expr_runtime *)expr_rt, thread_id); - - return group_hit_cnt; -} - -static int expr_stream_scan(struct maat_stream *stream, const char *data, - size_t data_len, struct maat_state *state) -{ - if (NULL == stream || NULL == data) { - return 0; - } - - enum table_type table_type = TABLE_TYPE_INVALID; - struct table_manager *tbl_mgr = stream->ref_maat_inst->tbl_mgr; - table_type = table_manager_get_table_type(tbl_mgr, stream->phy_table_id); - if (table_type == TABLE_TYPE_EXPR_PLUS && - DISTRICT_FLAG_UNSET == state->district_flag) { - return -1; - } - - if (table_type != TABLE_TYPE_EXPR && table_type != TABLE_TYPE_EXPR_PLUS) { - return -1; - } - - void *expr_rt = table_manager_get_runtime(tbl_mgr, stream->phy_table_id); - if (NULL == expr_rt) { - return -1; - } - - int group_hit_cnt = expr_runtime_stream_scan((struct expr_runtime *)expr_rt, - stream->handle, data, data_len, - stream->vtable_id, state); - if (group_hit_cnt <= 0) { - return group_hit_cnt; - } - - expr_runtime_hit_inc((struct expr_runtime *)expr_rt, stream->thread_id); + expr_runtime_hit_times_inc((struct expr_runtime *)expr_rt, thread_id); return group_hit_cnt; } @@ -1222,7 +1186,7 @@ int maat_scan_flag(struct maat *maat_inst, int table_id, clock_gettime(CLOCK_MONOTONIC, &start); } - state->scan_cnt++; + state->Nth_scan++; struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { @@ -1267,7 +1231,8 @@ int maat_scan_flag(struct maat *maat_inst, int table_id, } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, state->thread_id, + sum_hit_compile_cnt); } void *flag_rt = table_manager_get_runtime(maat_inst->tbl_mgr, phy_table_id); @@ -1306,7 +1271,7 @@ int maat_scan_integer(struct maat *maat_inst, int table_id, clock_gettime(CLOCK_MONOTONIC, &start); } - state->scan_cnt++; + state->Nth_scan++; struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { @@ -1351,7 +1316,8 @@ int maat_scan_integer(struct maat *maat_inst, int table_id, } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, state->thread_id, + sum_hit_compile_cnt); } void *interval_rt = table_manager_get_runtime(maat_inst->tbl_mgr, phy_table_id); @@ -1390,7 +1356,7 @@ int maat_scan_ipv4(struct maat *maat_inst, int table_id, uint32_t ip_addr, clock_gettime(CLOCK_MONOTONIC, &start); } - state->scan_cnt++; + state->Nth_scan++; struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { @@ -1435,7 +1401,8 @@ int maat_scan_ipv4(struct maat *maat_inst, int table_id, uint32_t ip_addr, } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, state->thread_id, + sum_hit_compile_cnt); } void *ip_rt = table_manager_get_runtime(maat_inst->tbl_mgr, phy_table_id); @@ -1476,7 +1443,7 @@ int maat_scan_ipv6(struct maat *maat_inst, int table_id, clock_gettime(CLOCK_MONOTONIC, &start); } - state->scan_cnt++; + state->Nth_scan++; struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { @@ -1521,7 +1488,8 @@ int maat_scan_ipv6(struct maat *maat_inst, int table_id, } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, state->thread_id, + sum_hit_compile_cnt); } void *ip_rt = table_manager_get_runtime(maat_inst->tbl_mgr, phy_table_id); @@ -1562,7 +1530,7 @@ int maat_scan_string(struct maat *maat_inst, int table_id, clock_gettime(CLOCK_MONOTONIC, &start); } - state->scan_cnt++; + state->Nth_scan++; struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { @@ -1607,7 +1575,8 @@ int maat_scan_string(struct maat *maat_inst, int table_id, } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, state->thread_id, + sum_hit_compile_cnt); } void *expr_rt = table_manager_get_runtime(maat_inst->tbl_mgr, phy_table_id); @@ -1654,7 +1623,7 @@ static void maat_state_add_hit_group(struct maat_state *state, int table_id, } compile_state_update(state->compile_state, maat_inst, table_id, - state->compile_table_id, state->scan_cnt, + state->compile_table_id, state->Nth_scan, hit_items, n_hit_item); } @@ -1677,7 +1646,7 @@ static void maat_state_activate_hit_not_group(struct maat_state *state, int tabl } compile_state_not_logic_update(state->compile_state, compile_rt, maat_inst, - table_id, state->scan_cnt); + table_id, state->Nth_scan); } int maat_scan_group(struct maat *maat_inst, int table_id, @@ -1692,7 +1661,7 @@ int maat_scan_group(struct maat *maat_inst, int table_id, return -1; } - state->scan_cnt++; + state->Nth_scan++; struct maat_runtime *maat_rt = maat_inst->maat_rt; if (NULL == maat_rt) { @@ -1708,7 +1677,8 @@ int maat_scan_group(struct maat *maat_inst, int table_id, maat_runtime_ref_dec(maat_rt, state->thread_id); if (hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, state->thread_id, + hit_compile_cnt); return MAAT_SCAN_HIT; } @@ -1743,7 +1713,8 @@ int maat_scan_not_logic(struct maat *maat_inst, int table_id, maat_runtime_ref_dec(maat_rt, state->thread_id); if (hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, state->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, state->thread_id, + hit_compile_cnt); return MAAT_SCAN_HIT; } @@ -1789,13 +1760,16 @@ struct maat_stream *maat_stream_new(struct maat *maat_inst, int table_id, stream->expr_rt_version = expr_runtime_get_version(expr_rt); maat_runtime_ref_inc(maat_inst->maat_rt, state->thread_id); - struct expr_matcher_stream *handle = expr_runtime_stream_open((struct expr_runtime *)expr_rt, - state->thread_id); - if (NULL == handle) { + + struct expr_runtime_stream *expr_rt_stream = NULL; + expr_rt_stream = expr_runtime_stream_open((struct expr_runtime *)expr_rt, + state->thread_id); + if (NULL == expr_rt_stream) { goto error; } - alignment_int64_array_add(maat_inst->stat->stream_num, stream->thread_id, 1); - stream->handle = handle; + + alignment_int64_array_add(maat_inst->stat->stream_cnt, stream->thread_id, 1); + stream->expr_rt_stream = expr_rt_stream; return stream; @@ -1804,6 +1778,36 @@ error: return NULL; } +static int expr_stream_scan(struct maat_stream *stream, const char *data, + size_t data_len, struct maat_state *state) +{ + if (NULL == stream || NULL == data) { + return 0; + } + + enum table_type table_type = TABLE_TYPE_INVALID; + struct table_manager *tbl_mgr = stream->ref_maat_inst->tbl_mgr; + table_type = table_manager_get_table_type(tbl_mgr, stream->phy_table_id); + if (table_type == TABLE_TYPE_EXPR_PLUS && + DISTRICT_FLAG_UNSET == state->district_flag) { + return -1; + } + + if (table_type != TABLE_TYPE_EXPR && table_type != TABLE_TYPE_EXPR_PLUS) { + return -1; + } + + int group_hit_cnt = expr_runtime_stream_scan(stream->expr_rt_stream, data, + data_len, stream->vtable_id, state); + if (group_hit_cnt <= 0) { + return group_hit_cnt; + } + + expr_runtime_stream_hit_times_inc(stream->expr_rt_stream, stream->thread_id); + + return group_hit_cnt; +} + int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data_len, long long *results, size_t n_result, size_t *n_hit_result, struct maat_state *state) @@ -1818,7 +1822,7 @@ int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data clock_gettime(CLOCK_MONOTONIC, &start); } - state->scan_cnt++; + state->Nth_scan++; struct maat *maat_inst = maat_stream->ref_maat_inst; if (maat_stream->last_full_version != maat_inst->last_full_version) { @@ -1850,7 +1854,8 @@ int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data } if (sum_hit_compile_cnt > 0) { - alignment_int64_array_add(maat_inst->stat->hit_cnt, maat_stream->thread_id, 1); + alignment_int64_array_add(maat_inst->stat->hit_compile_cnt, maat_stream->thread_id, + sum_hit_compile_cnt); } if (1 == maat_inst->opts.perf_on) { @@ -1871,12 +1876,12 @@ int maat_stream_scan(struct maat_stream *maat_stream, const char *data, int data void maat_stream_free(struct maat_stream *maat_stream) { - if (NULL == maat_stream || NULL == maat_stream->handle) { + if (NULL == maat_stream) { return; } struct maat *maat_inst = maat_stream->ref_maat_inst; - void *expr_rt = table_manager_get_runtime(maat_inst->tbl_mgr, + void *expr_rt = table_manager_get_runtime(maat_inst->tbl_mgr, maat_stream->phy_table_id); assert(expr_rt != NULL); @@ -1888,8 +1893,13 @@ void maat_stream_free(struct maat_stream *maat_stream) maat_inst->stat->zombie_rs_stream--; } - alignment_int64_array_add(maat_inst->stat->stream_num, maat_stream->thread_id, -1); - expr_runtime_stream_close(expr_rt, maat_stream->thread_id, maat_stream->handle); + alignment_int64_array_add(maat_inst->stat->stream_cnt, maat_stream->thread_id, -1); + + if (maat_stream->expr_rt_stream != NULL) { + expr_runtime_stream_close(maat_stream->expr_rt_stream); + maat_stream->expr_rt_stream = NULL; + } + FREE(maat_stream); } @@ -1921,7 +1931,7 @@ void maat_state_reset(struct maat_state *state) state->compile_table_id = 0; state->district_flag = DISTRICT_FLAG_UNSET; state->district_id = DISTRICT_ANY; - state->scan_cnt = 0; + state->Nth_scan = 0; if (state->compile_state != NULL) { compile_state_reset(state->compile_state); @@ -2098,7 +2108,7 @@ size_t maat_state_get_scan_count(struct maat_state *state) return 0; } - return state->scan_cnt; + return state->Nth_scan; } int maat_state_get_direct_hit_groups(struct maat_state *state, diff --git a/src/maat_bool_plugin.c b/src/maat_bool_plugin.c index bf04e5d..f6b1dd7 100644 --- a/src/maat_bool_plugin.c +++ b/src/maat_bool_plugin.c @@ -39,7 +39,7 @@ struct bool_plugin_runtime { long long rule_num; long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; }; /* bool plugin schema API */ @@ -199,7 +199,7 @@ void *bool_plugin_runtime_new(void *bool_plugin_schema, size_t max_thread_num, bool_plugin_rt->n_worker_thread = max_thread_num; bool_plugin_rt->ref_garbage_bin = garbage_bin; bool_plugin_rt->logger = logger; - bool_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + bool_plugin_rt->scan_times = alignment_int64_array_alloc(max_thread_num); return bool_plugin_rt; } @@ -221,9 +221,9 @@ void bool_plugin_runtime_free(void *bool_plugin_runtime) bool_plugin_rt->ex_data_rt = NULL; } - if (bool_plugin_rt->scan_cnt != NULL) { - alignment_int64_array_free(bool_plugin_rt->scan_cnt); - bool_plugin_rt->scan_cnt = NULL; + if (bool_plugin_rt->scan_times != NULL) { + alignment_int64_array_free(bool_plugin_rt->scan_times); + bool_plugin_rt->scan_times = NULL; } FREE(bool_plugin_rt); @@ -583,26 +583,26 @@ long long bool_plugin_runtime_update_err_count(void *bool_plugin_runtime) return bool_plugin_rt->update_err_cnt; } -void bool_plugin_runtime_scan_inc(void *bool_plugin_runtime, int thread_id) +void bool_plugin_runtime_scan_times_inc(void *bool_plugin_runtime, int thread_id) { if (NULL == bool_plugin_runtime || thread_id < 0) { return; } struct bool_plugin_runtime *bool_plugin_rt = (struct bool_plugin_runtime *)bool_plugin_runtime; - alignment_int64_array_add(bool_plugin_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(bool_plugin_rt->scan_times, thread_id, 1); } -long long bool_plugin_runtime_scan_count(void *bool_plugin_runtime) +long long bool_plugin_runtime_scan_times(void *bool_plugin_runtime) { if (NULL == bool_plugin_runtime) { return 0; } struct bool_plugin_runtime *bool_plugin_rt = (struct bool_plugin_runtime *)bool_plugin_runtime; - long long sum = alignment_int64_array_sum(bool_plugin_rt->scan_cnt, + long long sum = alignment_int64_array_sum(bool_plugin_rt->scan_times, bool_plugin_rt->n_worker_thread); - alignment_int64_array_reset(bool_plugin_rt->scan_cnt, bool_plugin_rt->n_worker_thread); + alignment_int64_array_reset(bool_plugin_rt->scan_times, bool_plugin_rt->n_worker_thread); return sum; }
\ No newline at end of file diff --git a/src/maat_config_monitor.c b/src/maat_config_monitor.c index 95b3802..2e83b83 100644 --- a/src/maat_config_monitor.c +++ b/src/maat_config_monitor.c @@ -25,8 +25,7 @@ #define MAX_CONFIG_LINE (1024 * 16) -struct cm_table_info_t -{ +struct cm_table_info_t { char table_name[MAX_NAME_STR_LEN]; char cfg_path[NAME_MAX]; int cfg_num; @@ -45,8 +44,8 @@ static int cm_read_cfg_index_file(const char *path, struct cm_table_info_t *idx, while (!feof(fp)) { memset(line, 0, sizeof(line)); fgets(line, sizeof(line), fp); - ret = sscanf(line, "%s\t%d\t%s\t%s", idx[i].table_name, &(idx[i].cfg_num), - idx[i].cfg_path ,idx[i].encrypt_algo); + ret = sscanf(line, "%s\t%d\t%s\t%s", idx[i].table_name, + &(idx[i].cfg_num), idx[i].cfg_path, idx[i].encrypt_algo); //jump over empty line if (!(ret == 3 || ret == 4) || idx[i].cfg_num == 0) { @@ -140,7 +139,7 @@ static int cm_read_table_file(struct cm_table_info_t *index, } } else { // not encrypted - ret = load_file_to_memory(index->cfg_path, (unsigned char **)&file_buff, &file_sz); + ret = load_file_to_memory(index->cfg_path, (unsigned char**)&file_buff, &file_sz); if (ret < 0) { log_fatal(logger, MODULE_CONFIG_MONITOR, "[%s:%d] open %s failed.", __FUNCTION__, __LINE__, index->cfg_path); @@ -193,12 +192,8 @@ static int cm_read_table_file(struct cm_table_info_t *index, #define ENLARGE_STEP 1024 int my_scandir(const char *dir, struct dirent ***namelist, int(*filter)(const struct dirent *), - int(*compar)(const void *, const void *)) + int(*compare)(const void *, const void *)) { - int n = 0; - int DIR_ENT_SIZE = ENLARGE_STEP; - struct dirent entry, *result; - if ((NULL == dir) || (NULL == namelist)) { return -1; } @@ -207,25 +202,25 @@ int my_scandir(const char *dir, struct dirent ***namelist, if (NULL == od) { return -1; } - + + int num = 0; + int DIR_ENT_SIZE = ENLARGE_STEP; + struct dirent *entry = NULL; struct dirent **list = ALLOC(struct dirent *, DIR_ENT_SIZE); - while (0 == readdir_r(od, &entry, &result)) { - if (NULL == result) { - break; - } - if (filter && !filter(&entry)) { + while ((entry = readdir(od)) != NULL) { + if (filter && !filter(entry)) { continue; } - + struct dirent *p = ALLOC(struct dirent, 1); - memcpy((void *)p, (void *)(&entry), sizeof(struct dirent)); - list[n] = p; + memcpy((void *)p, (void *)entry, sizeof(struct dirent)); + list[num] = p; - n++; - if (n >= DIR_ENT_SIZE) { - DIR_ENT_SIZE += ENLARGE_STEP; - struct dirent **tmp_list = (struct dirent **)realloc((void*)list, + num++; + if (num >= DIR_ENT_SIZE) { + DIR_ENT_SIZE += ENLARGE_STEP; + struct dirent **tmp_list = (struct dirent **)realloc((void *)list, DIR_ENT_SIZE * sizeof(struct dirent *)); if (tmp_list != NULL) { list = tmp_list; @@ -234,17 +229,18 @@ int my_scandir(const char *dir, struct dirent ***namelist, closedir(od); return -1; } - } - } + } + entry = readdir(od); + } - closedir(od); + closedir(od); *namelist = list; - if (compar) { - qsort((void *)*namelist, n, sizeof(struct dirent *), compar); + if (compare) { + qsort((void *)*namelist, num, sizeof(struct dirent *), compare); } - return n; + return num; } static int filter_fn(const struct dirent *ent) @@ -372,11 +368,13 @@ void config_monitor_traverse(long long current_version, const char *idx_dir, memset(table_array, 0, sizeof(table_array)); - int update_type = get_new_idx_path(current_version, idx_dir, &idx_path_array, &idx_path_num, logger); + int update_type = get_new_idx_path(current_version, idx_dir, &idx_path_array, + &idx_path_num, logger); if (update_type != MAAT_UPDATE_TYPE_INVALID) { for (i = 0; i < idx_path_num; i++) { log_info(logger, MODULE_CONFIG_MONITOR, "load %s", idx_path_array[i]); - int table_num = cm_read_cfg_index_file(idx_path_array[i], table_array, MAX_TABLE_NUM, logger); + int table_num = cm_read_cfg_index_file(idx_path_array[i], table_array, + MAX_TABLE_NUM, logger); if (table_num < 0) { log_fatal(logger, MODULE_CONFIG_MONITOR, "[%s:%d] load %s failed, abandon update", @@ -386,7 +384,9 @@ void config_monitor_traverse(long long current_version, const char *idx_dir, char str_not_care[256] = {0}; const char *table_filename = path2filename(idx_path_array[i]); - sscanf(table_filename, "%[a-zA-Z]_config_index.%lld", str_not_care, &new_version); + sscanf(table_filename, "%[a-zA-Z]_config_index.%lld", + str_not_care, &new_version); + if (start_fn != NULL) { start_fn(new_version, update_type, u_param); } @@ -424,11 +424,11 @@ int load_maat_json_file(struct maat *maat_inst, const char *json_filename, "Maat initial with JSON file %s, formating...", json_filename); - if (strlen(maat_inst->opts.decrypt_key) && strlen(maat_inst->opts.decrypt_algo)) { + if (strlen(maat_inst->opts.decrypt_key) && + strlen(maat_inst->opts.decrypt_algo)) { ret = decrypt_open(json_filename, maat_inst->opts.decrypt_key, - maat_inst->opts.decrypt_algo, - (unsigned char **)&decrypted_buff, - &decrypted_buff_sz, + maat_inst->opts.decrypt_algo, + &decrypted_buff, &decrypted_buff_sz, err_str, err_str_sz); if (ret < 0) { log_fatal(maat_inst->logger, MODULE_CONFIG_MONITOR, diff --git a/src/maat_expr.c b/src/maat_expr.c index 2fa4c25..55fcbe8 100644 --- a/src/maat_expr.c +++ b/src/maat_expr.c @@ -92,15 +92,23 @@ struct expr_runtime { struct maat_kv_store *district_map; struct maat_kv_store *tmp_district_map; - long long *scan_cnt; + long long *scan_times; long long *scan_cpu_time; - long long *hit_cnt; - long long update_err_cnt; long long *scan_bytes; + + long long *hit_times; + long long *hit_item_num; + long long *hit_pattern_num; + + long long update_err_cnt; }; -static enum expr_type int_to_expr_type(int expr_type) -{ +struct expr_runtime_stream { + struct expr_runtime *ref_expr_rt; + struct expr_matcher_stream *handle; +}; + +static enum expr_type int_to_expr_type(int expr_type) { enum expr_type type = EXPR_TYPE_INVALID; switch (expr_type) { @@ -512,11 +520,14 @@ void *expr_runtime_new(void *expr_schema, size_t max_thread_num, expr_rt->engine_type = schema->engine_type; } - expr_rt->hit_cnt = alignment_int64_array_alloc(max_thread_num); - expr_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + expr_rt->scan_times = alignment_int64_array_alloc(max_thread_num); expr_rt->scan_bytes = alignment_int64_array_alloc(max_thread_num); expr_rt->scan_cpu_time = alignment_int64_array_alloc(max_thread_num); + expr_rt->hit_times = alignment_int64_array_alloc(max_thread_num); + expr_rt->hit_item_num = alignment_int64_array_alloc(max_thread_num); + expr_rt->hit_pattern_num = alignment_int64_array_alloc(max_thread_num); + return expr_rt; } @@ -544,9 +555,9 @@ void expr_runtime_free(void *expr_runtime) expr_rt->district_map = NULL; } - if (expr_rt->scan_cnt != NULL) { - alignment_int64_array_free(expr_rt->scan_cnt); - expr_rt->scan_cnt = NULL; + if (expr_rt->scan_times != NULL) { + alignment_int64_array_free(expr_rt->scan_times); + expr_rt->scan_times = NULL; } if (expr_rt->scan_cpu_time != NULL) { @@ -554,16 +565,26 @@ void expr_runtime_free(void *expr_runtime) expr_rt->scan_cpu_time = NULL; } - if (expr_rt->hit_cnt != NULL) { - alignment_int64_array_free(expr_rt->hit_cnt); - expr_rt->hit_cnt = NULL; - } - if (expr_rt->scan_bytes != NULL) { alignment_int64_array_free(expr_rt->scan_bytes); expr_rt->scan_bytes = NULL; } + if (expr_rt->hit_times != NULL) { + alignment_int64_array_free(expr_rt->hit_times); + expr_rt->hit_times = NULL; + } + + if (expr_rt->hit_item_num != NULL) { + alignment_int64_array_free(expr_rt->hit_item_num); + expr_rt->hit_item_num = NULL; + } + + if (expr_rt->hit_pattern_num != NULL) { + alignment_int64_array_free(expr_rt->hit_pattern_num); + expr_rt->hit_pattern_num = NULL; + } + FREE(expr_rt); } @@ -1015,15 +1036,27 @@ int expr_runtime_scan(struct expr_runtime *expr_rt, int thread_id, } size_t n_hit_item = 0; + size_t n_hit_pattern = 0; struct expr_scan_result hit_results[MAX_HIT_ITEM_NUM]; int ret = expr_matcher_match(expr_rt->matcher, thread_id, data, data_len, - hit_results, MAX_HIT_ITEM_NUM, &n_hit_item); + hit_results, MAX_HIT_ITEM_NUM, &n_hit_item, + &n_hit_pattern); if (ret < 0) { return -1; } + if (n_hit_pattern > 0) { + alignment_int64_array_add(expr_rt->hit_pattern_num, state->thread_id, + n_hit_pattern); + } + + if (n_hit_item > 0) { + alignment_int64_array_add(expr_rt->hit_item_num, state->thread_id, + n_hit_item); + } + struct maat_item hit_maat_items[n_hit_item]; - size_t real_hit_item_cnt = 0; + size_t real_hit_item_num = 0; if (0 == n_hit_item) { goto next; @@ -1041,10 +1074,10 @@ int expr_runtime_scan(struct expr_runtime *expr_rt, int thread_id, continue; } - hit_maat_items[real_hit_item_cnt].item_id = item_id; - hit_maat_items[real_hit_item_cnt].group_id = expr_item->group_id; + hit_maat_items[real_hit_item_num].item_id = item_id; + hit_maat_items[real_hit_item_num].group_id = expr_item->group_id; - real_hit_item_cnt++; + real_hit_item_num++; } } @@ -1056,45 +1089,59 @@ next: } return compile_state_update(state->compile_state, state->maat_inst, vtable_id, - state->compile_table_id, state->scan_cnt, - hit_maat_items, real_hit_item_cnt); + state->compile_table_id, state->Nth_scan, + hit_maat_items, real_hit_item_num); } -struct expr_matcher_stream * +struct expr_runtime_stream * expr_runtime_stream_open(struct expr_runtime *expr_rt, int thread_id) { if (NULL == expr_rt || thread_id < 0) { return NULL; } - struct expr_matcher_stream *stream = expr_matcher_stream_open(expr_rt->matcher, - thread_id); - if (NULL == stream) { + struct expr_runtime_stream *expr_rt_stream = ALLOC(struct expr_runtime_stream, 1); + + expr_rt_stream->ref_expr_rt = expr_rt; + expr_rt_stream->handle = expr_matcher_stream_open(expr_rt->matcher, thread_id); + if (NULL == expr_rt_stream->handle) { + FREE(expr_rt_stream); return NULL; } - return stream; + return expr_rt_stream; } -int expr_runtime_stream_scan(struct expr_runtime *expr_rt, - struct expr_matcher_stream *s_handle, +int expr_runtime_stream_scan(struct expr_runtime_stream *expr_rt_stream, const char *data, size_t data_len, int vtable_id, struct maat_state *state) { + struct expr_runtime *expr_rt = expr_rt_stream->ref_expr_rt; if (0 == expr_rt->rule_num) { //empty expr table return 0; } size_t n_hit_item = 0; + size_t n_hit_pattern = 0; struct expr_scan_result hit_results[MAX_HIT_ITEM_NUM]; - int ret = expr_matcher_stream_match(s_handle, data, data_len, hit_results, - MAX_HIT_ITEM_NUM, &n_hit_item); + int ret = expr_matcher_stream_match(expr_rt_stream->handle, data, data_len, hit_results, + MAX_HIT_ITEM_NUM, &n_hit_item, &n_hit_pattern); if (ret < 0) { return -1; } + if (n_hit_pattern > 0) { + alignment_int64_array_add(expr_rt->hit_pattern_num, state->thread_id, + n_hit_pattern); + } + + if (n_hit_item > 0) { + alignment_int64_array_add(expr_rt->hit_item_num, state->thread_id, + n_hit_item); + } + struct maat_item hit_maat_items[n_hit_item]; struct expr_item *expr_item = NULL; size_t real_hit_item_cnt = 0; @@ -1126,27 +1173,22 @@ next: } return compile_state_update(state->compile_state, state->maat_inst, vtable_id, - state->compile_table_id, state->scan_cnt, + state->compile_table_id, state->Nth_scan, hit_maat_items, real_hit_item_cnt); } -void expr_runtime_stream_close(struct expr_runtime *expr_rt, int thread_id, - struct expr_matcher_stream *stream) +void expr_runtime_stream_close(struct expr_runtime_stream *expr_rt_stream) { - if (NULL == expr_rt || thread_id < 0 || NULL == stream) { + if (NULL == expr_rt_stream) { return; } - expr_matcher_stream_close(stream); -} - -void expr_runtime_hit_inc(struct expr_runtime *expr_rt, int thread_id) -{ - if (NULL == expr_rt || thread_id < 0) { - return; + expr_rt_stream->ref_expr_rt = NULL; + if (expr_rt_stream->handle != NULL) { + expr_matcher_stream_close(expr_rt_stream->handle); } - alignment_int64_array_add(expr_rt->hit_cnt, thread_id, 1); + FREE(expr_rt_stream); } void expr_runtime_perf_stat(struct expr_runtime *expr_rt, size_t scan_len, @@ -1157,7 +1199,7 @@ void expr_runtime_perf_stat(struct expr_runtime *expr_rt, size_t scan_len, return; } - alignment_int64_array_add(expr_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(expr_rt->scan_times, thread_id, 1); alignment_int64_array_add(expr_rt->scan_bytes, thread_id, scan_len); if (start != NULL && end != NULL) { @@ -1167,16 +1209,16 @@ void expr_runtime_perf_stat(struct expr_runtime *expr_rt, size_t scan_len, } } -long long expr_runtime_scan_count(void *expr_runtime) +long long expr_runtime_scan_times(void *expr_runtime) { if (NULL == expr_runtime) { return 0; } struct expr_runtime *expr_rt = (struct expr_runtime *)expr_runtime; - long long sum = alignment_int64_array_sum(expr_rt->scan_cnt, + long long sum = alignment_int64_array_sum(expr_rt->scan_times, expr_rt->n_worker_thread); - alignment_int64_array_reset(expr_rt->scan_cnt, expr_rt->n_worker_thread); + alignment_int64_array_reset(expr_rt->scan_times, expr_rt->n_worker_thread); return sum; } @@ -1195,16 +1237,66 @@ long long expr_runtime_scan_cpu_time(void *expr_runtime) return sum; } -long long expr_runtime_hit_count(void *expr_runtime) +void expr_runtime_hit_times_inc(struct expr_runtime *expr_rt, int thread_id) +{ + if (NULL == expr_rt || thread_id < 0) { + return; + } + + alignment_int64_array_add(expr_rt->hit_times, thread_id, 1); +} + +void expr_runtime_stream_hit_times_inc(struct expr_runtime_stream *expr_rt_stream, + int thread_id) +{ + if (NULL == expr_rt_stream || thread_id < 0) { + return; + } + + struct expr_runtime *expr_rt = expr_rt_stream->ref_expr_rt; + alignment_int64_array_add(expr_rt->hit_times, thread_id, 1); +} + +long long expr_runtime_hit_times(void *expr_runtime) +{ + if (NULL == expr_runtime) { + return 0; + } + + struct expr_runtime *expr_rt = (struct expr_runtime *)expr_runtime; + long long sum = alignment_int64_array_sum(expr_rt->hit_times, + expr_rt->n_worker_thread); + alignment_int64_array_reset(expr_rt->hit_times, + expr_rt->n_worker_thread); + + return sum; +} + +long long expr_runtime_hit_item_num(void *expr_runtime) +{ + if (NULL == expr_runtime) { + return 0; + } + + struct expr_runtime *expr_rt = (struct expr_runtime *)expr_runtime; + long long sum = alignment_int64_array_sum(expr_rt->hit_item_num, + expr_rt->n_worker_thread); + alignment_int64_array_reset(expr_rt->hit_item_num, expr_rt->n_worker_thread); + + return sum; +} + +long long expr_runtime_hit_pattern_num(void *expr_runtime) { if (NULL == expr_runtime) { return 0; } struct expr_runtime *expr_rt = (struct expr_runtime *)expr_runtime; - long long sum = alignment_int64_array_sum(expr_rt->hit_cnt, + long long sum = alignment_int64_array_sum(expr_rt->hit_pattern_num, expr_rt->n_worker_thread); - alignment_int64_array_reset(expr_rt->hit_cnt, expr_rt->n_worker_thread); + alignment_int64_array_reset(expr_rt->hit_pattern_num, + expr_rt->n_worker_thread); return sum; } diff --git a/src/maat_flag.c b/src/maat_flag.c index f5a1c4c..4c6ab7d 100644 --- a/src/maat_flag.c +++ b/src/maat_flag.c @@ -56,10 +56,13 @@ struct flag_runtime { struct maat_kv_store *district_map; struct maat_kv_store *tmp_district_map; - long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; long long *scan_cpu_time; - long long *hit_cnt; + + long long *hit_times; + long long *hit_item_num; + + long long update_err_cnt; }; void *flag_schema_new(cJSON *json, struct table_manager *tbl_mgr, @@ -192,10 +195,12 @@ void *flag_runtime_new(void *flag_schema, size_t max_thread_num, flag_rt->logger = logger; flag_rt->district_map = maat_kv_store_new(); - flag_rt->hit_cnt = alignment_int64_array_alloc(max_thread_num); - flag_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + flag_rt->scan_times = alignment_int64_array_alloc(max_thread_num); flag_rt->scan_cpu_time = alignment_int64_array_alloc(max_thread_num); + flag_rt->hit_times = alignment_int64_array_alloc(max_thread_num); + flag_rt->hit_item_num = alignment_int64_array_alloc(max_thread_num); + return flag_rt; } @@ -223,14 +228,9 @@ void flag_runtime_free(void *flag_runtime) flag_rt->district_map = NULL; } - if (flag_rt->hit_cnt != NULL) { - alignment_int64_array_free(flag_rt->hit_cnt); - flag_rt->hit_cnt = NULL; - } - - if (flag_rt->scan_cnt != NULL) { - alignment_int64_array_free(flag_rt->scan_cnt); - flag_rt->scan_cnt = NULL; + if (flag_rt->scan_times != NULL) { + alignment_int64_array_free(flag_rt->scan_times); + flag_rt->scan_times = NULL; } if (flag_rt->scan_cpu_time != NULL) { @@ -238,6 +238,16 @@ void flag_runtime_free(void *flag_runtime) flag_rt->scan_cpu_time = NULL; } + if (flag_rt->hit_times != NULL) { + alignment_int64_array_free(flag_rt->hit_times); + flag_rt->hit_times = NULL; + } + + if (flag_rt->hit_item_num != NULL) { + alignment_int64_array_free(flag_rt->hit_item_num); + flag_rt->hit_item_num = NULL; + } + FREE(flag_rt); } @@ -562,6 +572,11 @@ int flag_runtime_scan(struct flag_runtime *flag_rt, int thread_id, return -1; } + if (n_hit_item > 0) { + alignment_int64_array_add(flag_rt->hit_item_num, state->thread_id, + n_hit_item); + } + struct maat_item hit_maat_items[n_hit_item]; size_t real_hit_item_cnt = 0; @@ -595,19 +610,10 @@ next: } return compile_state_update(state->compile_state, state->maat_inst, vtable_id, - state->compile_table_id, state->scan_cnt, + state->compile_table_id, state->Nth_scan, hit_maat_items, real_hit_item_cnt); } -void flag_runtime_hit_inc(struct flag_runtime *flag_rt, int thread_id) -{ - if (NULL == flag_rt || thread_id < 0) { - return; - } - - alignment_int64_array_add(flag_rt->hit_cnt, thread_id, 1); -} - void flag_runtime_perf_stat(struct flag_runtime *flag_rt, struct timespec *start, struct timespec *end, int thread_id) { @@ -615,7 +621,7 @@ void flag_runtime_perf_stat(struct flag_runtime *flag_rt, struct timespec *start return; } - alignment_int64_array_add(flag_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(flag_rt->scan_times, thread_id, 1); if (start != NULL && end != NULL) { long long consume_time = (end->tv_sec - start->tv_sec) * 1000000000 + @@ -624,44 +630,70 @@ void flag_runtime_perf_stat(struct flag_runtime *flag_rt, struct timespec *start } } -long long flag_runtime_scan_count(void *flag_runtime) +long long flag_runtime_hit_times(void *flag_runtime) { if (NULL == flag_runtime) { return 0; } struct flag_runtime *flag_rt = (struct flag_runtime *)flag_runtime; - long long sum = alignment_int64_array_sum(flag_rt->scan_cnt, + long long sum = alignment_int64_array_sum(flag_rt->hit_times, flag_rt->n_worker_thread); - alignment_int64_array_reset(flag_rt->scan_cnt, flag_rt->n_worker_thread); + alignment_int64_array_reset(flag_rt->hit_times, + flag_rt->n_worker_thread); return sum; } -long long flag_runtime_scan_cpu_time(void *flag_runtime) +void flag_runtime_hit_times_inc(struct flag_runtime *flag_rt, int thread_id) +{ + if (NULL == flag_rt || thread_id < 0) { + return; + } + + alignment_int64_array_add(flag_rt->hit_times, thread_id, 1); +} + +long long flag_runtime_hit_item_num(void *flag_runtime) { if (NULL == flag_runtime) { return 0; } struct flag_runtime *flag_rt = (struct flag_runtime *)flag_runtime; - long long sum = alignment_int64_array_sum(flag_rt->scan_cpu_time, + long long sum = alignment_int64_array_sum(flag_rt->hit_item_num, flag_rt->n_worker_thread); - alignment_int64_array_reset(flag_rt->scan_cpu_time, flag_rt->n_worker_thread); + alignment_int64_array_reset(flag_rt->hit_item_num, + flag_rt->n_worker_thread); + + return sum; +} + +long long flag_runtime_scan_times(void *flag_runtime) +{ + if (NULL == flag_runtime) { + return 0; + } + + struct flag_runtime *flag_rt = (struct flag_runtime *)flag_runtime; + long long sum = alignment_int64_array_sum(flag_rt->scan_times, + flag_rt->n_worker_thread); + alignment_int64_array_reset(flag_rt->scan_times, + flag_rt->n_worker_thread); return sum; } -long long flag_runtime_hit_count(void *flag_runtime) +long long flag_runtime_scan_cpu_time(void *flag_runtime) { if (NULL == flag_runtime) { return 0; } struct flag_runtime *flag_rt = (struct flag_runtime *)flag_runtime; - long long sum = alignment_int64_array_sum(flag_rt->hit_cnt, + long long sum = alignment_int64_array_sum(flag_rt->scan_cpu_time, flag_rt->n_worker_thread); - alignment_int64_array_reset(flag_rt->hit_cnt, flag_rt->n_worker_thread); + alignment_int64_array_reset(flag_rt->scan_cpu_time, flag_rt->n_worker_thread); return sum; } diff --git a/src/maat_fqdn_plugin.c b/src/maat_fqdn_plugin.c index 9100a46..eb1cc6d 100644 --- a/src/maat_fqdn_plugin.c +++ b/src/maat_fqdn_plugin.c @@ -40,7 +40,7 @@ struct fqdn_plugin_runtime { long long rule_num; long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; }; void *fqdn_plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr, @@ -198,7 +198,7 @@ void *fqdn_plugin_runtime_new(void *fqdn_plugin_schema, size_t max_thread_num, fqdn_plugin_rt->n_worker_thread = max_thread_num; fqdn_plugin_rt->ref_garbage_bin = garbage_bin; fqdn_plugin_rt->logger = logger; - fqdn_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + fqdn_plugin_rt->scan_times = alignment_int64_array_alloc(max_thread_num); return fqdn_plugin_rt; } @@ -220,9 +220,9 @@ void fqdn_plugin_runtime_free(void *fqdn_plugin_runtime) fqdn_plugin_rt->ex_data_rt = NULL; } - if (fqdn_plugin_rt->scan_cnt != NULL) { - alignment_int64_array_free(fqdn_plugin_rt->scan_cnt); - fqdn_plugin_rt->scan_cnt = NULL; + if (fqdn_plugin_rt->scan_times != NULL) { + alignment_int64_array_free(fqdn_plugin_rt->scan_times); + fqdn_plugin_rt->scan_times = NULL; } FREE(fqdn_plugin_rt); @@ -596,26 +596,27 @@ long long fqdn_plugin_runtime_update_err_count(void *fqdn_plugin_runtime) return fqdn_plugin_rt->update_err_cnt; } -void fqdn_plugin_runtime_scan_inc(void *fqdn_plugin_runtime, int thread_id) +void fqdn_plugin_runtime_scan_times_inc(void *fqdn_plugin_runtime, int thread_id) { if (NULL == fqdn_plugin_runtime || thread_id < 0) { return; } struct fqdn_plugin_runtime *fqdn_plugin_rt = (struct fqdn_plugin_runtime *)fqdn_plugin_runtime; - alignment_int64_array_add(fqdn_plugin_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(fqdn_plugin_rt->scan_times, thread_id, 1); } -long long fqdn_plugin_runtime_scan_count(void *fqdn_plugin_runtime) +long long fqdn_plugin_runtime_scan_times(void *fqdn_plugin_runtime) { if (NULL == fqdn_plugin_runtime) { return 0; } struct fqdn_plugin_runtime *fqdn_plugin_rt = (struct fqdn_plugin_runtime *)fqdn_plugin_runtime; - long long sum = alignment_int64_array_sum(fqdn_plugin_rt->scan_cnt, + long long sum = alignment_int64_array_sum(fqdn_plugin_rt->scan_times, fqdn_plugin_rt->n_worker_thread); - alignment_int64_array_reset(fqdn_plugin_rt->scan_cnt, fqdn_plugin_rt->n_worker_thread); + alignment_int64_array_reset(fqdn_plugin_rt->scan_times, + fqdn_plugin_rt->n_worker_thread); return sum; }
\ No newline at end of file diff --git a/src/maat_interval.c b/src/maat_interval.c index c0e7700..7216179 100644 --- a/src/maat_interval.c +++ b/src/maat_interval.c @@ -53,10 +53,13 @@ struct interval_runtime { struct maat_kv_store *district_map; struct maat_kv_store *tmp_district_map; - long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; long long *scan_cpu_time; - long long *hit_cnt; + + long long *hit_times; + long long *hit_item_num; + + long long update_err_cnt; }; void *interval_schema_new(cJSON *json, struct table_manager *tbl_mgr, @@ -188,9 +191,10 @@ void *interval_runtime_new(void *interval_schema, size_t max_thread_num, interval_rt->logger = logger; interval_rt->district_map = maat_kv_store_new(); - interval_rt->hit_cnt = alignment_int64_array_alloc(max_thread_num); - interval_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + interval_rt->hit_times = alignment_int64_array_alloc(max_thread_num); + interval_rt->scan_times = alignment_int64_array_alloc(max_thread_num); interval_rt->scan_cpu_time = alignment_int64_array_alloc(max_thread_num); + interval_rt->hit_item_num = alignment_int64_array_alloc(max_thread_num); return interval_rt; } @@ -219,14 +223,14 @@ void interval_runtime_free(void *interval_runtime) interval_rt->district_map = NULL; } - if (interval_rt->hit_cnt != NULL) { - alignment_int64_array_free(interval_rt->hit_cnt); - interval_rt->hit_cnt = NULL; + if (interval_rt->hit_times != NULL) { + alignment_int64_array_free(interval_rt->hit_times); + interval_rt->hit_times = NULL; } - if (interval_rt->scan_cnt != NULL) { - alignment_int64_array_free(interval_rt->scan_cnt); - interval_rt->scan_cnt = NULL; + if (interval_rt->scan_times != NULL) { + alignment_int64_array_free(interval_rt->scan_times); + interval_rt->scan_times = NULL; } if (interval_rt->scan_cpu_time != NULL) { @@ -234,6 +238,11 @@ void interval_runtime_free(void *interval_runtime) interval_rt->scan_cpu_time = NULL; } + if (interval_rt->hit_item_num != NULL) { + alignment_int64_array_free(interval_rt->hit_item_num); + interval_rt->hit_item_num = NULL; + } + FREE(interval_rt); } @@ -563,6 +572,11 @@ int interval_runtime_scan(struct interval_runtime *interval_rt, int thread_id, return -1; } + if (n_hit_item > 0) { + alignment_int64_array_add(interval_rt->hit_item_num, state->thread_id, + n_hit_item); + } + struct maat_item hit_maat_items[n_hit_item]; size_t real_hit_item_cnt = 0; @@ -596,19 +610,10 @@ next: } return compile_state_update(state->compile_state, state->maat_inst, vtable_id, - state->compile_table_id, state->scan_cnt, + state->compile_table_id, state->Nth_scan, hit_maat_items, real_hit_item_cnt); } -void interval_runtime_hit_inc(struct interval_runtime *interval_rt, int thread_id) -{ - if (NULL == interval_rt || thread_id < 0) { - return; - } - - alignment_int64_array_add(interval_rt->hit_cnt, thread_id, 1); -} - void interval_runtime_perf_stat(struct interval_runtime *interval_rt, struct timespec *start, struct timespec *end, int thread_id) @@ -617,7 +622,7 @@ void interval_runtime_perf_stat(struct interval_runtime *interval_rt, return; } - alignment_int64_array_add(interval_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(interval_rt->scan_times, thread_id, 1); if (start != NULL && end != NULL) { long long consume_time = (end->tv_sec - start->tv_sec) * 1000000000 + @@ -626,16 +631,41 @@ void interval_runtime_perf_stat(struct interval_runtime *interval_rt, } } -long long interval_runtime_scan_count(void *interval_runtime) +long long interval_runtime_hit_times(void *interval_runtime) +{ + if (NULL == interval_runtime) { + return 0; + } + + struct interval_runtime *interval_rt = (struct interval_runtime *)interval_runtime; + long long sum = alignment_int64_array_sum(interval_rt->hit_times, + interval_rt->n_worker_thread); + alignment_int64_array_reset(interval_rt->hit_times, + interval_rt->n_worker_thread); + + return sum; +} + +void interval_runtime_hit_times_inc(struct interval_runtime *interval_rt, int thread_id) +{ + if (NULL == interval_rt || thread_id < 0) { + return; + } + + alignment_int64_array_add(interval_rt->hit_times, thread_id, 1); +} + +long long interval_runtime_scan_times(void *interval_runtime) { if (NULL == interval_runtime) { return 0; } struct interval_runtime *interval_rt = (struct interval_runtime *)interval_runtime; - long long sum = alignment_int64_array_sum(interval_rt->scan_cnt, + long long sum = alignment_int64_array_sum(interval_rt->scan_times, interval_rt->n_worker_thread); - alignment_int64_array_reset(interval_rt->scan_cnt, interval_rt->n_worker_thread); + alignment_int64_array_reset(interval_rt->scan_times, + interval_rt->n_worker_thread); return sum; } @@ -649,21 +679,23 @@ long long interval_runtime_scan_cpu_time(void *interval_runtime) struct interval_runtime *interval_rt = (struct interval_runtime *)interval_runtime; long long sum = alignment_int64_array_sum(interval_rt->scan_cpu_time, interval_rt->n_worker_thread); - alignment_int64_array_reset(interval_rt->scan_cpu_time, interval_rt->n_worker_thread); + alignment_int64_array_reset(interval_rt->scan_cpu_time, + interval_rt->n_worker_thread); return sum; } -long long interval_runtime_hit_count(void *interval_runtime) +long long interval_runtime_hit_item_num(void *interval_runtime) { if (NULL == interval_runtime) { return 0; } struct interval_runtime *interval_rt = (struct interval_runtime *)interval_runtime; - long long sum = alignment_int64_array_sum(interval_rt->hit_cnt, + long long sum = alignment_int64_array_sum(interval_rt->hit_item_num, interval_rt->n_worker_thread); - alignment_int64_array_reset(interval_rt->hit_cnt, interval_rt->n_worker_thread); + alignment_int64_array_reset(interval_rt->hit_item_num, + interval_rt->n_worker_thread); return sum; } diff --git a/src/maat_ip.c b/src/maat_ip.c index 2a738c7..28cbda8 100644 --- a/src/maat_ip.c +++ b/src/maat_ip.c @@ -79,10 +79,13 @@ struct ip_runtime { struct log_handle *logger; struct maat_garbage_bin *ref_garbage_bin; - long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; long long *scan_cpu_time; - long long *hit_cnt; + + long long *hit_times; + long long *hit_item_num; + + long long update_err_cnt; }; void *ip_schema_new(cJSON *json, struct table_manager *tbl_mgr, @@ -429,10 +432,12 @@ void *ip_runtime_new(void *ip_schema, size_t max_thread_num, ip_rt->ref_garbage_bin = garbage_bin; ip_rt->logger = logger; - ip_rt->hit_cnt = alignment_int64_array_alloc(max_thread_num); - ip_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + ip_rt->scan_times = alignment_int64_array_alloc(max_thread_num); ip_rt->scan_cpu_time = alignment_int64_array_alloc(max_thread_num); + ip_rt->hit_times = alignment_int64_array_alloc(max_thread_num); + ip_rt->hit_item_num = alignment_int64_array_alloc(max_thread_num); + return ip_rt; } @@ -453,14 +458,9 @@ void ip_runtime_free(void *ip_runtime) ip_rt->item_hash = NULL; } - if (ip_rt->hit_cnt != NULL) { - alignment_int64_array_free(ip_rt->hit_cnt); - ip_rt->hit_cnt = NULL; - } - - if (ip_rt->scan_cnt != NULL) { - alignment_int64_array_free(ip_rt->scan_cnt); - ip_rt->scan_cnt = NULL; + if (ip_rt->scan_times != NULL) { + alignment_int64_array_free(ip_rt->scan_times); + ip_rt->scan_times = NULL; } if (ip_rt->scan_cpu_time != NULL) { @@ -468,6 +468,16 @@ void ip_runtime_free(void *ip_runtime) ip_rt->scan_cpu_time = NULL; } + if (ip_rt->hit_times != NULL) { + alignment_int64_array_free(ip_rt->hit_times); + ip_rt->hit_times = NULL; + } + + if (ip_rt->hit_item_num != NULL) { + alignment_int64_array_free(ip_rt->hit_item_num); + ip_rt->hit_item_num = NULL; + } + FREE(ip_rt); } @@ -760,6 +770,10 @@ int ip_runtime_scan(struct ip_runtime *ip_rt, int thread_id, int ip_type, real_hit_item_cnt++; } + if (real_hit_item_cnt > 0) { + alignment_int64_array_add(ip_rt->hit_item_num, state->thread_id, + real_hit_item_cnt); + } next: if (NULL == state->compile_state) { state->compile_state = compile_state_new(); @@ -768,19 +782,10 @@ next: } return compile_state_update(state->compile_state, state->maat_inst, vtable_id, - state->compile_table_id, state->scan_cnt, + state->compile_table_id, state->Nth_scan, hit_maat_items, real_hit_item_cnt); } -void ip_runtime_hit_inc(struct ip_runtime *ip_rt, int thread_id) -{ - if (NULL == ip_rt || thread_id < 0) { - return; - } - - alignment_int64_array_add(ip_rt->hit_cnt, thread_id, 1); -} - void ip_runtime_perf_stat(struct ip_runtime *ip_rt, struct timespec *start, struct timespec *end, int thread_id) { @@ -788,7 +793,7 @@ void ip_runtime_perf_stat(struct ip_runtime *ip_rt, struct timespec *start, return; } - alignment_int64_array_add(ip_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(ip_rt->scan_times, thread_id, 1); if (start != NULL && end != NULL) { long long consume_time = (end->tv_sec - start->tv_sec) * 1000000000 + @@ -797,15 +802,17 @@ void ip_runtime_perf_stat(struct ip_runtime *ip_rt, struct timespec *start, } } -long long ip_runtime_scan_count(void *ip_runtime) +long long ip_runtime_scan_times(void *ip_runtime) { if (NULL == ip_runtime) { return 0; } struct ip_runtime *ip_rt = (struct ip_runtime *)ip_runtime; - long long sum = alignment_int64_array_sum(ip_rt->scan_cnt, ip_rt->n_worker_thread); - alignment_int64_array_reset(ip_rt->scan_cnt, ip_rt->n_worker_thread); + long long sum = alignment_int64_array_sum(ip_rt->scan_times, + ip_rt->n_worker_thread); + alignment_int64_array_reset(ip_rt->scan_times, + ip_rt->n_worker_thread); return sum; } @@ -824,16 +831,41 @@ long long ip_runtime_scan_cpu_time(void *ip_runtime) return sum; } -long long ip_runtime_hit_count(void *ip_runtime) +long long ip_runtime_hit_times(void *ip_runtime) +{ + if (NULL == ip_runtime) { + return 0; + } + + struct ip_runtime *ip_rt = (struct ip_runtime *)ip_runtime; + long long sum = alignment_int64_array_sum(ip_rt->hit_times, + ip_rt->n_worker_thread); + alignment_int64_array_reset(ip_rt->hit_times, + ip_rt->n_worker_thread); + + return sum; +} + +void ip_runtime_hit_times_inc(struct ip_runtime *ip_rt, int thread_id) +{ + if (NULL == ip_rt || thread_id < 0) { + return; + } + + alignment_int64_array_add(ip_rt->hit_times, thread_id, 1); +} + +long long ip_runtime_hit_item_num(void *ip_runtime) { if (NULL == ip_runtime) { return 0; } struct ip_runtime *ip_rt = (struct ip_runtime *)ip_runtime; - long long sum = alignment_int64_array_sum(ip_rt->hit_cnt, + long long sum = alignment_int64_array_sum(ip_rt->hit_item_num, ip_rt->n_worker_thread); - alignment_int64_array_reset(ip_rt->hit_cnt, ip_rt->n_worker_thread); + alignment_int64_array_reset(ip_rt->hit_item_num, + ip_rt->n_worker_thread); return sum; } diff --git a/src/maat_ip_plugin.c b/src/maat_ip_plugin.c index fa521db..05dad75 100644 --- a/src/maat_ip_plugin.c +++ b/src/maat_ip_plugin.c @@ -43,7 +43,7 @@ struct ip_plugin_runtime { long long rule_num; long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; }; void *ip_plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr, @@ -362,7 +362,7 @@ void *ip_plugin_runtime_new(void *ip_plugin_schema, size_t max_thread_num, ip_plugin_rt->n_worker_thread = max_thread_num; ip_plugin_rt->ref_garbage_bin = garbage_bin; ip_plugin_rt->logger = logger; - ip_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + ip_plugin_rt->scan_times = alignment_int64_array_alloc(max_thread_num); return ip_plugin_rt; } @@ -384,9 +384,9 @@ void ip_plugin_runtime_free(void *ip_plugin_runtime) ip_plugin_rt->ex_data_rt = NULL; } - if (ip_plugin_rt->scan_cnt != NULL) { - alignment_int64_array_free(ip_plugin_rt->scan_cnt); - ip_plugin_rt->scan_cnt = NULL; + if (ip_plugin_rt->scan_times != NULL) { + alignment_int64_array_free(ip_plugin_rt->scan_times); + ip_plugin_rt->scan_times = NULL; } FREE(ip_plugin_rt); @@ -596,26 +596,27 @@ long long ip_plugin_runtime_update_err_count(void *ip_plugin_runtime) return ip_plugin_rt->update_err_cnt; } -void ip_plugin_runtime_scan_inc(void *ip_plugin_runtime, int thread_id) +void ip_plugin_runtime_scan_times_inc(void *ip_plugin_runtime, int thread_id) { if (NULL == ip_plugin_runtime || thread_id < 0) { return; } struct ip_plugin_runtime *ip_plugin_rt = (struct ip_plugin_runtime *)ip_plugin_runtime; - alignment_int64_array_add(ip_plugin_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(ip_plugin_rt->scan_times, thread_id, 1); } -long long ip_plugin_runtime_scan_count(void *ip_plugin_runtime) +long long ip_plugin_runtime_scan_times(void *ip_plugin_runtime) { if (NULL == ip_plugin_runtime) { return 0; } struct ip_plugin_runtime *ip_plugin_rt = (struct ip_plugin_runtime *)ip_plugin_runtime; - long long sum = alignment_int64_array_sum(ip_plugin_rt->scan_cnt, + long long sum = alignment_int64_array_sum(ip_plugin_rt->scan_times, ip_plugin_rt->n_worker_thread); - alignment_int64_array_reset(ip_plugin_rt->scan_cnt, ip_plugin_rt->n_worker_thread); + alignment_int64_array_reset(ip_plugin_rt->scan_times, + ip_plugin_rt->n_worker_thread); return sum; }
\ No newline at end of file diff --git a/src/maat_ipport_plugin.c b/src/maat_ipport_plugin.c index 3bc6d50..eec3548 100644 --- a/src/maat_ipport_plugin.c +++ b/src/maat_ipport_plugin.c @@ -65,7 +65,7 @@ struct ipport_plugin_runtime { long long rule_num; long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; }; void *ipport_plugin_schema_new(cJSON *json, struct table_manager *tbl_mgr, @@ -223,7 +223,7 @@ void *ipport_plugin_runtime_new(void *ipport_plugin_schema, size_t max_thread_nu ipport_plugin_rt->n_worker_thread = max_thread_num; ipport_plugin_rt->ref_garbage_bin = garbage_bin; ipport_plugin_rt->logger = logger; - ipport_plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + ipport_plugin_rt->scan_times = alignment_int64_array_alloc(max_thread_num); return ipport_plugin_rt; } @@ -245,9 +245,9 @@ void ipport_plugin_runtime_free(void *ipport_plugin_runtime) ipport_plugin_rt->ex_data_rt = NULL; } - if (ipport_plugin_rt->scan_cnt != NULL) { - alignment_int64_array_free(ipport_plugin_rt->scan_cnt); - ipport_plugin_rt->scan_cnt = NULL; + if (ipport_plugin_rt->scan_times != NULL) { + alignment_int64_array_free(ipport_plugin_rt->scan_times); + ipport_plugin_rt->scan_times = NULL; } FREE(ipport_plugin_rt); @@ -634,26 +634,27 @@ long long ipport_plugin_runtime_update_err_count(void *ipport_plugin_runtime) return ipport_plugin_rt->update_err_cnt; } -void ipport_plugin_runtime_scan_inc(void *ipport_plugin_runtime, int thread_id) +void ipport_plugin_runtime_scan_times_inc(void *ipport_plugin_runtime, int thread_id) { if (NULL == ipport_plugin_runtime || thread_id < 0) { return; } struct ipport_plugin_runtime *ipport_plugin_rt = (struct ipport_plugin_runtime *)ipport_plugin_runtime; - alignment_int64_array_add(ipport_plugin_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(ipport_plugin_rt->scan_times, thread_id, 1); } -long long ipport_plugin_runtime_scan_count(void *ipport_plugin_runtime) +long long ipport_plugin_runtime_scan_times(void *ipport_plugin_runtime) { if (NULL == ipport_plugin_runtime) { return 0; } struct ipport_plugin_runtime *ipport_plugin_rt = (struct ipport_plugin_runtime *)ipport_plugin_runtime; - long long sum = alignment_int64_array_sum(ipport_plugin_rt->scan_cnt, + long long sum = alignment_int64_array_sum(ipport_plugin_rt->scan_times, ipport_plugin_rt->n_worker_thread); - alignment_int64_array_reset(ipport_plugin_rt->scan_cnt, ipport_plugin_rt->n_worker_thread); + alignment_int64_array_reset(ipport_plugin_rt->scan_times, + ipport_plugin_rt->n_worker_thread); return sum; }
\ No newline at end of file diff --git a/src/maat_plugin.c b/src/maat_plugin.c index ae6cdf8..495ddb7 100644 --- a/src/maat_plugin.c +++ b/src/maat_plugin.c @@ -41,7 +41,7 @@ struct plugin_runtime { long long rule_num; long long acc_line_num; long long update_err_cnt; - long long *scan_cnt; + long long *scan_times; }; enum plugin_key_type { @@ -320,7 +320,7 @@ void *plugin_runtime_new(void *plugin_schema, size_t max_thread_num, plugin_rt->n_worker_thread = max_thread_num; plugin_rt->ref_garbage_bin = garbage_bin; plugin_rt->logger = logger; - plugin_rt->scan_cnt = alignment_int64_array_alloc(max_thread_num); + plugin_rt->scan_times = alignment_int64_array_alloc(max_thread_num); return plugin_rt; } @@ -337,9 +337,9 @@ void plugin_runtime_free(void *plugin_runtime) plugin_rt->ex_data_rt = NULL; } - if (plugin_rt->scan_cnt != NULL) { - alignment_int64_array_free(plugin_rt->scan_cnt); - plugin_rt->scan_cnt = NULL; + if (plugin_rt->scan_times != NULL) { + alignment_int64_array_free(plugin_rt->scan_times); + plugin_rt->scan_times = NULL; } FREE(plugin_rt); @@ -720,26 +720,27 @@ void *plugin_runtime_get_ex_data(void *plugin_runtime, void *plugin_schema, return ex_data_runtime_get_ex_data_by_key(plugin_rt->ex_data_rt, key, key_len); } -void plugin_runtime_scan_inc(void *plugin_runtime, int thread_id) +void plugin_runtime_scan_times_inc(void *plugin_runtime, int thread_id) { if (NULL == plugin_runtime || thread_id < 0) { return; } struct plugin_runtime *plugin_rt = (struct plugin_runtime *)plugin_runtime; - alignment_int64_array_add(plugin_rt->scan_cnt, thread_id, 1); + alignment_int64_array_add(plugin_rt->scan_times, thread_id, 1); } -long long plugin_runtime_scan_count(void *plugin_runtime) +long long plugin_runtime_scan_times(void *plugin_runtime) { if (NULL == plugin_runtime) { return 0; } struct plugin_runtime *plugin_rt = (struct plugin_runtime *)plugin_runtime; - long long sum = alignment_int64_array_sum(plugin_rt->scan_cnt, + long long sum = alignment_int64_array_sum(plugin_rt->scan_times, plugin_rt->n_worker_thread); - alignment_int64_array_reset(plugin_rt->scan_cnt, plugin_rt->n_worker_thread); + alignment_int64_array_reset(plugin_rt->scan_times, + plugin_rt->n_worker_thread); return sum; }
\ No newline at end of file diff --git a/src/maat_stat.c b/src/maat_stat.c index c0dbc36..7e6bda7 100644 --- a/src/maat_stat.c +++ b/src/maat_stat.c @@ -30,6 +30,7 @@ enum MAAT_FS_STATUS { STATUS_PLUGIN_ACC_NUM, STATUS_CLAUSE_REF_NOT_NUM, STATUS_GROUP_REF_EXCL_NUM, //group reference exclude group num + STATUS_HIT_COMPILE_NUM, STATUS_MAAT_STATE_NUM, STATUS_MAAT_PER_STATE_MEM, STATUS_COMPILE_STATE_NUM, @@ -44,17 +45,19 @@ enum MAAT_FS_STATUS { enum MAAT_FS_COLUMN { COLUMN_RULE_NUM = 0, COLUMN_REGEX_NUM, - COLUMN_SCAN_CNT, + COLUMN_SCAN_TIMES, //the times of scan + COLUMN_HIT_TIMES, //the times of hit compile COLUMN_SCAN_BYTES, - COLUMN_CPU_TIME, //microseconds - COLUMN_HIT_CNT, - COLUMN_SCAN_BPS, //scan bytes per second - COLUMN_SCAN_TPS, //scan times per second - COLUMN_HIT_RATE //scan hit rate(hit_cnt/scan_cnt) + COLUMN_SCAN_CPU_TIME, //microseconds + COLUMN_HIT_ITEM_NUM, + COLUMN_HIT_PAT_NUM, //hit pattern num(only valid for expr/expr_plus table) + COLUMN_SCAN_BPS, //scan bytes per second + COLUMN_SCAN_TPS, //scan times per second + COLUMN_HIT_RATE //scan hit rate(hit_times/scan_times) }; -const char *common_column_name[] = {"rule", "reg/v6", "scan_cnt", "scan_bytes", "scan_cpu_time", - "hit_cnt", "IN_Bps", "IN_Tps", "hit_rate"}; +const char *common_column_name[] = {"rule", "reg/v6", "scan_times", "hit_times", "scan_bytes", "scan_cpu_time", + "hit_item_num", "hit_pat_num", "IN_Bps", "IN_Tps", "hit_rate"}; enum field_type common_column_type[] = { FIELD_TYPE_GAUGE, @@ -66,6 +69,8 @@ enum field_type common_column_type[] = { FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE, + FIELD_TYPE_GAUGE, + FIELD_TYPE_GAUGE, FIELD_TYPE_GAUGE }; @@ -88,6 +93,8 @@ static void maat_fieldstat_register(struct maat_stat *stat) "excl_grp", NULL, 0); stat->fs_status_id[STATUS_GARBAGE_QSIZE] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, "garbage_num", NULL, 0); + stat->fs_status_id[STATUS_HIT_COMPILE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, + "hit_compile_num", NULL, 0); stat->fs_status_id[STATUS_MAAT_STATE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, "state_num", NULL, 0); stat->fs_status_id[STATUS_MAAT_PER_STATE_MEM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, @@ -120,23 +127,23 @@ static int maat_fieldstat_table_row_register(struct maat_stat *stat, ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_BPS], stat->total_stat_id[COLUMN_SCAN_BYTES], - stat->total_stat_id[COLUMN_CPU_TIME], 1000000000); + stat->total_stat_id[COLUMN_SCAN_CPU_TIME], 1000000000); if (ret < 0) { log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set IN_Bps for Sum failed."); return -1; } ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_TPS], - stat->total_stat_id[COLUMN_SCAN_CNT], - stat->total_stat_id[COLUMN_CPU_TIME], 1000000000); + stat->total_stat_id[COLUMN_SCAN_TIMES], + stat->total_stat_id[COLUMN_SCAN_CPU_TIME], 1000000000); if (ret < 0) { log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set IN_Tps for Sum failed."); return -1; } ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->total_stat_id[COLUMN_HIT_RATE], - stat->total_stat_id[COLUMN_HIT_CNT], - stat->total_stat_id[COLUMN_SCAN_CNT], 1); + stat->total_stat_id[COLUMN_HIT_TIMES], + stat->total_stat_id[COLUMN_SCAN_TIMES], 1); if (ret < 0) { log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set hit_rate for Sum failed."); return -1; @@ -166,7 +173,7 @@ static int maat_fieldstat_table_row_register(struct maat_stat *stat, ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_BPS], stat->fs_column_id[i][COLUMN_SCAN_BYTES], - stat->fs_column_id[i][COLUMN_CPU_TIME], 1000000000); + stat->fs_column_id[i][COLUMN_SCAN_CPU_TIME], 1000000000); if (ret < 0) { log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set IN_Bps for %s failed.", table_name); @@ -174,8 +181,8 @@ static int maat_fieldstat_table_row_register(struct maat_stat *stat, } ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_TPS], - stat->fs_column_id[i][COLUMN_SCAN_CNT], - stat->fs_column_id[i][COLUMN_CPU_TIME], 1000000000); + stat->fs_column_id[i][COLUMN_SCAN_TIMES], + stat->fs_column_id[i][COLUMN_SCAN_CPU_TIME], 1000000000); if (ret < 0) { log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set IN_Tps for %s failed.", table_name); @@ -183,8 +190,8 @@ static int maat_fieldstat_table_row_register(struct maat_stat *stat, } ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_RATE], - stat->fs_column_id[i][COLUMN_HIT_CNT], - stat->fs_column_id[i][COLUMN_SCAN_CNT], 1); + stat->fs_column_id[i][COLUMN_HIT_TIMES], + stat->fs_column_id[i][COLUMN_SCAN_TIMES], 1); if (ret < 0) { log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set hit_rate for %s failed.", table_name); @@ -205,9 +212,9 @@ struct maat_stat *maat_stat_new(const char *stat_file, size_t max_thread_num, stat->nr_worker_thread = max_thread_num; stat->logger = logger; - stat->stream_num = alignment_int64_array_alloc(max_thread_num); + stat->stream_cnt = alignment_int64_array_alloc(max_thread_num); stat->thread_call_cnt = alignment_int64_array_alloc(max_thread_num); - stat->hit_cnt = alignment_int64_array_alloc(max_thread_num); + stat->hit_compile_cnt = alignment_int64_array_alloc(max_thread_num); stat->maat_state_cnt = alignment_int64_array_alloc(max_thread_num); stat->compile_state_cnt = alignment_int64_array_alloc(max_thread_num); stat->maat_state_free_cnt = alignment_int64_array_alloc(max_thread_num); @@ -222,9 +229,9 @@ void maat_stat_free(struct maat_stat *stat) return; } - if (stat->stream_num != NULL) { - alignment_int64_array_free(stat->stream_num); - stat->stream_num = NULL; + if (stat->stream_cnt != NULL) { + alignment_int64_array_free(stat->stream_cnt); + stat->stream_cnt = NULL; } if (stat->thread_call_cnt != NULL) { @@ -232,9 +239,9 @@ void maat_stat_free(struct maat_stat *stat) stat->thread_call_cnt = NULL; } - if (stat->hit_cnt != NULL) { - alignment_int64_array_free(stat->hit_cnt); - stat->hit_cnt = NULL; + if (stat->hit_compile_cnt != NULL) { + alignment_int64_array_free(stat->hit_compile_cnt); + stat->hit_compile_cnt = NULL; } if (stat->maat_state_cnt != NULL) { @@ -318,9 +325,9 @@ int maat_stat_init(struct maat_stat *stat, struct table_manager *tbl_mgr, static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on) { long long plugin_cache_num = 0, plugin_rule_num = 0; - long long total_rule_num = 0, total_input_bytes = 0; - long long total_scan_cnt = 0, total_scan_cpu_time = 0, total_regex_num = 0; - long long total_ipv6_num = 0, total_hit_cnt = 0, total_update_err = 0; + long long total_rule_num = 0, total_input_bytes = 0, total_update_err = 0; + long long total_scan_times = 0, total_scan_cpu_time = 0, total_regex_num = 0; + long long total_ipv6_num = 0, total_hit_item_num = 0, total_hit_pattern_num = 0; long long g2c_not_clause_num = 0, g2g_excl_rule_num = 0; size_t max_table_count = table_manager_table_size(stat->ref_tbl_mgr); @@ -370,9 +377,9 @@ static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on) fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_RULE_NUM], rule_num); total_rule_num += rule_num; - long long scan_cnt = table_manager_runtime_scan_count(stat->ref_tbl_mgr, i); - fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_CNT], scan_cnt); - total_scan_cnt += scan_cnt; + long long scan_times = table_manager_runtime_scan_times(stat->ref_tbl_mgr, i); + fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_TIMES], scan_times); + total_scan_times += scan_times; if (table_type == TABLE_TYPE_PLUGIN || table_type == TABLE_TYPE_IP_PLUGIN || table_type == TABLE_TYPE_IPPORT_PLUGIN || table_type == TABLE_TYPE_BOOL_PLUGIN || @@ -387,6 +394,11 @@ static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on) fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_BYTES], input_bytes); total_input_bytes += input_bytes; + + long long hit_pattern_num = expr_runtime_hit_pattern_num(runtime); + fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_PAT_NUM], + hit_pattern_num); + total_hit_pattern_num += hit_pattern_num; } if (table_type == TABLE_TYPE_IP_PLUS) { @@ -396,14 +408,14 @@ static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on) if (1 == perf_on) { long long scan_cpu_time = table_manager_runtime_scan_cpu_time(stat->ref_tbl_mgr, i); - fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_CPU_TIME], + fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_CPU_TIME], scan_cpu_time); total_scan_cpu_time += scan_cpu_time; } - long long hit_cnt = table_manager_runtime_hit_count(stat->ref_tbl_mgr, i); - fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_CNT], hit_cnt); - total_hit_cnt += hit_cnt; + long long hit_item_num = table_manager_runtime_hit_item_num(stat->ref_tbl_mgr, i); + fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_ITEM_NUM], hit_item_num); + total_hit_item_num += hit_item_num; total_update_err += table_manager_runtime_update_err_count(stat->ref_tbl_mgr, i); } @@ -412,15 +424,17 @@ static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on) total_rule_num); fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_REGEX_NUM], total_regex_num); - fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_CNT], - total_scan_cnt); - fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_HIT_CNT], - total_hit_cnt); + fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_TIMES], + total_scan_times); + fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_HIT_ITEM_NUM], + total_hit_item_num); + fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_HIT_PAT_NUM], + total_hit_pattern_num); fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_BYTES], total_input_bytes); if (1 == perf_on) { - fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_CPU_TIME], + fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_CPU_TIME], total_scan_cpu_time); } @@ -446,22 +460,25 @@ void maat_stat_output(struct maat_stat *stat, long long maat_version, int perf_o long long active_thread_num = alignment_int64_array_cnt(stat->thread_call_cnt, stat->nr_worker_thread); - long long stream_num = alignment_int64_array_sum(stat->stream_num, - stat->nr_worker_thread); - long long maat_state_cnt = alignment_int64_array_sum(stat->maat_state_cnt, + long long stream_num = alignment_int64_array_sum(stat->stream_cnt, + stat->nr_worker_thread); + long long hit_compile_num = alignment_int64_array_sum(stat->hit_compile_cnt, + stat->nr_worker_thread); + long long maat_state_num = alignment_int64_array_sum(stat->maat_state_cnt, stat->nr_worker_thread); - long long maat_state_free_cnt = alignment_int64_array_sum(stat->maat_state_free_cnt, + long long compile_state_num = alignment_int64_array_sum(stat->compile_state_cnt, + stat->nr_worker_thread); + long long maat_state_free_num = alignment_int64_array_sum(stat->maat_state_free_cnt, stat->nr_worker_thread); long long maat_state_free_bytes = alignment_int64_array_sum(stat->maat_state_free_bytes, stat->nr_worker_thread); - long long compile_state_cnt = alignment_int64_array_sum(stat->compile_state_cnt, - stat->nr_worker_thread); - size_t table_cnt = table_manager_table_count(stat->ref_tbl_mgr); + + size_t table_num = table_manager_table_num(stat->ref_tbl_mgr); size_t garbage_q_len = maat_garbage_bin_get_size(stat->ref_garbage_bin); long long per_state_mem = 0; - if (maat_state_free_cnt != 0) { - per_state_mem = maat_state_free_bytes / maat_state_free_cnt; + if (maat_state_free_num != 0) { + per_state_mem = maat_state_free_bytes / maat_state_free_num; } fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_VERSION], @@ -469,13 +486,15 @@ void maat_stat_output(struct maat_stat *stat, long long maat_version, int perf_o fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_THRED_NUM], active_thread_num); fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_TABLE_NUM], - table_cnt); + table_num); + fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_HIT_COMPILE_NUM], + hit_compile_num); fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_MAAT_STATE_NUM], - maat_state_cnt); + maat_state_num); fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_MAAT_PER_STATE_MEM], per_state_mem); fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_COMPILE_STATE_NUM], - compile_state_cnt); + compile_state_num); fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_CMD_LINE_NUM], stat->line_cmd_acc_num); fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_GARBAGE_QSIZE], diff --git a/src/maat_table.c b/src/maat_table.c index d216a9a..5e7cc5f 100644 --- a/src/maat_table.c +++ b/src/maat_table.c @@ -82,11 +82,13 @@ struct table_operations { long long (*rule_count)(void *runtime); - long long (*scan_count)(void *runtime); + long long (*scan_times)(void *runtime); long long (*scan_cpu_time)(void *runtime); - long long (*hit_count)(void *runtime); + long long (*hit_times)(void *runtime); + + long long (*hit_item_num)(void *runtime); long long (*update_err_count)(void *runtime); }; @@ -101,9 +103,10 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .update_runtime = flag_runtime_update, .commit_runtime = flag_runtime_commit, .rule_count = flag_runtime_rule_count, - .scan_count = flag_runtime_scan_count, + .scan_times = flag_runtime_scan_times, .scan_cpu_time = flag_runtime_scan_cpu_time, - .hit_count = flag_runtime_hit_count, + .hit_times = flag_runtime_hit_times, + .hit_item_num = flag_runtime_hit_item_num, .update_err_count = flag_runtime_update_err_count }, { @@ -115,9 +118,10 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .update_runtime = flag_runtime_update, .commit_runtime = flag_runtime_commit, .rule_count = flag_runtime_rule_count, - .scan_count = flag_runtime_scan_count, + .scan_times = flag_runtime_scan_times, .scan_cpu_time = flag_runtime_scan_cpu_time, - .hit_count = flag_runtime_hit_count, + .hit_times = flag_runtime_hit_times, + .hit_item_num = flag_runtime_hit_item_num, .update_err_count = flag_runtime_update_err_count }, { @@ -129,9 +133,10 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .update_runtime = expr_runtime_update, .commit_runtime = expr_runtime_commit, .rule_count = expr_runtime_rule_count, - .scan_count = expr_runtime_scan_count, + .scan_times = expr_runtime_scan_times, .scan_cpu_time = expr_runtime_scan_cpu_time, - .hit_count = expr_runtime_hit_count, + .hit_times = expr_runtime_hit_times, + .hit_item_num = expr_runtime_hit_item_num, .update_err_count = expr_runtime_update_err_count }, { @@ -143,9 +148,10 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .update_runtime = expr_runtime_update, .commit_runtime = expr_runtime_commit, .rule_count = expr_runtime_rule_count, - .scan_count = expr_runtime_scan_count, + .scan_times = expr_runtime_scan_times, .scan_cpu_time = expr_runtime_scan_cpu_time, - .hit_count = expr_runtime_hit_count, + .hit_times = expr_runtime_hit_times, + .hit_item_num = expr_runtime_hit_item_num, .update_err_count = expr_runtime_update_err_count }, { @@ -157,9 +163,10 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .update_runtime = ip_runtime_update, .commit_runtime = ip_runtime_commit, .rule_count = ip_runtime_rule_count, - .scan_count = ip_runtime_scan_count, + .scan_times = ip_runtime_scan_times, .scan_cpu_time = ip_runtime_scan_cpu_time, - .hit_count = ip_runtime_hit_count, + .hit_times = ip_runtime_hit_times, + .hit_item_num = ip_runtime_hit_item_num, .update_err_count = ip_runtime_update_err_count }, { @@ -171,9 +178,10 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .update_runtime = interval_runtime_update, .commit_runtime = interval_runtime_commit, .rule_count = interval_runtime_rule_count, - .scan_count = interval_runtime_scan_count, + .scan_times = interval_runtime_scan_times, .scan_cpu_time = interval_runtime_scan_cpu_time, - .hit_count = interval_runtime_hit_count, + .hit_times = interval_runtime_hit_times, + .hit_item_num = interval_runtime_hit_item_num, .update_err_count = interval_runtime_update_err_cnt }, { @@ -185,9 +193,10 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .update_runtime = interval_runtime_update, .commit_runtime = interval_runtime_commit, .rule_count = interval_runtime_rule_count, - .scan_count = interval_runtime_scan_count, + .scan_times = interval_runtime_scan_times, .scan_cpu_time = interval_runtime_scan_cpu_time, - .hit_count = interval_runtime_hit_count, + .hit_times = interval_runtime_hit_times, + .hit_item_num = interval_runtime_hit_item_num, .update_err_count = interval_runtime_update_err_cnt }, { @@ -198,7 +207,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .free_runtime = plugin_runtime_free, .update_runtime = plugin_runtime_update, .commit_runtime = plugin_runtime_commit, - .scan_count = plugin_runtime_scan_count, + .scan_times = plugin_runtime_scan_times, .rule_count = plugin_runtime_rule_count, .update_err_count = plugin_runtime_update_err_count }, @@ -210,7 +219,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .free_runtime = ip_plugin_runtime_free, .update_runtime = ip_plugin_runtime_update, .commit_runtime = ip_plugin_runtime_commit, - .scan_count = ip_plugin_runtime_scan_count, + .scan_times = ip_plugin_runtime_scan_times, .rule_count = ip_plugin_runtime_rule_count, .update_err_count = ip_plugin_runtime_update_err_count }, @@ -222,8 +231,8 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .free_runtime = ipport_plugin_runtime_free, .update_runtime = ipport_plugin_runtime_update, .commit_runtime = ipport_plugin_runtime_commit, + .scan_times = ipport_plugin_runtime_scan_times, .rule_count = ipport_plugin_runtime_rule_count, - .scan_count = ipport_plugin_runtime_scan_count, .update_err_count = ipport_plugin_runtime_update_err_count }, { @@ -234,7 +243,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .free_runtime = fqdn_plugin_runtime_free, .update_runtime = fqdn_plugin_runtime_update, .commit_runtime = fqdn_plugin_runtime_commit, - .scan_count = fqdn_plugin_runtime_scan_count, + .scan_times = fqdn_plugin_runtime_scan_times, .rule_count = fqdn_plugin_runtime_rule_count, .update_err_count = fqdn_plugin_runtime_update_err_count }, @@ -246,7 +255,7 @@ struct table_operations table_ops[TABLE_TYPE_MAX] = { .free_runtime = bool_plugin_runtime_free, .update_runtime = bool_plugin_runtime_update, .commit_runtime = bool_plugin_runtime_commit, - .scan_count = bool_plugin_runtime_scan_count, + .scan_times = bool_plugin_runtime_scan_times, .rule_count = bool_plugin_runtime_rule_count, .update_err_count = bool_plugin_runtime_update_err_count }, @@ -1062,7 +1071,7 @@ size_t table_manager_table_size(struct table_manager *tbl_mgr) return MAX_TABLE_NUM; } -size_t table_manager_table_count(struct table_manager *tbl_mgr) +size_t table_manager_table_num(struct table_manager *tbl_mgr) { if (NULL == tbl_mgr) { return 0; @@ -1371,7 +1380,7 @@ long long table_manager_runtime_rule_count(struct table_manager *tbl_mgr, int ta return table_ops[table_type].rule_count(runtime); } -long long table_manager_runtime_scan_count(struct table_manager *tbl_mgr, int table_id) +long long table_manager_runtime_scan_times(struct table_manager *tbl_mgr, int table_id) { void *runtime = table_manager_get_runtime(tbl_mgr, table_id); if (NULL == runtime) { @@ -1386,11 +1395,11 @@ long long table_manager_runtime_scan_count(struct table_manager *tbl_mgr, int ta return 0; } - if (NULL == table_ops[table_type].scan_count) { + if (NULL == table_ops[table_type].scan_times) { return 0; } - return table_ops[table_type].scan_count(runtime); + return table_ops[table_type].scan_times(runtime); } long long table_manager_runtime_scan_cpu_time(struct table_manager *tbl_mgr, int table_id) @@ -1415,7 +1424,7 @@ long long table_manager_runtime_scan_cpu_time(struct table_manager *tbl_mgr, int return table_ops[table_type].scan_cpu_time(runtime); } -long long table_manager_runtime_hit_count(struct table_manager *tbl_mgr, int table_id) +long long table_manager_runtime_hit_item_num(struct table_manager *tbl_mgr, int table_id) { void *runtime = table_manager_get_runtime(tbl_mgr, table_id); if (NULL == runtime) { @@ -1430,11 +1439,11 @@ long long table_manager_runtime_hit_count(struct table_manager *tbl_mgr, int tab return 0; } - if (NULL == table_ops[table_type].hit_count) { + if (NULL == table_ops[table_type].hit_item_num) { return 0; } - return table_ops[table_type].hit_count(runtime); + return table_ops[table_type].hit_item_num(runtime); } long long table_manager_runtime_update_err_count(struct table_manager *tbl_mgr, int table_id) diff --git a/src/maat_utils.c b/src/maat_utils.c index 70c2b60..85d7b68 100644 --- a/src/maat_utils.c +++ b/src/maat_utils.c @@ -266,7 +266,7 @@ int system_cmd_gzip(const char *src_file, const char *dst_file) int system_cmd_encrypt(const char *src_file, const char *dst_file, const char *password) { char cmd[MAX_SYSTEM_CMD_LEN] = { 0 }; - snprintf(cmd, sizeof(cmd), "openssl enc -e -aes-256-cbc -k %s -p -nosalt -in %s -out %s -md md5", + snprintf(cmd, sizeof(cmd), "openssl enc -e -aes-256-cbc -k %s -nosalt -in %s -out %s -md md5", password, src_file, dst_file); return system(cmd); } diff --git a/test/benchmark/benchmark_hs_gtest.cpp b/test/benchmark/benchmark_hs_gtest.cpp index caa6d28..55801c7 100644 --- a/test/benchmark/benchmark_hs_gtest.cpp +++ b/test/benchmark/benchmark_hs_gtest.cpp @@ -25,14 +25,14 @@ #define ARRAY_SIZE 10 #define PERF_THREAD_NUM 5 -#define MAX_SCAN_COUNT 1000000 +#define MAX_SCAN_TIMES 1000000 const char *table_info_path = "./benchmark_table_info.conf"; struct log_handle *g_logger = NULL; struct thread_param { int thread_id; - int test_count; + int test_times; int rule_count; struct maat *maat_inst; const char *table_name; @@ -182,7 +182,7 @@ void *perf_regex_scan_thread(void *arg) int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -195,7 +195,7 @@ void *perf_regex_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d regex_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -246,7 +246,7 @@ void *perf_literal_scan_thread(void *arg) int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -259,7 +259,7 @@ void *perf_literal_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d literal_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -311,7 +311,7 @@ void *perf_stream_scan_thread(void *arg) struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { ret = maat_stream_scan(sp, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -326,7 +326,7 @@ void *perf_stream_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = ((hit_times == param->test_count) ? 1 : 0); + *is_all_hit = ((hit_times == param->test_times) ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d stream_scan time_elapse:%lldms hit_times:%d", @@ -354,7 +354,7 @@ void *perf_ip_scan_thread(void *arg) int proto = 6; clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -367,7 +367,7 @@ void *perf_ip_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d ip_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -420,7 +420,7 @@ void *perf_integer_scan_thread(void *arg) long long scan_data = 1000000; clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_integer(maat_inst, table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -433,7 +433,7 @@ void *perf_integer_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d integer_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -482,7 +482,7 @@ void *perf_flag_scan_thread(void *arg) long long scan_data = 1000000; clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_flag(maat_inst, table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -495,7 +495,7 @@ void *perf_flag_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d flag_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -587,7 +587,7 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 100; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -595,24 +595,24 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex100Scan match rate on %d-threads speed %lld lookups/s/thread", @@ -679,7 +679,7 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 200; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -687,24 +687,24 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex200Scan match rate on %d-threads speed %lld lookups/s/thread", @@ -771,7 +771,7 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 300; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -779,24 +779,24 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex300Scan match rate on %d-threads speed %lld lookups/s/thread", @@ -863,7 +863,7 @@ TEST_F(Regex500BenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 500; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -871,24 +871,24 @@ TEST_F(Regex500BenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex500Scan match rate on %d-threads speed %lld lookups/s/thread", @@ -955,7 +955,7 @@ TEST_F(Regex1KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -963,24 +963,24 @@ TEST_F(Regex1KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1047,7 +1047,7 @@ TEST_F(Regex2KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 2000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1055,24 +1055,24 @@ TEST_F(Regex2KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex2KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1139,7 +1139,7 @@ TEST_F(Regex3KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 3000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1147,24 +1147,24 @@ TEST_F(Regex3KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex3KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1231,7 +1231,7 @@ TEST_F(Regex5KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1239,24 +1239,24 @@ TEST_F(Regex5KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1323,7 +1323,7 @@ TEST_F(Regex10KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1331,24 +1331,24 @@ TEST_F(Regex10KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1415,7 +1415,7 @@ TEST_F(Regex15KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 15000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1423,24 +1423,24 @@ TEST_F(Regex15KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex15KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1508,7 +1508,7 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1516,24 +1516,24 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr1KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1601,7 +1601,7 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1609,24 +1609,24 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr5KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1694,7 +1694,7 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1702,24 +1702,24 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr10KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1787,7 +1787,7 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 50000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1795,24 +1795,24 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr50KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1880,7 +1880,7 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 100000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1888,24 +1888,24 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr100KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1973,7 +1973,7 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 500000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1981,24 +1981,24 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr500KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2066,7 +2066,7 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2074,24 +2074,24 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr1MLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2159,7 +2159,7 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 2000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2167,24 +2167,24 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr2MLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2252,7 +2252,7 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2263,18 +2263,18 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2342,7 +2342,7 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2353,18 +2353,18 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2432,7 +2432,7 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2443,18 +2443,18 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2522,7 +2522,7 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 50000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2533,18 +2533,18 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream50KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2612,7 +2612,7 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 100000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2623,18 +2623,18 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream100KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2702,7 +2702,7 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 500000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2713,18 +2713,18 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream500KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2792,7 +2792,7 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2803,18 +2803,18 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream1MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2882,7 +2882,7 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 2000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2893,18 +2893,18 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream2MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2970,7 +2970,7 @@ TEST_F(IP1KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2978,24 +2978,24 @@ TEST_F(IP1KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3061,7 +3061,7 @@ TEST_F(IP5KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3069,24 +3069,24 @@ TEST_F(IP5KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3152,7 +3152,7 @@ TEST_F(IP10KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3160,24 +3160,24 @@ TEST_F(IP10KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3243,7 +3243,7 @@ TEST_F(IP50KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 50000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3251,24 +3251,24 @@ TEST_F(IP50KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP50KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3334,7 +3334,7 @@ TEST_F(IP100KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 100000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3342,24 +3342,24 @@ TEST_F(IP100KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP100KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3425,7 +3425,7 @@ TEST_F(IP500KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 500000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3433,24 +3433,24 @@ TEST_F(IP500KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP500KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3516,7 +3516,7 @@ TEST_F(IP1MBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3524,24 +3524,24 @@ TEST_F(IP1MBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP1MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3607,7 +3607,7 @@ TEST_F(IP5MBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 5000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3615,24 +3615,24 @@ TEST_F(IP5MBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP5MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3698,7 +3698,7 @@ TEST_F(IP10MBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 10000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3706,24 +3706,24 @@ TEST_F(IP10MBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP10MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3789,7 +3789,7 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3797,24 +3797,24 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Integer1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3880,7 +3880,7 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3888,24 +3888,24 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Integer5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3971,7 +3971,7 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3979,24 +3979,24 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Integer10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -4062,7 +4062,7 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -4070,24 +4070,24 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Flag1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -4153,7 +4153,7 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -4161,24 +4161,24 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Flag5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -4244,7 +4244,7 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_SCAN_TIMES; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -4252,24 +4252,24 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Flag10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -4286,4 +4286,4 @@ int main(int argc, char ** argv) log_handle_destroy(g_logger); return ret; -}
\ No newline at end of file +} diff --git a/test/benchmark/benchmark_rs_gtest.cpp b/test/benchmark/benchmark_rs_gtest.cpp index ae97759..7cbd111 100644 --- a/test/benchmark/benchmark_rs_gtest.cpp +++ b/test/benchmark/benchmark_rs_gtest.cpp @@ -25,14 +25,14 @@ #define ARRAY_SIZE 10 #define PERF_THREAD_NUM 5 -#define MAX_SCAN_COUNT 1000000 +#define MAX_scan_times 1000000 const char *table_info_path = "./benchmark_table_info.conf"; struct log_handle *g_logger = NULL; struct thread_param { int thread_id; - int test_count; + int test_times; int rule_count; struct maat *maat_inst; const char *table_name; @@ -183,7 +183,7 @@ void *perf_literal_scan_thread(void *arg) int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -196,7 +196,7 @@ void *perf_literal_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d literal_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -248,7 +248,7 @@ void *perf_stream_scan_thread(void *arg) struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { ret = maat_stream_scan(sp, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -263,7 +263,7 @@ void *perf_stream_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = ((hit_times == param->test_count) ? 1 : 0); + *is_all_hit = ((hit_times == param->test_times) ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d stream_scan time_elapse:%lldms hit_times:%d", @@ -291,7 +291,7 @@ void *perf_ip_scan_thread(void *arg) int proto = 6; clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, proto, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -304,7 +304,7 @@ void *perf_ip_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d ip_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -357,7 +357,7 @@ void *perf_integer_scan_thread(void *arg) long long scan_data = 1000000; clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_integer(maat_inst, table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -370,7 +370,7 @@ void *perf_integer_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d integer_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -419,7 +419,7 @@ void *perf_flag_scan_thread(void *arg) long long scan_data = 1000000; clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_flag(maat_inst, table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -432,7 +432,7 @@ void *perf_flag_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d flag_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -480,7 +480,7 @@ void *perf_regex_scan_thread(void *arg) int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -493,7 +493,7 @@ void *perf_regex_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_BENCHMARK_GTEST, "thread_id:%d rule_count:%d regex_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->rule_count, param->time_elapse_ms, hit_times); @@ -587,7 +587,7 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 100; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -595,24 +595,24 @@ TEST_F(Regex100BenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex100Scan match rate on %d-threads speed %lld lookups/s/thread", @@ -679,7 +679,7 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 200; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -687,24 +687,24 @@ TEST_F(Regex200BenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex200Scan match rate on %d-threads speed %lld lookups/s/thread", @@ -771,7 +771,7 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 300; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -779,24 +779,24 @@ TEST_F(Regex300BenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Regex300Scan match rate on %d-threads speed %lld lookups/s/thread", @@ -864,7 +864,7 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -872,24 +872,24 @@ TEST_F(Expr1KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr1KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -957,7 +957,7 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -965,24 +965,24 @@ TEST_F(Expr5KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr5KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1050,7 +1050,7 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1058,24 +1058,24 @@ TEST_F(Expr10KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr10KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1143,7 +1143,7 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 50000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1151,24 +1151,24 @@ TEST_F(Expr50KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr50KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1236,7 +1236,7 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 100000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1244,24 +1244,24 @@ TEST_F(Expr100KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr100KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1329,7 +1329,7 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 500000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1337,24 +1337,24 @@ TEST_F(Expr500KBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr500KLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1422,7 +1422,7 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1430,24 +1430,24 @@ TEST_F(Expr1MBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr1MLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1515,7 +1515,7 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 2000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1523,24 +1523,24 @@ TEST_F(Expr2MBenchmarkGTest, LiteralScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_literal_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_literal_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Expr2MLiteralScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1608,7 +1608,7 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1619,18 +1619,18 @@ TEST_F(Stream1KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1698,7 +1698,7 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1709,18 +1709,18 @@ TEST_F(Stream5KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1788,7 +1788,7 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1799,18 +1799,18 @@ TEST_F(Stream10KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1878,7 +1878,7 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 50000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1889,18 +1889,18 @@ TEST_F(Stream50KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream50KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1968,7 +1968,7 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 100000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -1979,18 +1979,18 @@ TEST_F(Stream100KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream100KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2058,7 +2058,7 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 500000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2069,18 +2069,18 @@ TEST_F(Stream500KBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream500KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2148,7 +2148,7 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2159,18 +2159,18 @@ TEST_F(Stream1MBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream1MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2238,7 +2238,7 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 2000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2249,18 +2249,18 @@ TEST_F(Stream2MBenchmarkGTest, LiteralScan) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Stream2MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2328,7 +2328,7 @@ TEST_F(IP1KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2336,24 +2336,24 @@ TEST_F(IP1KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2421,7 +2421,7 @@ TEST_F(IP5KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2429,24 +2429,24 @@ TEST_F(IP5KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2514,7 +2514,7 @@ TEST_F(IP10KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2522,24 +2522,24 @@ TEST_F(IP10KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2607,7 +2607,7 @@ TEST_F(IP50KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 50000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2615,24 +2615,24 @@ TEST_F(IP50KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP50KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2700,7 +2700,7 @@ TEST_F(IP100KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 100000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2708,24 +2708,24 @@ TEST_F(IP100KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP100KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2793,7 +2793,7 @@ TEST_F(IP500KBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 500000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2801,24 +2801,24 @@ TEST_F(IP500KBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP500KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2886,7 +2886,7 @@ TEST_F(IP1MBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2894,24 +2894,24 @@ TEST_F(IP1MBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP1MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -2979,7 +2979,7 @@ TEST_F(IP5MBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 5000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -2987,24 +2987,24 @@ TEST_F(IP5MBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP5MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3071,7 +3071,7 @@ TEST_F(IP10MBenchmarkGTest, IPScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 10000000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3079,24 +3079,24 @@ TEST_F(IP10MBenchmarkGTest, IPScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "IP10MScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3164,7 +3164,7 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3172,24 +3172,24 @@ TEST_F(Integer1KBenchmarkGTest, IntegerScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Integer1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3257,7 +3257,7 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3265,24 +3265,24 @@ TEST_F(Integer5KBenchmarkGTest, IntegerScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Integer5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3350,7 +3350,7 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3358,24 +3358,24 @@ TEST_F(Integer10KBenchmarkGTest, IntegerScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Integer10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3443,7 +3443,7 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 1000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3451,24 +3451,24 @@ TEST_F(Flag1KBenchmarkGTest, FlagScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Flag1KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3536,7 +3536,7 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 5000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3544,24 +3544,24 @@ TEST_F(Flag5KBenchmarkGTest, FlagScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Flag5KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3629,7 +3629,7 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = MAX_SCAN_COUNT; + thread_params[i].test_times = MAX_scan_times; thread_params[i].rule_count = 10000; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -3637,24 +3637,24 @@ TEST_F(Flag10KBenchmarkGTest, FlagScan) { if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_BENCHMARK_GTEST, "Flag10KScan match rate on %d-threads speed %lld lookups/s/thread", @@ -3671,4 +3671,4 @@ int main(int argc, char ** argv) log_handle_destroy(g_logger); return ret; -}
\ No newline at end of file +} diff --git a/test/expr_matcher_gtest.cpp b/test/expr_matcher_gtest.cpp index 1f58fc8..a2364a5 100644 --- a/test/expr_matcher_gtest.cpp +++ b/test/expr_matcher_gtest.cpp @@ -296,33 +296,42 @@ TEST(hs_expr_matcher_match, literal_sub_has_normal_offset) char scan_data1[64] = "hello aaa"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data2[64] = "Ahello aaa"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 101); char scan_data3[64] = "Aahello aaa"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 101); char scan_data4[64] = "Aaahello aaa"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -343,33 +352,42 @@ TEST(rs_expr_matcher_match, literal_sub_has_normal_offset) char scan_data1[64] = "hello aaa"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data2[64] = "Ahello aaa"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 101); char scan_data3[64] = "Aahello aaa"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 101); char scan_data4[64] = "Aaahello aaa"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -383,41 +401,51 @@ TEST(hs_expr_matcher_match, literal_sub_has_left_unlimit_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello bbb"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 102); char scan_data2[64] = "Ahello bbb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 102); char scan_data3[64] = "Aahello bbb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 102); char scan_data4[64] = "Aaahello bbb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -431,41 +459,51 @@ TEST(rs_expr_matcher_match, literal_sub_has_left_unlimit_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello bbb"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 102); char scan_data2[64] = "Ahello bbb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 102); char scan_data3[64] = "Aahello bbb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 102); char scan_data4[64] = "Aaahello bbb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -479,47 +517,59 @@ TEST(hs_expr_matcher_match, literal_sub_has_right_unlimit_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello ccc"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data2[64] = "1234hello ccc"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data3[64] = "12345hello ccc"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 103); char scan_data4[64] = "12345hello cccAaBb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 103); char scan_data5[64] = "123456hello cccAaBb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 103); expr_matcher_free(matcher); @@ -534,47 +584,59 @@ TEST(rs_expr_matcher_match, literal_sub_has_right_unlimit_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello ccc"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data2[64] = "1234hello ccc"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data3[64] = "12345hello ccc"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 103); char scan_data4[64] = "12345hello cccAaBb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 103); char scan_data5[64] = "123456hello cccAaBb"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data5, strlen(scan_data5), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 103); expr_matcher_free(matcher); @@ -589,40 +651,51 @@ TEST(hs_expr_matcher_match, literal_sub_with_no_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello ddd"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 104); char scan_data2[64] = "123hello ddd"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 104); char scan_data3[64] = "123hello ddd456"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 104); char scan_data4[64] = "helloddd"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -636,40 +709,51 @@ TEST(rs_expr_matcher_match, literal_sub_with_no_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello ddd"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 104); char scan_data2[64] = "123hello ddd"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 104); char scan_data3[64] = "123hello ddd456"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 104); char scan_data4[64] = "helloddd"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -683,24 +767,29 @@ TEST(hs_expr_matcher_match, literal_exactly) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello eee"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 105); char scan_data2[64] = "Ahello eee"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); @@ -708,9 +797,11 @@ TEST(hs_expr_matcher_match, literal_exactly) memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -724,34 +815,42 @@ TEST(rs_expr_matcher_match, literal_exactly) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello eee"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 105); char scan_data2[64] = "Ahello eee"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data3[64] = "hello eeeB"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -765,42 +864,52 @@ TEST(hs_expr_matcher_match, literal_prefix) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello fff"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 106); char scan_data2[64] = "Ahello fff"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data3[64] = "Ahello fffBCD"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data4[64] = "hello fffBCD"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 106); expr_matcher_free(matcher); @@ -815,42 +924,52 @@ TEST(rs_expr_matcher_match, literal_prefix) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello fff"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 106); char scan_data2[64] = "Ahello fff"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data3[64] = "Ahello fffBCD"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data4[64] = "hello fffBCD"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 106); expr_matcher_free(matcher); @@ -865,43 +984,53 @@ TEST(hs_expr_matcher_match, literal_suffix) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello ggg"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 107); char scan_data2[64] = "ABChello ggg"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 107); char scan_data3[64] = "ABChello gggDEF"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data4[64] = "hello gggDEF"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -915,43 +1044,53 @@ TEST(rs_expr_matcher_match, literal_suffix) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "hello ggg"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 107); char scan_data2[64] = "ABChello ggg"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 107); char scan_data3[64] = "ABChello gggDEF"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data3, strlen(scan_data3), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); char scan_data4[64] = "hello gggDEF"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data4, strlen(scan_data4), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -965,25 +1104,32 @@ TEST(hs_expr_matcher_match, literal_sub_with_hex) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "Content-Type: /html"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 108); char scan_data2[64] = " html"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -997,25 +1143,32 @@ TEST(rs_expr_matcher_match, literal_sub_with_hex) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char scan_data1[64] = "Content-Type: /html"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 108); char scan_data2[64] = " html"; memset(result, 0, sizeof(result)); n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 0); expr_matcher_free(matcher); matcher = NULL; @@ -1029,16 +1182,21 @@ TEST(hs_expr_matcher_match, literal_with_chinese) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char data0[64] = "#ä¸å›½ ä½ å¥½"; struct expr_scan_result result0[64] = {0}; size_t n_result0 = 0; - ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64, &n_result0); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64, + &n_result0, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result0, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result0[0].rule_id, 110); expr_matcher_free(matcher); @@ -1053,16 +1211,21 @@ TEST(rs_expr_matcher_match, literal_with_chinese) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char data0[64] = "#ä¸å›½ ä½ å¥½"; struct expr_scan_result result0[64] = {0}; size_t n_result0 = 0; - ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64, &n_result0); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, data0, strlen(data0), result0, 64, + &n_result0, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result0, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result0[0].rule_id, 110); expr_matcher_free(matcher); @@ -1077,16 +1240,21 @@ TEST(hs_expr_matcher_match, same_pattern_different_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char data[64] = "onetoday,anothertoday"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64, + &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 3); EXPECT_EQ(result[0].rule_id, 112); expr_matcher_free(matcher); @@ -1101,16 +1269,21 @@ TEST(rs_expr_matcher_match, same_pattern_different_offset) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); char data[64] = "onetoday,anothertoday"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, data, strlen(data), result, 64, + &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 3); EXPECT_EQ(result[0].rule_id, 112); expr_matcher_free(matcher); @@ -1125,7 +1298,8 @@ TEST(hs_expr_matcher_match, long_scan_data) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); @@ -1134,9 +1308,13 @@ sequence of edges which joins a sequence of distinct vertices, but with the adde that the edges be all directed in the same direction."; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 3); EXPECT_EQ(result[0].rule_id, 113); expr_matcher_free(matcher); @@ -1151,7 +1329,8 @@ TEST(rs_expr_matcher_match, long_scan_data) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); @@ -1160,9 +1339,13 @@ sequence of edges which joins a sequence of distinct vertices, but with the adde that the edges be all directed in the same direction."; struct expr_scan_result result[64] = {0}; size_t n_result = 0; - ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result, 64, &n_result); + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, scan_data, strlen(scan_data), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 3); EXPECT_EQ(result[0].rule_id, 113); expr_matcher_free(matcher); @@ -1194,7 +1377,8 @@ TEST(hs_expr_matcher_stream, basic) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); @@ -1203,18 +1387,23 @@ TEST(hs_expr_matcher_stream, basic) struct expr_scan_result result[64] = {0}; size_t n_hit_result = 0; + size_t n_hit_pattern = 0; int thread_id = 0; struct expr_matcher_stream *stream = expr_matcher_stream_open(matcher, thread_id); EXPECT_TRUE(stream != NULL); - ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result, 64, &n_hit_result); + ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result, + 64, &n_hit_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_hit_result, 0); + EXPECT_EQ(n_hit_pattern, 2); - ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result, 64, &n_hit_result); + ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result, + 64, &n_hit_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_hit_result, 1); + EXPECT_EQ(n_hit_pattern, 3); EXPECT_EQ(result[0].rule_id, 113); expr_matcher_stream_close(stream); @@ -1230,7 +1419,8 @@ TEST(rs_expr_matcher_stream, basic) int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); EXPECT_EQ(ret, 0); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); @@ -1239,18 +1429,23 @@ TEST(rs_expr_matcher_stream, basic) struct expr_scan_result result[64] = {0}; size_t n_hit_result = 0; + size_t n_hit_pattern = 0; int thread_id = 0; struct expr_matcher_stream *stream = expr_matcher_stream_open(matcher, thread_id); EXPECT_TRUE(stream != NULL); - ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result, 64, &n_hit_result); + ret = expr_matcher_stream_match(stream, scan_data1, strlen(scan_data1), result, + 64, &n_hit_result, &n_hit_pattern); EXPECT_EQ(ret, 0); EXPECT_EQ(n_hit_result, 0); + EXPECT_EQ(n_hit_pattern, 2); - ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result, 64, &n_hit_result); + ret = expr_matcher_stream_match(stream, scan_data2, strlen(scan_data2), result, + 64, &n_hit_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_hit_result, 1); + EXPECT_EQ(n_hit_pattern, 3); EXPECT_EQ(result[0].rule_id, 113); expr_matcher_stream_close(stream); @@ -1277,9 +1472,12 @@ TEST(hs_expr_matcher, regex_basic) //const char *scan_data2 = "8rain"; struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 114); expr_matcher_free(matcher); @@ -1297,7 +1495,8 @@ TEST(rs_expr_matcher, regex_basic) ret = expr_matcher_verify_regex_expression("[0-9]rain", g_logger); EXPECT_EQ(ret, 1); - struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, 1, g_logger); + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_RS, + 1, g_logger); EXPECT_TRUE(matcher != NULL); expr_array_free(rules, n_rule); @@ -1306,14 +1505,53 @@ TEST(rs_expr_matcher, regex_basic) struct expr_scan_result result[64] = {0}; size_t n_result = 0; + size_t n_hit_pattern = 0; - ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, 64, &n_result); + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); EXPECT_EQ(ret, 1); EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 1); EXPECT_EQ(result[0].rule_id, 114); expr_matcher_free(matcher); - matcher = NULL; + matcher = NULL; +} + +TEST(hs_expr_matcher, hit_pattern_num) +{ + struct expr_rule rules[64] = {0}; + size_t n_rule = 0; + + int ret = parse_config_file("./literal_expr.conf", rules, &n_rule); + EXPECT_EQ(ret, 0); + + struct expr_matcher *matcher = expr_matcher_new(rules, n_rule, EXPR_ENGINE_TYPE_HS, + 1, g_logger); + EXPECT_TRUE(matcher != NULL); + expr_array_free(rules, n_rule); + + const char *scan_data1 = "string has one two"; + const char *scan_data2 = "string has one two three"; + struct expr_scan_result result[64] = {0}; + size_t n_result = 0; + size_t n_hit_pattern = 0; + + ret = expr_matcher_match(matcher, 0, scan_data1, strlen(scan_data1), result, + 64, &n_result, &n_hit_pattern); + EXPECT_EQ(ret, 0); + EXPECT_EQ(n_result, 0); + EXPECT_EQ(n_hit_pattern, 2); + + ret = expr_matcher_match(matcher, 0, scan_data2, strlen(scan_data2), result, + 64, &n_result, &n_hit_pattern); + EXPECT_EQ(ret, 1); + EXPECT_EQ(n_result, 1); + EXPECT_EQ(n_hit_pattern, 3); + EXPECT_EQ(result[0].rule_id, 115); + + expr_matcher_free(matcher); + matcher = NULL; } int main(int argc, char **argv) diff --git a/test/ipport_plugin/ipport_plugin_gtest.cpp b/test/ipport_plugin/ipport_plugin_gtest.cpp index 54c449b..1b5f73c 100644 --- a/test/ipport_plugin/ipport_plugin_gtest.cpp +++ b/test/ipport_plugin/ipport_plugin_gtest.cpp @@ -11,7 +11,7 @@ #define MODULE_IPPORT_PLUGIN_GTEST module_name_str("maat.ipport_plugin_gtest") #define ARRAY_SIZE 10 -#define PERF_SCAN_COUNT 1000 * 1000 +#define PERF_scan_times 1000 * 1000 const char *table_info_path = "./ipport_plugin_table_info.conf"; const char *log_file = "./ipport_plugin_gtest.log"; @@ -252,15 +252,18 @@ void *ipport_plugin_scan_thread(void *arg) return is_all_hit; } -static void test_add_ipport_plugin_command(struct maat *maat_inst, const char *table_name, +static int test_add_ipport_plugin_command(struct maat *maat_inst, const char *table_name, long long item_id, const char *ip_str, int port1, int port2) { int table_id = maat_get_table_id(maat_inst, table_name); - assert(table_id >= 0); - - enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); - assert(table_type == TABLE_TYPE_IPPORT_PLUGIN); + if (table_id < 0) { + return -1; + } + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); + if (table_type != TABLE_TYPE_IPPORT_PLUGIN) { + return -1; + } char table_line[1024] = {0}; sprintf(table_line, "%lld\t4\t%s\t%d\t%d\t1", item_id, ip_str, port1, port2); @@ -272,17 +275,22 @@ static void test_add_ipport_plugin_command(struct maat *maat_inst, const char *t line_rule.expire_after = 0; maat_cmd_set_line(maat_inst, &line_rule); + + return 0; } -static void test_del_ipport_plugin_command(struct maat *maat_inst, const char *table_name, +static int test_del_ipport_plugin_command(struct maat *maat_inst, const char *table_name, long long item_id, const char *ip_str, int port1, int port2) { int table_id = maat_get_table_id(maat_inst, table_name); - assert(table_id >= 0); - - enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); - assert(table_type == TABLE_TYPE_IPPORT_PLUGIN); + if (table_id < 0) { + return -1; + } + enum table_type table_type = table_manager_get_table_type(maat_inst->tbl_mgr, table_id); + if (table_type != TABLE_TYPE_IPPORT_PLUGIN) { + return -1; + } char table_line[1024] = {0}; sprintf(table_line, "%lld\t4\t%s\t%d\t%d\t0", item_id, ip_str, port1, port2); @@ -294,6 +302,8 @@ static void test_del_ipport_plugin_command(struct maat *maat_inst, const char *t line_rule.expire_after = 0; maat_cmd_set_line(maat_inst, &line_rule); + + return 0; } void *ipport_plugin_update_thread(void *arg) @@ -303,16 +313,29 @@ void *ipport_plugin_update_thread(void *arg) const char *table_name = param->table_name; const int CMD_EXPR_NUM = 256; long long item_id = 9000000; + int ret = 0; for (int i = 0; i < CMD_EXPR_NUM; i++) { - test_add_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201); + ret = test_add_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201); + if (ret < 0) { + log_fatal(param->logger, MODULE_IPPORT_PLUGIN_GTEST, + "[%s:%d]add ipport rule(item_id:%lld) for table:%s failed.", + __FUNCTION__, __LINE__, item_id, table_name); + continue; + } item_id++; usleep(100 * 1000); } item_id = 9000000; for (int i = 0; i < CMD_EXPR_NUM; i++) { - test_del_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201); + ret = test_del_ipport_plugin_command(maat_inst, table_name, item_id, g_ip_str, i+201, i+201); + if (ret < 0) { + log_fatal(param->logger, MODULE_IPPORT_PLUGIN_GTEST, + "[%s:%d]del ipport rule(item_id:%lld) for table:%s failed.", + __FUNCTION__, __LINE__, item_id, table_name); + continue; + } usleep(100 * 1000); item_id++; } @@ -364,7 +387,7 @@ TEST_F(IPPortPluginTable, WITHOUT_SAME_IP) { thread_params[i].thread_id = i; thread_params[i].table_name = table_name; thread_params[i].port = 10; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_count = PERF_scan_times; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; } @@ -385,7 +408,7 @@ TEST_F(IPPortPluginTable, WITHOUT_SAME_IP) { } maat_free(maat_inst); - scan_per_second = PERF_SCAN_COUNT * 1000 / time_elapse_ms; + scan_per_second = PERF_scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_IPPORT_PLUGIN_GTEST, "IpportPluginScan without same ip match rate speed %lld lookups/s/thread", scan_per_second); @@ -432,7 +455,7 @@ TEST_F(IPPortPluginTable, WITH_256SAME_IP) { thread_params[i].thread_id = i; thread_params[i].table_name = table_name; thread_params[i].port = 10; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_count = PERF_scan_times; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; } @@ -453,7 +476,7 @@ TEST_F(IPPortPluginTable, WITH_256SAME_IP) { } maat_free(maat_inst); - scan_per_second = PERF_SCAN_COUNT * 1000 / time_elapse_ms; + scan_per_second = PERF_scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_IPPORT_PLUGIN_GTEST, "IpportPluginScan with 256 same ip match rate speed %lld lookups/s/thread", scan_per_second); @@ -466,4 +489,4 @@ int main(int argc, char ** argv) ret = RUN_ALL_TESTS(); return ret; -}
\ No newline at end of file +} diff --git a/test/literal_expr.conf b/test/literal_expr.conf index 7bb2db6..2b5e6cd 100644 --- a/test/literal_expr.conf +++ b/test/literal_expr.conf @@ -124,7 +124,7 @@ "match_method": "sub", "case_sensitive": "yes", "is_hexbin": "no", - "pattern": "pat" + "pattern": "directed graph" } ] }, @@ -178,7 +178,7 @@ }, { "expr_id": 113, - "pattern_num": 1, + "pattern_num": 2, "patterns": [ { "pattern_type": "literal", @@ -186,6 +186,13 @@ "case_sensitive": "yes", "is_hexbin": "no", "pattern": "a finite or infinite" + }, + { + "pattern_type": "literal", + "match_method": "sub", + "case_sensitive": "yes", + "is_hexbin": "no", + "pattern": "directed path" } ] }, @@ -201,6 +208,33 @@ "pattern": "query=(.*)" } ] + }, + { + "expr_id": 115, + "pattern_num": 3, + "patterns": [ + { + "pattern_type": "literal", + "match_method": "sub", + "case_sensitive": "yes", + "is_hexbin": "no", + "pattern": "one" + }, + { + "pattern_type": "literal", + "match_method": "sub", + "case_sensitive": "yes", + "is_hexbin": "no", + "pattern": "two" + }, + { + "pattern_type": "literal", + "match_method": "sub", + "case_sensitive": "yes", + "is_hexbin": "no", + "pattern": "three" + } + ] } ] } diff --git a/test/maat_framework_gtest.cpp b/test/maat_framework_gtest.cpp index e57d7fc..76a8631 100644 --- a/test/maat_framework_gtest.cpp +++ b/test/maat_framework_gtest.cpp @@ -9005,8 +9005,8 @@ TEST_F(MaatCmdTest, HitGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - size_t scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 1); + size_t scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 1); struct maat_hit_group hit_groups[128]; memset(hit_groups, 0, sizeof(hit_groups)); @@ -9052,8 +9052,8 @@ TEST_F(MaatCmdTest, HitGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 2); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 2); memset(hit_groups, 0, sizeof(hit_groups)); n_hit_group = maat_state_get_direct_hit_group_cnt(state); @@ -9088,8 +9088,8 @@ TEST_F(MaatCmdTest, HitGroup) { ret = maat_stream_scan(stream, keywords1, strlen(keywords1), results, ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 3); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 3); int ip_table_id = maat_get_table_id(maat_inst, ip_table_name); ASSERT_GT(ip_table_id, 0); @@ -9105,8 +9105,8 @@ TEST_F(MaatCmdTest, HitGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 4); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 4); memset(hit_groups, 0, sizeof(hit_groups)); n_hit_group = maat_state_get_direct_hit_group_cnt(state); @@ -9125,23 +9125,28 @@ TEST_F(MaatCmdTest, HitGroup) { ARRAY_SIZE, &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_HALF_HIT); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 5); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 5); memset(hit_groups, 0, sizeof(hit_groups)); n_hit_group = maat_state_get_direct_hit_group_cnt(state); maat_state_get_direct_hit_groups(state, hit_groups, n_hit_group); - EXPECT_EQ(n_hit_group, 1); + EXPECT_EQ(n_hit_group, 2); EXPECT_EQ(hit_groups[0].item_id, item5_id); EXPECT_EQ(hit_groups[0].group_id, group1_id); EXPECT_EQ(hit_groups[0].vtable_id, keywords_table_id); //physical table(keywords_table) vtable_id is 0 + EXPECT_EQ(hit_groups[1].item_id, item4_id); + EXPECT_EQ(hit_groups[1].group_id, group4_id); + EXPECT_EQ(hit_groups[1].vtable_id, keywords_table_id); //physical table(keywords_table) vtable_id is 0 + n_last_hit_group = maat_state_get_last_hit_group_id_cnt(state); maat_state_get_last_hit_group_ids(state, last_hit_group_ids, 128); - EXPECT_EQ(n_last_hit_group, 2); + EXPECT_EQ(n_last_hit_group, 3); EXPECT_EQ(last_hit_group_ids[0], group1_id); - EXPECT_EQ(last_hit_group_ids[1], group11_id); + EXPECT_EQ(last_hit_group_ids[1], group4_id); + EXPECT_EQ(last_hit_group_ids[2], group11_id); maat_stream_free(stream); maat_state_free(state); @@ -9263,8 +9268,8 @@ TEST_F(MaatCmdTest, HitPathBasic) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - size_t scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 1); + size_t scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 1); struct maat_hit_path hit_path[128]; memset(hit_path, 0, sizeof(hit_path)); @@ -9306,8 +9311,8 @@ TEST_F(MaatCmdTest, HitPathBasic) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 2); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 2); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 4); @@ -9364,8 +9369,8 @@ that the edges be all directed in the same direction."; &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 3); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 3); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 5); @@ -9394,8 +9399,8 @@ that the edges be all directed in the same direction."; &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 4); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 4); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 6); @@ -9418,8 +9423,8 @@ that the edges be all directed in the same direction."; &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 5); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 5); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 7); @@ -9927,8 +9932,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - size_t scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 1); + size_t scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 1); struct maat_hit_path hit_path[128]; memset(hit_path, 0, sizeof(hit_path)); @@ -9972,8 +9977,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 2); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 2); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 4); @@ -10031,8 +10036,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 3); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 3); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 5); @@ -10062,8 +10067,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 4); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 4); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 6); @@ -10087,8 +10092,8 @@ TEST_F(MaatCmdTest, HitPathHasNotGroup) { &n_hit_result, state); EXPECT_EQ(ret, MAAT_SCAN_OK); - scan_count = maat_state_get_scan_count(state); - EXPECT_EQ(scan_count, 5); + scan_times = maat_state_get_scan_count(state); + EXPECT_EQ(scan_times, 5); n_read = maat_state_get_hit_paths(state, hit_path, sizeof(hit_path)); EXPECT_EQ(n_read, 7); diff --git a/test/maat_framework_perf_gtest.cpp b/test/maat_framework_perf_gtest.cpp index 89393a5..3084759 100644 --- a/test/maat_framework_perf_gtest.cpp +++ b/test/maat_framework_perf_gtest.cpp @@ -15,14 +15,14 @@ #define ARRAY_SIZE 10 #define WAIT_FOR_EFFECTIVE_S 2 #define PERF_THREAD_NUM 5 -#define PERF_SCAN_COUNT 1000 * 1000 +#define PERF_SCAN_TIMES 1000 * 1000 const char *table_info_path = "./table_info.conf"; const char *json_filename = "maat_json.json"; struct thread_param { int thread_id; - int test_count; + int test_times; struct maat *maat_inst; const char *table_name; long long time_elapse_ms; @@ -449,7 +449,7 @@ void *perf_string_scan_thread(void *arg) struct timespec start, end; clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -462,7 +462,7 @@ void *perf_string_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d string_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->time_elapse_ms, hit_times); @@ -505,31 +505,31 @@ TEST_F(MaatPerfStringScan, LiteralMultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_string_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_string_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "StringScan match rate on %d-threads speed %lld lookups/s/thread", PERF_THREAD_NUM, scan_per_second); @@ -599,7 +599,7 @@ void *perf_regex_scan_thread(void *arg) maat_register_thread(maat_inst); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -612,7 +612,7 @@ void *perf_regex_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d regex_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->time_elapse_ms, hit_times); @@ -655,31 +655,31 @@ TEST_F(MaatPerfRegexScan, RegexMultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "RegexScan match rate on %d-threads speed %lld lookups/s/thread", @@ -701,7 +701,7 @@ void *perf_integer_scan_thread(void *arg) maat_register_thread(maat_inst); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_integer(maat_inst, table_id, 3000, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -714,7 +714,7 @@ void *perf_integer_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d integer_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->time_elapse_ms, hit_times); @@ -804,7 +804,7 @@ void *perf_stream_scan_thread(void *arg) maat_register_thread(maat_inst); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { ret = maat_stream_scan(sp, scan_data, strlen(scan_data), results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -819,7 +819,7 @@ void *perf_stream_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = ((hit_times == param->test_count) ? 1 : 0); + *is_all_hit = ((hit_times == param->test_times) ? 1 : 0); log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d stream_scan time_elapse:%lldms hit_times:%d", @@ -843,7 +843,7 @@ TEST_F(MaatPerfStreamScan, MultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; @@ -853,17 +853,17 @@ TEST_F(MaatPerfStreamScan, MultiThread) { } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; //maybe expr_runtime rebuild in stream_scan, so should not expect is_all_hit always 1 EXPECT_EQ(*is_all_hit, 1); free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "StreamScan match rate on %d-threads speed %lld lookups/s/thread", @@ -939,7 +939,7 @@ void *perf_ip_scan_thread(void *arg) maat_register_thread(maat_inst); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, port, 6, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -952,7 +952,7 @@ void *perf_ip_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d ip_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->time_elapse_ms, hit_times); @@ -1006,31 +1006,31 @@ TEST_F(MaatPerfIPScan, MultiThread) thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ip_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ip_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "IPScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1101,31 +1101,31 @@ TEST_F(MaatPerfIntegerScan, MultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "IntegerScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1195,7 +1195,7 @@ void *perf_flag_scan_thread(void *arg) int table_id = maat_get_table_id(maat_inst, table_name); clock_gettime(CLOCK_MONOTONIC, &start); - for (int i = 0; i < param->test_count; i++) { + for (int i = 0; i < param->test_times; i++) { int ret = maat_scan_flag(maat_inst, table_id, scan_data, results, ARRAY_SIZE, &n_hit_result, state); if (ret == MAAT_SCAN_HIT) { @@ -1208,7 +1208,7 @@ void *perf_flag_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int *is_all_hit = ALLOC(int, 1); - *is_all_hit = (hit_times == param->test_count ? 1 : 0); + *is_all_hit = (hit_times == param->test_times ? 1 : 0); log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d flag_scan time_elapse:%lldms hit_times:%d", param->thread_id, param->time_elapse_ms, hit_times); @@ -1249,31 +1249,31 @@ TEST_F(MaatPerfFlagScan, MultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "FlagScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1382,7 +1382,7 @@ void* perf_fqdn_plugin_scan_thread(void *arg) struct timespec start, end; clock_gettime(CLOCK_MONOTONIC, &start); - for (i = 0; i < param->test_count; i++) { + for (i = 0; i < param->test_times; i++) { ret = maat_fqdn_plugin_table_get_ex_data(maat_inst, table_id, "r3---sn-i3belne6.example2.com", @@ -1396,7 +1396,7 @@ void* perf_fqdn_plugin_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int* is_all_hit = (int*)malloc(sizeof(int)); - *is_all_hit = (hit_times == param->test_count) ? 1 : 0; + *is_all_hit = (hit_times == param->test_times) ? 1 : 0; log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d fqdn_plugin_get_ex_data time_elapse:%lldms hit_times:%d", param->thread_id, param->time_elapse_ms, hit_times); @@ -1477,31 +1477,31 @@ TEST_F(MaatPerfFQDNPluginScan, MultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_fqdn_plugin_scan_thread, thread_params + i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_fqdn_plugin_update_thread, thread_params + i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "FQDNPluginScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1613,7 +1613,7 @@ void* perf_bool_plugin_scan_thread(void *arg) unsigned long long items_4[]={7, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7}; clock_gettime(CLOCK_MONOTONIC, &start); - for (i = 0; i < param->test_count; i++) { + for (i = 0; i < param->test_times; i++) { ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_4, sizeof(items_4)/sizeof(unsigned long long), @@ -1627,7 +1627,7 @@ void* perf_bool_plugin_scan_thread(void *arg) param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000; int* is_all_hit = (int*)malloc(sizeof(int)); - *is_all_hit = (hit_times == param->test_count) ? 1 : 0; + *is_all_hit = (hit_times == param->test_times) ? 1 : 0; log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, "thread_id:%d bool_plugin_get_ex_data time_elapse:%lldms hit_times:%d", @@ -1685,31 +1685,31 @@ TEST_F(MaatPerfBoolPluginScan, MultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_bool_plugin_scan_thread, thread_params + i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_bool_plugin_update_thread, thread_params + i); } } long long time_elapse_ms = 0; - long long scan_count = 0; + long long scan_times = 0; long long scan_per_second = 0; for (i = 0; i < PERF_THREAD_NUM + 1; i++) { pthread_join(threads[i], (void **)&is_all_hit); time_elapse_ms += thread_params[i].time_elapse_ms; - scan_count += thread_params[i].test_count; + scan_times += thread_params[i].test_times; EXPECT_EQ(*is_all_hit, 1); *is_all_hit = 0; free(is_all_hit); } - scan_per_second = scan_count * 1000 / time_elapse_ms; + scan_per_second = scan_times * 1000 / time_elapse_ms; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "BoolPluginScan match rate on %d-threads speed %lld lookups/s/thread", @@ -1990,7 +1990,7 @@ static void *perf_ipport_plugin_scan_thread(void *arg) inet_pton(AF_INET, "192.168.100.1", &ipv4.ipv4); uint16_t port = htons(215); - for (i = 0; i < param->test_count; i++) { + for (i = 0; i < param->test_times; i++) { ret = maat_ipport_plugin_table_get_ex_data(maat_inst, table_id, &ipv4, port, (void**)results, 4); if (ret > 0) { @@ -1999,7 +1999,7 @@ static void *perf_ipport_plugin_scan_thread(void *arg) } int *is_all_hit = (int *)malloc(sizeof(int)); - *is_all_hit = (hit_times == param->test_count) ? 1 : 0; + *is_all_hit = (hit_times == param->test_times) ? 1 : 0; log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST, "ipport_plugin_get_ex_data hit_times:%d", hit_times); @@ -2056,14 +2056,14 @@ TEST_F(MaatPerfIPPortPluginScan, MultiThread) { thread_params[i].maat_inst = maat_inst; thread_params[i].thread_id = i; thread_params[i].table_name = table_name; - thread_params[i].test_count = PERF_SCAN_COUNT; + thread_params[i].test_times = PERF_SCAN_TIMES; thread_params[i].time_elapse_ms = 0; thread_params[i].logger = logger; if (i < PERF_THREAD_NUM) { pthread_create(&threads[i], NULL, perf_ipport_plugin_scan_thread, thread_params+i); } else { - thread_params[i].test_count = 0; + thread_params[i].test_times = 0; pthread_create(&threads[i], NULL, perf_ipport_plugin_update_thread, thread_params+i); } } @@ -2084,4 +2084,4 @@ int main(int argc, char ** argv) ret=RUN_ALL_TESTS(); return ret; -}
\ No newline at end of file +} |