1798 lines
62 KiB
C++
1798 lines
62 KiB
C++
#include <gtest/gtest.h>
|
|
|
|
#include "test_utils.h"
|
|
#include "log/log.h"
|
|
#include "maat.h"
|
|
#include "maat_core.h"
|
|
#include "maat_utils.h"
|
|
#include "ip_matcher.h"
|
|
#include "maat_command.h"
|
|
#include "json2iris.h"
|
|
#include "maat_config_monitor.h"
|
|
#include "maat_redis_monitor.h"
|
|
|
|
#define MODULE_FRAMEWORK_PERF_GTEST module_name_str("maat.framework_perf_gtest")
|
|
|
|
#define ARRAY_SIZE 10
|
|
#define WAIT_FOR_EFFECTIVE_S 2
|
|
#define PERF_THREAD_NUM 5
|
|
#define PERF_SCAN_TIMES 1000 * 1000
|
|
|
|
const char *g_table_info_path = "./table_info.json";
|
|
const char *g_json_filename = "maat_json.json";
|
|
|
|
struct thread_param {
|
|
int thread_id;
|
|
int test_times;
|
|
struct maat *maat_inst;
|
|
const char *table_name;
|
|
long long time_elapse_ms;
|
|
struct log_handle *logger;
|
|
};
|
|
|
|
static void
|
|
test_add_expr_command(struct maat *maat_inst, const char *table_name,
|
|
const char *keywords)
|
|
{
|
|
long long rule_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
|
|
int ret = rule_table_set_line(maat_inst, "RULE_DEFAULT",
|
|
MAAT_OP_ADD, rule_id, "null",
|
|
1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long object_id = maat_cmd_incrby(maat_inst, "SEQUENCE_OBJECT", 1);
|
|
ret = object2rule_table_set_line(maat_inst, "OBJECT2RULE_DEFAULT",
|
|
MAAT_OP_ADD, object_id, rule_id,
|
|
0, table_name, 1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1);
|
|
ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id,
|
|
object_id, keywords, "null", 1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
}
|
|
|
|
static void
|
|
test_add_ip_command(struct maat *maat_inst, const char *table_name,
|
|
const char *ip)
|
|
{
|
|
long long rule_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
|
|
int ret = rule_table_set_line(maat_inst, "RULE_DEFAULT",
|
|
MAAT_OP_ADD, rule_id, "null",
|
|
1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long object_id = maat_cmd_incrby(maat_inst, "SEQUENCE_OBJECT", 1);
|
|
ret = object2rule_table_set_line(maat_inst, "OBJECT2RULE_DEFAULT",
|
|
MAAT_OP_ADD, object_id, rule_id,
|
|
0, table_name, 1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1);
|
|
ret = ip_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id,
|
|
object_id, ip, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
}
|
|
|
|
static void
|
|
test_add_integer_command(struct maat *maat_inst, const char *table_name,
|
|
int low_boundary, int up_boundary)
|
|
{
|
|
long long rule_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
|
|
int ret = rule_table_set_line(maat_inst, "RULE_DEFAULT",
|
|
MAAT_OP_ADD, rule_id, "null",
|
|
1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long object_id = maat_cmd_incrby(maat_inst, "SEQUENCE_OBJECT", 1);
|
|
ret = object2rule_table_set_line(maat_inst, "OBJECT2RULE_DEFAULT",
|
|
MAAT_OP_ADD, object_id, rule_id,
|
|
0, table_name, 1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1);
|
|
char interval_range_str[64] = {0};
|
|
snprintf(interval_range_str, sizeof(interval_range_str), "%d-%d", low_boundary, up_boundary);
|
|
ret = interval_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id,
|
|
object_id, interval_range_str, NULL, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
}
|
|
|
|
static void
|
|
test_add_flag_command(struct maat *maat_inst, const char *table_name,
|
|
long long flag, long long flag_mask)
|
|
{
|
|
long long rule_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
|
|
int ret = rule_table_set_line(maat_inst, "RULE_DEFAULT",
|
|
MAAT_OP_ADD, rule_id, "null",
|
|
1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long object_id = maat_cmd_incrby(maat_inst, "SEQUENCE_OBJECT", 1);
|
|
ret = object2rule_table_set_line(maat_inst, "OBJECT2RULE_DEFAULT",
|
|
MAAT_OP_ADD, object_id, rule_id,
|
|
0, table_name, 1, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1);
|
|
ret = flag_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id,
|
|
object_id, flag, flag_mask, 0);
|
|
EXPECT_EQ(ret, 1);
|
|
}
|
|
|
|
class MaatPerfStringScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatStringScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfStringScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfStringScan::logger;
|
|
|
|
void *perf_string_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
const char *scan_data = "today and yesterday should hit";
|
|
long long results[ARRAY_SIZE] = {0};
|
|
int hit_times = 0;
|
|
size_t n_hit_result = 0;
|
|
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
struct timespec start, end;
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
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) {
|
|
hit_times++;
|
|
}
|
|
maat_state_reset(state);
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
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_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);
|
|
return is_all_hit;
|
|
}
|
|
|
|
void *perf_string_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
const int CMD_EXPR_NUM = 10;
|
|
char keyword_buf[128];
|
|
|
|
for (int i = 0; i < CMD_EXPR_NUM; i++) {
|
|
random_keyword_generate(keyword_buf, sizeof(keyword_buf));
|
|
test_add_expr_command(maat_inst, table_name, keyword_buf);
|
|
sleep(1);
|
|
}
|
|
|
|
int *is_all_hit = ALLOC(int, 1);
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfStringScan, LiteralMultiThread) {
|
|
const char *table_name = "EXPR_LITERAL_PERF_CONFIG";
|
|
struct maat *maat_inst = MaatPerfStringScan::_shared_maat_inst;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_string_update_thread,
|
|
thread_params+i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_times += thread_params[i].test_times;
|
|
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
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);
|
|
}
|
|
|
|
class MaatPerfRegexScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatRegexScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfRegexScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfRegexScan::logger;
|
|
|
|
void *perf_regex_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
struct timespec start, end;
|
|
const char *scan_data =
|
|
"http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567";
|
|
long long results[ARRAY_SIZE] = {0};
|
|
int hit_times = 0;
|
|
size_t n_hit_result = 0;
|
|
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
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) {
|
|
hit_times++;
|
|
}
|
|
maat_state_reset(state);
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
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_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);
|
|
return is_all_hit;
|
|
}
|
|
|
|
void *perf_regex_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
const int CMD_EXPR_NUM = 10;
|
|
char keyword_buf[128];
|
|
|
|
for (int i = 0; i < CMD_EXPR_NUM; i++) {
|
|
random_keyword_generate(keyword_buf, sizeof(keyword_buf));
|
|
test_add_expr_command(maat_inst, table_name, keyword_buf);
|
|
sleep(1);
|
|
}
|
|
|
|
int *is_all_hit = ALLOC(int, 1);
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfRegexScan, RegexMultiThread) {
|
|
const char *table_name = "EXPR_REGEX_PERF_CONFIG";
|
|
struct maat *maat_inst = MaatPerfRegexScan::_shared_maat_inst;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_regex_update_thread,
|
|
thread_params+i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_times += thread_params[i].test_times;
|
|
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
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",
|
|
PERF_THREAD_NUM, scan_per_second);
|
|
}
|
|
|
|
void *perf_integer_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
struct timespec start, end;
|
|
int hit_times = 0;
|
|
long long results[ARRAY_SIZE] = {0};
|
|
size_t n_hit_result = 0;
|
|
|
|
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
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) {
|
|
hit_times++;
|
|
}
|
|
maat_state_reset(state);
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
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_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);
|
|
return is_all_hit;
|
|
}
|
|
|
|
void *perf_integer_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
const int CMD_EXPR_NUM = 10;
|
|
|
|
for (int i = 0; i < CMD_EXPR_NUM; i++) {
|
|
test_add_integer_command(maat_inst, table_name, 3001+i, 3001+i);
|
|
sleep(1);
|
|
}
|
|
|
|
int *is_all_hit = ALLOC(int, 1);
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
class MaatPerfStreamScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
\
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatStreamScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfStreamScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfStreamScan::logger;
|
|
|
|
void *perf_stream_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
struct timespec start, end;
|
|
const char *scan_data =
|
|
"http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567";
|
|
long long results[ARRAY_SIZE] = {0};
|
|
int ret = 0, hit_times = 0;
|
|
size_t n_hit_result = 0;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
|
|
struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state);
|
|
maat_register_thread(maat_inst);
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
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) {
|
|
hit_times++;
|
|
}
|
|
maat_state_reset(state);
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
maat_stream_free(sp);
|
|
maat_state_free(state);
|
|
|
|
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_times) ? 1 : 0);
|
|
|
|
log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"thread_id:%d stream_scan time_elapse:%lldms hit_times:%d",
|
|
param->thread_id, param->time_elapse_ms, hit_times);
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfStreamScan, MultiThread) {
|
|
const char *table_name = "HTTP_URL";
|
|
struct maat *maat_inst = MaatPerfStreamScan::_shared_maat_inst;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM];
|
|
struct thread_param thread_params[PERF_THREAD_NUM];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_stream_scan_thread,
|
|
thread_params+i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_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_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",
|
|
PERF_THREAD_NUM, scan_per_second);
|
|
}
|
|
|
|
class MaatPerfIPScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatIPScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfIPScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfIPScan::logger;
|
|
|
|
void *perf_ip_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
struct timespec start, end;
|
|
char ip_str[32] = "10.0.0.1";
|
|
uint32_t ip_addr;
|
|
|
|
int ret = inet_pton(AF_INET, ip_str, &ip_addr);
|
|
EXPECT_EQ(ret, 1);
|
|
|
|
int hit_times = 0;
|
|
long long results[ARRAY_SIZE] = {0};
|
|
size_t n_hit_result = 0;
|
|
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
for (int i = 0; i < param->test_times; i++) {
|
|
int ret = maat_scan_ipv4(maat_inst, table_id, ip_addr, results,
|
|
ARRAY_SIZE, &n_hit_result, state);
|
|
if (ret == MAAT_SCAN_HIT) {
|
|
hit_times++;
|
|
}
|
|
maat_state_reset(state);
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
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_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);
|
|
return is_all_hit;
|
|
}
|
|
|
|
void *perf_ip_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
const int CMD_EXPR_NUM = 10;
|
|
char ip_str[10][32] = {
|
|
"10.0.7.101",
|
|
"10.0.7.102",
|
|
"10.0.7.103",
|
|
"10.0.7.104",
|
|
"10.0.7.105",
|
|
"10.0.7.106",
|
|
"10.0.7.107",
|
|
"10.0.7.108",
|
|
"10.0.7.109",
|
|
"10.0.7.110"};
|
|
|
|
for (int i = 0; i < CMD_EXPR_NUM; i++) {
|
|
test_add_ip_command(maat_inst, table_name, ip_str[i]);
|
|
sleep(1);
|
|
}
|
|
|
|
int *is_all_hit = ALLOC(int, 1);
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfIPScan, MultiThread)
|
|
{
|
|
const char *table_name = "IP_PERF_CONFIG";
|
|
struct maat *maat_inst = MaatPerfIPScan::_shared_maat_inst;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_ip_update_thread,
|
|
thread_params+i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_times += thread_params[i].test_times;
|
|
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
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",
|
|
PERF_THREAD_NUM, scan_per_second);
|
|
}
|
|
|
|
class MaatPerfIntegerScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatIntegerScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfIntegerScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfIntegerScan::logger;
|
|
|
|
TEST_F(MaatPerfIntegerScan, MultiThread) {
|
|
const char *table_name = "CONTENT_SIZE";
|
|
struct maat *maat_inst = MaatPerfIntegerScan::_shared_maat_inst;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_integer_update_thread,
|
|
thread_params+i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_times += thread_params[i].test_times;
|
|
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
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",
|
|
PERF_THREAD_NUM, scan_per_second);
|
|
}
|
|
|
|
class MaatPerfFlagScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatFlagScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfFlagScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfFlagScan::logger;
|
|
|
|
void *perf_flag_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
struct timespec start, end;
|
|
int hit_times = 0;
|
|
long long results[ARRAY_SIZE] = {0};
|
|
size_t n_hit_result = 0;
|
|
long long scan_data = 15;
|
|
|
|
struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
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) {
|
|
hit_times++;
|
|
}
|
|
maat_state_reset(state);
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
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_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);
|
|
return is_all_hit;
|
|
}
|
|
|
|
void *perf_flag_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const char *table_name = param->table_name;
|
|
const int CMD_EXPR_NUM = 10;
|
|
|
|
for (int i = 0; i < CMD_EXPR_NUM; i++) {
|
|
test_add_flag_command(maat_inst, table_name, i, 15);
|
|
sleep(1);
|
|
}
|
|
|
|
int *is_all_hit = ALLOC(int, 1);
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfFlagScan, MultiThread) {
|
|
const char *table_name = "FLAG_PERF_CONFIG";
|
|
struct maat *maat_inst = MaatPerfFlagScan::_shared_maat_inst;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_flag_update_thread,
|
|
thread_params+i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_times += thread_params[i].test_times;
|
|
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
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",
|
|
PERF_THREAD_NUM, scan_per_second);
|
|
}
|
|
|
|
class MaatPerfFQDNPluginScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatFQDNPluginScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfFQDNPluginScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfFQDNPluginScan::logger;
|
|
|
|
struct perf_fqdn_plugin_ud {
|
|
long long rule_id;
|
|
int catid;
|
|
};
|
|
|
|
void perf_fqdn_plugin_EX_new_cb(const char *table_name, int table_id,
|
|
const char *key, const char *table_line,
|
|
void **ad, long argl, void *argp)
|
|
{
|
|
int *counter=(int *)argp;
|
|
size_t column_offset=0, column_len=0;
|
|
|
|
struct perf_fqdn_plugin_ud *ud = ALLOC(struct perf_fqdn_plugin_ud, 1);
|
|
int ret = maat_helper_read_column(table_line, 1, &column_offset, &column_len);
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
ud->rule_id = atoll(table_line+column_offset);
|
|
ret = maat_helper_read_column(table_line, 3, &column_offset, &column_len);
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
sscanf(table_line+column_offset, "catid=%d",&ud->catid);
|
|
|
|
*ad = ud;
|
|
(*counter)++;
|
|
}
|
|
|
|
void perf_fqdn_plugin_EX_free_cb(int table_id, void **ad, long argl, void *argp)
|
|
{
|
|
struct perf_fqdn_plugin_ud *u = (struct perf_fqdn_plugin_ud *)(*ad);
|
|
|
|
free(u);
|
|
*ad = NULL;
|
|
}
|
|
|
|
void perf_fqdn_plugin_EX_dup_cb(int table_id, void **to, void **from,
|
|
long argl, void *argp)
|
|
{
|
|
struct perf_fqdn_plugin_ud *u = (struct perf_fqdn_plugin_ud *)(*from);
|
|
|
|
*to = u;
|
|
}
|
|
|
|
void* perf_fqdn_plugin_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
struct perf_fqdn_plugin_ud *result[ARRAY_SIZE];
|
|
|
|
int i=0, ret=0, hit_times=0;
|
|
int table_id = maat_get_table_id(maat_inst, param->table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
struct timespec start, end;
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
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",
|
|
(void**)result, ARRAY_SIZE);
|
|
if (ret == 2) {
|
|
hit_times++;
|
|
}
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
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_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);
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
void random_fqdn_generate(char *fqdn_buff, int sz)
|
|
{
|
|
int min_fqdn_len = 6, max_fqdn_len = 32;
|
|
int i=0, j=0;
|
|
|
|
int len = random() % (max_fqdn_len - min_fqdn_len) + min_fqdn_len;
|
|
if (len >= sz) {
|
|
len = sz - 1;
|
|
}
|
|
|
|
for (i = 0; i < len-4; i++) {
|
|
fqdn_buff[i] = 'a' + random() % ('z' - 'a');
|
|
if (j > 5) {
|
|
if (random() % 3 == 0) {
|
|
fqdn_buff[i] = '.';
|
|
j = 0;
|
|
}
|
|
}
|
|
j++;
|
|
}
|
|
fqdn_buff[i] = '\0';
|
|
}
|
|
|
|
void *perf_fqdn_plugin_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const int CMD_EXPR_NUM = 20;
|
|
int i = 0;
|
|
struct maat_cmd_line line_rule;
|
|
char line_buff[1024], fqdn_buff[256];
|
|
|
|
for (i = 0; i < CMD_EXPR_NUM; i++) {
|
|
line_rule.rule_id = (int)maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1);
|
|
line_rule.table_name = param->table_name;
|
|
random_fqdn_generate(fqdn_buff, sizeof(fqdn_buff));
|
|
snprintf(line_buff, 1024, "%lld\t1\t%s\tcatid=4\t1",
|
|
line_rule.rule_id, fqdn_buff);
|
|
line_rule.table_line = line_buff;
|
|
line_rule.expire_after = 0;
|
|
maat_cmd_set_line(maat_inst, &line_rule);
|
|
sleep(WAIT_FOR_EFFECTIVE_S);
|
|
}
|
|
|
|
int *is_all_hit = (int *)malloc(sizeof(int));
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfFQDNPluginScan, MultiThread) {
|
|
struct maat *maat_inst = MaatPerfFQDNPluginScan::_shared_maat_inst;
|
|
const char *table_name = "TEST_FQDN_PLUGIN_WITH_EXDATA";
|
|
int fqdn_plugin_ex_data_counter = 0;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name,
|
|
perf_fqdn_plugin_EX_new_cb,
|
|
perf_fqdn_plugin_EX_free_cb,
|
|
perf_fqdn_plugin_EX_dup_cb,
|
|
0, &fqdn_plugin_ex_data_counter);
|
|
ASSERT_TRUE(ret>=0);
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_fqdn_plugin_update_thread,
|
|
thread_params + i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_times += thread_params[i].test_times;
|
|
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
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",
|
|
PERF_THREAD_NUM, scan_per_second);
|
|
}
|
|
|
|
class MaatPerfBoolPluginScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in BoolPluginScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfBoolPluginScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfBoolPluginScan::logger;
|
|
|
|
struct bool_plugin_ud {
|
|
int id;
|
|
char *name;
|
|
};
|
|
|
|
void perf_bool_plugin_ex_new_cb(const char *table_name, int table_id,
|
|
const char *key, const char *table_line,
|
|
void **ad, long argl, void *argp)
|
|
{
|
|
int *counter=(int *)argp;
|
|
size_t column_offset=0, column_len=0;
|
|
struct bool_plugin_ud *ud = ALLOC(struct bool_plugin_ud, 1);
|
|
|
|
int ret = get_column_pos(table_line, 1, &column_offset, &column_len);
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
ud->id = atoi(table_line + column_offset);
|
|
ret = get_column_pos(table_line, 3, &column_offset, &column_len);
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
ud->name = (char *)malloc(column_len+1);
|
|
memcpy(ud->name, table_line+column_offset, column_len);
|
|
|
|
*ad = ud;
|
|
(*counter)++;
|
|
}
|
|
|
|
void perf_bool_plugin_ex_free_cb(int table_id, void **ad, long argl, void *argp)
|
|
{
|
|
struct bool_plugin_ud *u = (struct bool_plugin_ud *)(*ad);
|
|
|
|
free(u->name);
|
|
free(u);
|
|
*ad = NULL;
|
|
}
|
|
|
|
void perf_bool_plugin_ex_dup_cb(int table_id, void **to, void **from,
|
|
long argl, void *argp)
|
|
{
|
|
struct bool_plugin_ud *u = (struct bool_plugin_ud *)(*from);
|
|
|
|
*to = u;
|
|
}
|
|
|
|
void* perf_bool_plugin_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
struct perf_fqdn_plugin_ud *result[ARRAY_SIZE];
|
|
|
|
int i=0, ret=0, hit_times=0;
|
|
int table_id = maat_get_table_id(maat_inst, param->table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
struct timespec start, end;
|
|
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_times; i++) {
|
|
|
|
ret = maat_bool_plugin_table_get_ex_data(maat_inst, table_id, items_4,
|
|
sizeof(items_4)/sizeof(unsigned long long),
|
|
(void**)result, 6);
|
|
if (ret == 1) {
|
|
hit_times++;
|
|
}
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
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_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",
|
|
param->thread_id, param->time_elapse_ms, hit_times);
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
void *perf_bool_plugin_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const int CMD_EXPR_NUM = 20;
|
|
int i = 0;
|
|
struct maat_cmd_line line_rule;
|
|
char line_buff[1024];
|
|
|
|
for (i = 0; i < CMD_EXPR_NUM; i++) {
|
|
line_rule.rule_id = (int)maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1);
|
|
line_rule.table_name = param->table_name;
|
|
snprintf(line_buff, 1024, "%lld\t1&%d\ttunnel2\t1", line_rule.rule_id, i);
|
|
line_rule.table_line = line_buff;
|
|
line_rule.expire_after = 0;
|
|
maat_cmd_set_line(maat_inst, &line_rule);
|
|
sleep(WAIT_FOR_EFFECTIVE_S);
|
|
}
|
|
|
|
int *is_all_hit = (int *)malloc(sizeof(int));
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfBoolPluginScan, MultiThread) {
|
|
int ex_data_counter = 0;
|
|
const char *table_name = "TEST_BOOL_PLUGIN_WITH_EXDATA";
|
|
struct maat *maat_inst = MaatPerfBoolPluginScan::_shared_maat_inst;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name,
|
|
perf_bool_plugin_ex_new_cb,
|
|
perf_bool_plugin_ex_free_cb,
|
|
perf_bool_plugin_ex_dup_cb,
|
|
0, &ex_data_counter);
|
|
ASSERT_TRUE(ret >= 0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_bool_plugin_update_thread,
|
|
thread_params + i);
|
|
}
|
|
}
|
|
|
|
long long time_elapse_ms = 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_times += thread_params[i].test_times;
|
|
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
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",
|
|
PERF_THREAD_NUM, scan_per_second);
|
|
}
|
|
|
|
class MaatPerfFileScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
const char *rule_folder = "./tsgrule/index";
|
|
const char *table_info = "./tsg_table_info.json";
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_iris(opts, rule_folder, rule_folder);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, table_info);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatPerfFileScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfFileScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfFileScan::logger;
|
|
|
|
struct perf_ip_plugin_ud {
|
|
long long rule_id;
|
|
};
|
|
|
|
void perf_ip_plugin_EX_new_cb(const char *table_name, int table_id,
|
|
const char *key, const char *table_line,
|
|
void **ad, long argl, void *argp)
|
|
{
|
|
int *counter=(int *)argp, ret=0;
|
|
size_t column_offset=0, column_len=0;
|
|
|
|
struct perf_ip_plugin_ud *ud = ALLOC(struct perf_ip_plugin_ud, 1);
|
|
ret = maat_helper_read_column(table_line, 1, &column_offset, &column_len);
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
ud->rule_id = atoll(table_line+column_offset);
|
|
ret = maat_helper_read_column(table_line, 5, &column_offset, &column_len);
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
*ad = ud;
|
|
(*counter)++;
|
|
}
|
|
|
|
void perf_ip_plugin_EX_free_cb(int table_id, void **ad, long argl, void *argp)
|
|
{
|
|
struct perf_ip_plugin_ud *u = (struct perf_ip_plugin_ud*)(*ad);
|
|
|
|
free(u);
|
|
*ad = NULL;
|
|
}
|
|
|
|
void perf_ip_plugin_EX_dup_cb(int table_id, void **to, void **from,
|
|
long argl, void *argp)
|
|
{
|
|
struct perf_ip_plugin_ud *u = (struct perf_ip_plugin_ud*)(*from);
|
|
|
|
*to = u;
|
|
}
|
|
|
|
static void *ip_plugin_get_thread(void *arg)
|
|
{
|
|
const char *table_name = "TSG_IP_LOCATION_BUILT_IN";
|
|
int test_times = 1000*1000, hit_times = 0;
|
|
int ret = 0, i = 0;
|
|
struct maat *maat_inst = (struct maat *)arg;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
struct timespec start, end;
|
|
struct ip_addr ipv4;
|
|
ipv4.ip_type = IPv4;
|
|
inet_pton(AF_INET, "191.70.72.1", &ipv4.ipv4);
|
|
|
|
clock_gettime(CLOCK_MONOTONIC, &start);
|
|
struct perf_ip_plugin_ud *results[ARRAY_SIZE];
|
|
for (i = 0; i < test_times; i++) {
|
|
ret = maat_ip_plugin_table_get_ex_data(maat_inst, table_id, &ipv4,
|
|
(void**)results, 4);
|
|
if (ret > 0) {
|
|
hit_times++;
|
|
}
|
|
}
|
|
clock_gettime(CLOCK_MONOTONIC, &end);
|
|
|
|
long long time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
|
|
(end.tv_nsec - start.tv_nsec) / 1000000;
|
|
log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"ip_plugin_get_ex_data time_elapse:%lldms hit_times:%d",
|
|
time_elapse_ms, hit_times);
|
|
|
|
int *is_all_hit = (int *)malloc(sizeof(int));
|
|
*is_all_hit = (hit_times == test_times) ? 1 : 0;
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfFileScan, IPPlugin) {
|
|
struct maat *maat_inst = MaatPerfFileScan::_shared_maat_inst;
|
|
const char* table_name = "TSG_IP_LOCATION_BUILT_IN";
|
|
int ip_plugin_ex_data_counter = 0;
|
|
int* is_all_hit = NULL;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name,
|
|
perf_ip_plugin_EX_new_cb,
|
|
perf_ip_plugin_EX_free_cb,
|
|
perf_ip_plugin_EX_dup_cb,
|
|
0, &ip_plugin_ex_data_counter);
|
|
ASSERT_TRUE(ret>=0);
|
|
|
|
int i = 0;
|
|
pthread_t threads[PERF_THREAD_NUM];
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM; i++) {
|
|
pthread_create(&(threads[i]), NULL, ip_plugin_get_thread, maat_inst);
|
|
}
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM; i++) {
|
|
pthread_join(threads[i], (void**)&is_all_hit);
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit=0;
|
|
free(is_all_hit);
|
|
}
|
|
}
|
|
|
|
class MaatPerfIPPortPluginScan : public testing::Test
|
|
{
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
const char *accept_tags =
|
|
"{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
|
|
"{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
|
|
char redis_ip[64] = "127.0.0.1";
|
|
int redis_port = 6379;
|
|
int redis_db = 0;
|
|
|
|
logger = log_handle_create("./maat_framework_perf_gtest.log", 0);
|
|
int ret = write_json_to_redis(g_json_filename, redis_ip, redis_port,
|
|
redis_db, logger);
|
|
if (ret < 0) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] write config to redis failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
|
|
struct maat_options *opts = maat_options_new();
|
|
maat_options_set_stat_file(opts, "./stat.log");
|
|
maat_options_set_perf_on(opts);
|
|
maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
|
|
maat_options_set_logger(opts, "./maat_framework_perf_gtest.log",
|
|
LOG_LEVEL_INFO);
|
|
maat_options_set_accept_tags(opts, accept_tags);
|
|
maat_options_set_caller_thread_number(opts, 5);
|
|
|
|
_shared_maat_inst = maat_new(opts, g_table_info_path);
|
|
maat_options_free(opts);
|
|
if (NULL == _shared_maat_inst) {
|
|
log_fatal(logger, MODULE_FRAMEWORK_PERF_GTEST,
|
|
"[%s:%d] create maat instance in MaatFlagScan failed.",
|
|
__FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
|
|
static void TearDownTestCase() {
|
|
maat_free(_shared_maat_inst);
|
|
log_handle_destroy(logger);
|
|
}
|
|
|
|
static struct log_handle *logger;
|
|
static struct maat *_shared_maat_inst;
|
|
};
|
|
|
|
struct maat *MaatPerfIPPortPluginScan::_shared_maat_inst;
|
|
struct log_handle *MaatPerfIPPortPluginScan::logger;
|
|
|
|
static void *perf_ipport_plugin_scan_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
struct perf_ip_plugin_ud *results[ARRAY_SIZE];
|
|
int i = 0, ret = 0, hit_times = 0;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, param->table_name);
|
|
maat_register_thread(maat_inst);
|
|
|
|
struct ip_addr ipv4;
|
|
ipv4.ip_type = IPv4;
|
|
inet_pton(AF_INET, "192.168.100.1", &ipv4.ipv4);
|
|
uint16_t port = htons(215);
|
|
|
|
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) {
|
|
hit_times++;
|
|
}
|
|
}
|
|
|
|
int *is_all_hit = (int *)malloc(sizeof(int));
|
|
*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);
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
void *perf_ipport_plugin_update_thread(void *arg)
|
|
{
|
|
struct thread_param *param = (struct thread_param *)arg;
|
|
struct maat *maat_inst = param->maat_inst;
|
|
const int CMD_EXPR_NUM = 20;
|
|
int i = 0;
|
|
struct maat_cmd_line line_rule;
|
|
char line_buff[1024];
|
|
|
|
for (i = 0; i < CMD_EXPR_NUM; i++) {
|
|
line_rule.rule_id = (int)maat_cmd_incrby(maat_inst, "TEST_PLUG_SEQ", 1);
|
|
line_rule.table_name = param->table_name;
|
|
snprintf(line_buff, 1024, "%lld\t4\t192.168.100.1\t%d\t%d\t1",
|
|
line_rule.rule_id, 200+i, 300+i);
|
|
line_rule.table_line = line_buff;
|
|
line_rule.expire_after = 0;
|
|
maat_cmd_set_line(maat_inst, &line_rule);
|
|
sleep(WAIT_FOR_EFFECTIVE_S);
|
|
}
|
|
|
|
int *is_all_hit = (int *)malloc(sizeof(int));
|
|
*is_all_hit = 1;
|
|
|
|
return is_all_hit;
|
|
}
|
|
|
|
TEST_F(MaatPerfIPPortPluginScan, MultiThread) {
|
|
struct maat *maat_inst = MaatPerfIPPortPluginScan::_shared_maat_inst;
|
|
const char* table_name = "TEST_IPPORT_PLUGIN_WITH_EXDATA";
|
|
int ip_plugin_ex_data_counter = 0;
|
|
|
|
int table_id = maat_get_table_id(maat_inst, table_name);
|
|
ASSERT_GT(table_id, 0);
|
|
|
|
int ret = maat_plugin_table_ex_schema_register(maat_inst, table_name,
|
|
perf_ip_plugin_EX_new_cb,
|
|
perf_ip_plugin_EX_free_cb,
|
|
perf_ip_plugin_EX_dup_cb,
|
|
0, &ip_plugin_ex_data_counter);
|
|
ASSERT_TRUE(ret>=0);
|
|
|
|
pthread_t threads[PERF_THREAD_NUM + 1];
|
|
struct thread_param thread_params[PERF_THREAD_NUM + 1];
|
|
int i = 0;
|
|
int *is_all_hit = NULL;
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
thread_params[i].maat_inst = maat_inst;
|
|
thread_params[i].thread_id = i;
|
|
thread_params[i].table_name = table_name;
|
|
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_times = 0;
|
|
pthread_create(&threads[i], NULL, perf_ipport_plugin_update_thread,
|
|
thread_params+i);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
|
|
pthread_join(threads[i], (void **)&is_all_hit);
|
|
EXPECT_EQ(*is_all_hit, 1);
|
|
*is_all_hit = 0;
|
|
free(is_all_hit);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char ** argv)
|
|
{
|
|
int ret=0;
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
|
|
ret=RUN_ALL_TESTS();
|
|
|
|
return ret;
|
|
}
|