From a194de2b5ad1b4a9a930d0c795aa09c8a4dcb312 Mon Sep 17 00:00:00 2001 From: fumingwei Date: Fri, 14 Jul 2023 11:54:47 +0800 Subject: temp commit 1 --- ctest/CMakeLists.txt | 3 + test/bin/telegraf_unit_test.conf | 5 + test/src/CMakeLists.txt | 6 +- test/src/gtest_dynamic_benchmark.cpp | 213 +++++++++++++++++++++++++++++++++++ 4 files changed, 226 insertions(+), 1 deletion(-) create mode 100644 test/src/gtest_dynamic_benchmark.cpp diff --git a/ctest/CMakeLists.txt b/ctest/CMakeLists.txt index a20b703..347eab3 100644 --- a/ctest/CMakeLists.txt +++ b/ctest/CMakeLists.txt @@ -9,6 +9,8 @@ add_test(NAME COPY_GTEST_OUTPUT_BINARY COMMAND sh -c "cp ${CMAKE_BINARY_DIR}/tes add_test(NAME COPY_GTEST_DYNAMIC_BINARY COMMAND sh -c "cp ${CMAKE_BINARY_DIR}/test/src/gtest_dynamic_fieldstat ${CMAKE_BINARY_DIR}/testing/") add_test(NAME COPY_GTEST_DYNAMIC_OUTPUT_BINARY COMMAND sh -c "cp ${CMAKE_BINARY_DIR}/test/src/gtest_dynamic_fieldstat_output ${CMAKE_BINARY_DIR}/testing/") add_test(NAME COPY_GTEST_OUTPUT_FILE_INSTANCE_BINARY COMMAND sh -c "cp ${CMAKE_BINARY_DIR}/test/src/gtest_fieldstat_output_file_instance ${CMAKE_BINARY_DIR}/testing/") +add_test(NAME COPY_GTEST_DYNAMIC_BENCHMARK COMMAND sh -c "cp ${CMAKE_BINARY_DIR}/test/src/gtest_dynamic_benchmark ${CMAKE_BINARY_DIR}/testing/") + set(GTEST_RUN_DIR ${CMAKE_BINARY_DIR}/testing) #add_test(NAME GTEST_RULE COMMAND gtest_rule WORKING_DIRECTORY ${GTEST_RUN_DIR}) @@ -17,3 +19,4 @@ add_test(NAME GTEST_FIELDSTAT_OUTPUT COMMAND gtest_fieldstat_output WORKING_DIRE add_test(NAME GTEST_DYNAMIC_FIELDSTAT COMMAND gtest_dynamic_fieldstat WORKING_DIRECTORY ${GTEST_RUN_DIR}) add_test(NAME GTEST_DYNAMIC_FIELDSTAT_OUTPUT COMMAND gtest_dynamic_fieldstat_output WORKING_DIRECTORY ${GTEST_RUN_DIR}) add_test(NAME GTEST_FIELDSTAT_OUTPUT_FILE_INSTANCE COMMAND gtest_fieldstat_output_file_instance WORKING_DIRECTORY ${GTEST_RUN_DIR}) +add_test(NAME GTEST_DYNAMIC_BENCHMARK COMMAND gtest_dynamic_benchmark WORKING_DIRECTORY ${GTEST_RUN_DIR}) diff --git a/test/bin/telegraf_unit_test.conf b/test/bin/telegraf_unit_test.conf index 748060e..b270115 100644 --- a/test/bin/telegraf_unit_test.conf +++ b/test/bin/telegraf_unit_test.conf @@ -23,3 +23,8 @@ [[inputs.socket_listener]] service_address = "udp://:8700" data_format = "influx" + +[[aggregators.basicstats]] + period = "1s" + drop_original = true + stats = ["sum"] \ No newline at end of file diff --git a/test/src/CMakeLists.txt b/test/src/CMakeLists.txt index 03311e2..734f9af 100644 --- a/test/src/CMakeLists.txt +++ b/test/src/CMakeLists.txt @@ -19,4 +19,8 @@ add_executable(gtest_dynamic_fieldstat_output ${SRC} gtest_dynamic_fieldstat_out target_link_libraries(gtest_dynamic_fieldstat_output gtest-static) add_executable(gtest_fieldstat_output_file_instance ${SRC} gtest_fieldstat_output_file_instance.cpp) -target_link_libraries(gtest_fieldstat_output_file_instance gtest-static) \ No newline at end of file +target_link_libraries(gtest_fieldstat_output_file_instance gtest-static) + + +add_executable(gtest_dynamic_benchmark ${SRC} gtest_dynamic_benchmark.cpp) +target_link_libraries(gtest_dynamic_benchmark gtest-static) \ No newline at end of file diff --git a/test/src/gtest_dynamic_benchmark.cpp b/test/src/gtest_dynamic_benchmark.cpp new file mode 100644 index 0000000..40d824b --- /dev/null +++ b/test/src/gtest_dynamic_benchmark.cpp @@ -0,0 +1,213 @@ +#include +#include +#include +#include +#include "fieldstat.h" +#include "fieldstat_internal.h" +#include "cJSON.h" +#include + + +void check_telegraf_output_content(const char *filepath) +{ + unsigned long long counter_sum = 0; + unsigned long long bytes_sum = 0; + unsigned long long packages_sum = 0; + char read_line_buf[2048] = {0}; + + cJSON *cjson_metric = NULL; + cJSON *cjson_fields = NULL; + cJSON *value_counter = NULL; + cJSON *value_bytes = NULL; + cJSON *value_packages = NULL; + + FILE *fp = fopen(filepath, "r"); + EXPECT_NE(nullptr, fp); + + while(!feof(fp)) + { + memset(read_line_buf, 0, sizeof(read_line_buf)); + if(NULL == fgets(read_line_buf, sizeof(read_line_buf), fp)) + { + continue; + } + + cjson_metric = cJSON_Parse(read_line_buf); + EXPECT_NE(nullptr, cjson_metric); + + cjson_fields = cJSON_GetObjectItem(cjson_metric, "fields"); + EXPECT_NE(nullptr, cjson_fields); + + value_bytes = cJSON_GetObjectItem(cjson_fields, "bytes_sum"); + if(value_bytes != NULL && value_bytes->type == cJSON_Number) + { + bytes_sum += value_bytes->valueint; + } + + value_packages = cJSON_GetObjectItem(cjson_fields, "packages_sum"); + if(value_packages != NULL && value_packages->type == cJSON_Number) + { + packages_sum += value_packages->valueint; + } + + value_counter = cJSON_GetObjectItem(cjson_fields, "counter_sum"); + if(value_counter != NULL && value_counter->type == cJSON_Number) + { + counter_sum += value_counter->valueint; + } + + cJSON_Delete(cjson_metric); + } + EXPECT_EQ(counter_sum, bytes_sum); + EXPECT_EQ(counter_sum, packages_sum); + + fclose(fp); +} + + +struct thread_para +{ + int loops; + struct fieldstat_dynamic_instance * instance; + int thread_id; + int table_id; + unsigned int *out_column_ids; + double duration_s; +}; + +void _worker_thread_metrics_operate(void *arg) +{ + int ret = 0; + unsigned long long counter = 0; + double elapsed_time = 0.0; + struct fieldstat_tag tags[3]; + const char *row_name = "security_rule_hits"; + struct thread_para *para = (struct thread_para*)arg; + + time_t start_time, end_time; + + tags[0].key = "policy_id"; + tags[0].value_int = 1; + tags[0].value_type = 0; + + tags[1].key = "quanlity"; + tags[1].value_double = 0.50; + tags[1].value_type = 1; + + tags[2].key = "device_id"; + tags[2].value_str = "test_device"; + tags[2].value_type = 2; + + + start_time = time(NULL); + for(;;) + { + end_time = time(NULL); + elapsed_time = difftime(end_time, start_time); + if(elapsed_time > para->duration_s) + { + break; + } + + ret = + fieldstat_dynamic_table_metric_value_incrby(para->instance, para->table_id, + para->out_column_ids[0], + row_name, 1, tags, + sizeof(tags)/sizeof(tags[0]), + para->thread_id); + EXPECT_EQ(0, ret); + ret = + fieldstat_dynamic_table_metric_value_incrby(para->instance, para->table_id, + para->out_column_ids[1], + row_name, 1, tags, + sizeof(tags)/sizeof(tags[0]), + para->thread_id); + EXPECT_EQ(0, ret); + counter++; + usleep(1); + } + + ret = fieldstat_dynamic_metric_value_set(para->instance, FIELD_TYPE_COUNTER, + "counter", counter, NULL, 0, + para->thread_id); + EXPECT_EQ(0, ret); + + return; +} + +void * worker_thread_metrics_operate(void *arg) +{ + _worker_thread_metrics_operate(arg); + return NULL; +} + + +TEST(BenchMark, OneMetricMultiAddMultiThreads) +{ + int ret = 0; + int n_thread = 64; + int n_loops = 10000000; + int duration_s = 86400.0; + int table_id = -1; + void *temp = NULL; + + struct fieldstat_dynamic_instance *instance = NULL; + + unsigned int out_column_ids[2]; + const char *column_name[] = {"packages", "bytes"}; + enum field_type column_type[] = {FIELD_TYPE_COUNTER, FIELD_TYPE_COUNTER}; + + struct thread_para para[n_thread]; + pthread_t thread_ids[n_thread]; + + system("cat /dev/null > /tmp/metrics.out"); + + instance = fieldstat_dynamic_instance_new("firewall", n_thread); + + ret = + fieldstat_dynamic_set_line_protocol_server(instance, "127.0.0.1", 8700); + EXPECT_EQ(0, ret); + + ret = fieldstat_dynamic_set_output_interval(instance, 1000); + EXPECT_EQ(0, ret); + + table_id = + fieldstat_register_dynamic_table(instance, "tsg_master", column_name, column_type, + sizeof(column_name)/sizeof(column_name[0]), + out_column_ids); + EXPECT_EQ(0, table_id); + + fieldstat_dynamic_instance_start(instance); + + for(int i = 0; i < n_thread; i++) + { + para[i].loops = n_loops; + para[i].instance = instance; + para[i].thread_id = i; + para[i].table_id = table_id; + para[i].out_column_ids = out_column_ids; + para[i].duration_s = duration_s; + } + + for(int i = 0; i < n_thread; i++) + { + ret = + pthread_create(&(thread_ids[i]), NULL, worker_thread_metrics_operate, &(para[i])); + EXPECT_EQ(0, ret); + } + + for(int i = 0; i < n_thread; i++) + { + pthread_join(thread_ids[i], (void**)&temp); + } + + sleep(4); + check_telegraf_output_content("/tmp/metrics.out"); + fieldstat_dynamic_instance_free(instance); +} + +int main(int argc, char *argv[]) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file -- cgit v1.2.3