temp commit 1feature-benchmark

4 files changed, 226 insertions, 1 deletions

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 <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <gtest/gtest.h>
+#include "fieldstat.h"
+#include "fieldstat_internal.h"
+#include "cJSON.h"
+#include <time.h>
+
+
+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