doc: new serialize performance benchmark

1 files changed, 372 insertions, 372 deletions

diff --git a/test/test_performance.cpp b/test/test_performance.cpp
index e311b66..cc24e05 100644
--- a/test/test_performance.cpp
+++ b/test/test_performance.cpp
@@ -10,377 +10,377 @@
 // /*                                    merge                                   */
 // /* -------------------------------------------------------------------------- */
 
-// TEST(test_performance, merge_performance_when_comprehensive_sampling_multi_instance)
-// {   
-//     const int INSTANCE_NUM = 100;
-//     const int MAX_CELL_NUM = 65535;
-//     const int DIMENSION_TOTAL = 100000;
-//     // const int INSTANCE_NUM = 2;
-//     // const int MAX_CELL_NUM = 1000;
-//     // const int DIMENSION_TOTAL = 1024;
-//     Fieldstat_tag_list_wrapper *tags[DIMENSION_TOTAL];
-//     for (int i = 0; i < DIMENSION_TOTAL; i++)
-//     {
-//         tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
-//     }
-
-//     struct fieldstat *instances[INSTANCE_NUM];
-//     for (int i = 0; i < INSTANCE_NUM; i++) {
-//         struct fieldstat *tmp_i = fieldstat_new();
-//         int cube_id = fieldstat_register_cube(tmp_i, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, MAX_CELL_NUM);
-//         int metric_id = fieldstat_register_counter(tmp_i, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
-//         for (int j = 0; j < MAX_CELL_NUM; j++) {
-//             int cell_id = fieldstat_cube_add(tmp_i, cube_id, tags[rand() % DIMENSION_TOTAL]->get_tag(), 1, 1);
-//             if (cell_id == -1) {
-//                 printf("cell_id == -1\n");
-//                 continue;
-//             }
-
-//             fieldstat_counter_incrby(tmp_i, cube_id, metric_id, cell_id, 1);
-//         }
-//         instances[i] = tmp_i;
-//     }
+TEST(test_performance, merge_performance_when_comprehensive_sampling_multi_instance)
+{   
+    const int INSTANCE_NUM = 100;
+    const int MAX_CELL_NUM = 65535;
+    const int DIMENSION_TOTAL = 100000;
+    // const int INSTANCE_NUM = 2;
+    // const int MAX_CELL_NUM = 1000;
+    // const int DIMENSION_TOTAL = 1024;
+    Fieldstat_tag_list_wrapper *tags[DIMENSION_TOTAL];
+    for (int i = 0; i < DIMENSION_TOTAL; i++)
+    {
+        tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
+    }
+
+    struct fieldstat *instances[INSTANCE_NUM];
+    for (int i = 0; i < INSTANCE_NUM; i++) {
+        struct fieldstat *tmp_i = fieldstat_new();
+        int cube_id = fieldstat_register_cube(tmp_i, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, MAX_CELL_NUM);
+        int metric_id = fieldstat_register_counter(tmp_i, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
+        for (int j = 0; j < MAX_CELL_NUM; j++) {
+            int cell_id = fieldstat_cube_add(tmp_i, cube_id, tags[rand() % DIMENSION_TOTAL]->get_tag(), 1, 1);
+            if (cell_id == -1) {
+                printf("cell_id == -1\n");
+                continue;
+            }
+
+            fieldstat_counter_incrby(tmp_i, cube_id, metric_id, cell_id, 1);
+        }
+        instances[i] = tmp_i;
+    }
     
-//     struct fieldstat *instance_dest = fieldstat_new();
-//     printf("prepare done\n");
-
-//     clock_t start = clock();
-//     // getchar();
-//     for (int i = 0; i < INSTANCE_NUM; i++) {
-//         fieldstat_merge(instance_dest, instances[i]);
-//     }
-//     // exit(0);
-//     clock_t end = clock();
-
-//     double elapsed_secs = double(end - start) / CLOCKS_PER_SEC;
-//     printf("merge_performance_when_comprehensive_sampling_multi_instance elapsed_secs: %f\n", elapsed_secs);
-//     EXPECT_TRUE(elapsed_secs < 0.1);
-
-//     fieldstat_free(instance_dest);
-//     for (int i = 0; i < INSTANCE_NUM; i++) {
-//         fieldstat_free(instances[i]);
-//     }
-//     for (int i = 0; i < DIMENSION_TOTAL; i++) {
-//         delete tags[i];
-//     }
-// }
-
-// clock_t perform_merge_test(std::function<void (struct fieldstat*, int, int, int)> metric_add_func, 
-//     std::function<int(struct fieldstat*, int)> metric_register_func, enum sampling_mode mode, bool merge_empty_dest)
-// {
-//     const int MAX_CELL_NUM = 1000;
-//     Fieldstat_tag_list_wrapper *tags[MAX_CELL_NUM];
-//     for (int i = 0; i < MAX_CELL_NUM; i++) {
-//         tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
-//     }
-//     struct fieldstat *instance = fieldstat_new();
-//     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, mode, MAX_CELL_NUM);
-//     int metric_id = metric_register_func(instance, cube_id);
-//     for (int j = 0; j < MAX_CELL_NUM; j++) {
-//         int cell_id = fieldstat_cube_add(instance, cube_id, tags[j]->get_tag(), 1, 1);
-//         metric_add_func(instance, cube_id, metric_id, cell_id);
-//     }
-
-//     struct fieldstat *instance_dest = fieldstat_new();
-//     if (!merge_empty_dest) {
-//         fieldstat_merge(instance_dest, instance);
-//     }
-
-//     clock_t start = clock();
-//     fieldstat_merge(instance_dest, instance);
-//     clock_t end = clock();
-
-//     fieldstat_free(instance_dest);
-//     fieldstat_free(instance);
-//     for (int i = 0; i < MAX_CELL_NUM; i++) {
-//         delete tags[i];
-//     }
-
-//     return end - start;
-// }
-
-// TEST(test_performance, merge_performance_one_instance_comprehensive_counter_empty_dest)
-// {   
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
-//     printf("merge_performance_one_instance_comprehensive_counter_empty_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 1000000);
-// }
-
-// TEST(test_performance, merge_performance_one_instance_comprehensive_hll_empty_dest)
-// {   
-//     //     int metric_id = fieldstat_register_hll(instance, cube_id, "czz_test hll metric", 10);
-//     // int ret = fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
-
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_hll(instance, cube_id, "hll metric", 6);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
-//     printf("merge_performance_one_instance_comprehensive_hll_empty_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 1500);
-// }
-
-// TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_empty_dest)
-// {   
-//     // int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test", 1, 100000, 1);
-//     // int ret = fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
-
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_hist(instance, cube_id, "histogram metric", 1, 100000, 1);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
-//     printf("merge_performance_one_instance_comprehensive_histogram_empty_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 5000);
-// }
-
-// TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
-// {   
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, rand() % 1000);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_TOPK, true);
-//     printf("merge_performance_one_instance_topk_counter_empty_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 1000);
-// }
-
-// TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full_dest)
-// {   
-//     // int metric_id = fieldstat_register_counter(tmp_i, cube_id, "metric name", false);
-//     // fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
-//     printf("merge_performance_one_instance_comprehensive_counter_full_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 1000);
-// }
-
-// TEST(test_performance, merge_performance_one_instance_comprehensive_hll_full_dest)
-// {   
-//     //     int metric_id = fieldstat_register_hll(instance, cube_id, "czz_test hll metric", 10);
-//     // int ret = fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
-
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_hll(instance, cube_id, "hll metric", 6);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
-//     printf("merge_performance_one_instance_comprehensive_hll_full_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 1300);
-// }
-
-// TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_full_dest)
-// {   
-//     // int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test", 1, 600000, 3);
-//     // int ret = fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
-
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_hist(instance, cube_id, "histogram metric", 1, 100000, 1);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
-//     printf("merge_performance_one_instance_comprehensive_histogram_full_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 3 * 1000);
-// }
-
-// TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
-// {   
-//     auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
-//         fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, rand() % 1000);
-//     };
-//     auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
-//         return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
-//     };
-
-//     clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_TOPK, false);
-//     printf("merge_performance_one_instance_topk_counter_full_dest elapsed_secs: %ld\n", elapsed);
-//     EXPECT_TRUE(elapsed < 1500);
-// }
+    struct fieldstat *instance_dest = fieldstat_new();
+    printf("prepare done\n");
 
-// /* -------------------------------------------------------------------------- */
-// /*                                     add                                    */
-// /* -------------------------------------------------------------------------- */
-// TEST(test_performance, performance_test_add_cells_comprehensive)
-// {
-//     size_t cell_count = 100000;
-//     struct fieldstat_tag tags[cell_count];
-//     for (size_t i = 0; i < cell_count; i++) {
-//         tags[i] = TEST_TAG_INT;
-//         tags[i].value_longlong = i;
-//     }
-//     // getchar();
-//     struct fieldstat *instance = fieldstat_new();
-//     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, cell_count);
-//     fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
-
-//     clock_t start = clock();
-//     for (size_t i = 0; i < cell_count; i++) {
-//         fieldstat_cube_add(instance, 0, &tags[i % cell_count], 1, 1);
-//     }
-//     clock_t end = clock();
-//     double seconds = (double)(end - start) / cell_count;
-//     printf("performance_test_add_cells_comprehensive time cost: %f\n", seconds);
-//     EXPECT_TRUE(seconds < 1);
-//     fieldstat_free(instance);
-// }
-
-// TEST(test_performance, performance_test_add_cells_topk)
-// {
-//     size_t cell_count = 100000;
-//     struct fieldstat_tag tags[cell_count];
-//     for (size_t i = 0; i < cell_count; i++) {
-//         tags[i] = TEST_TAG_INT;
-//         // tags[i].value_longlong = rand() % 10000;
-//         if (rand()%2)
-//             tags[i].value_longlong = i;
-//         else
-//             tags[i].value_longlong = rand() % 1000;
-//     }
-//     struct fieldstat *instance = fieldstat_new();
-//     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 1000);
-//     fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
-
-//     // getchar();
-//     clock_t start = clock();
-//     for (size_t i = 0; i < cell_count; i++) {
-//         fieldstat_cube_add(instance, 0, &tags[i % cell_count], 1, 1);
-//     }
-//     clock_t end = clock();
-//     double seconds = (double)(end - start) / cell_count;
-//     // exit(0);
-
-//     EXPECT_TRUE(seconds < 1);
-//     printf("performance_test_on_1000_cells_topk_1000000_times time cost: %f\n", seconds);
-
-//     fieldstat_free(instance);
-// }
-
-// TEST(test_performance, performance_test_add_cells_histogram_record)
-// {
-//     struct fieldstat *instance = fieldstat_new();
-//     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-//     fieldstat_register_hist(instance, 0, "test", 1, 1000000, 3);
-//     int cell_id = fieldstat_cube_add(instance, 0, &TEST_TAG_DOUBLE, 1, 1);
-//     size_t test_num = 100000;
-//     long long vals[test_num];
-//     for (size_t i = 0; i < test_num; i++) {
-//         vals[i] = rand() % 1000000 + 1;
-//     }
-
-//     clock_t start = clock();
-//     for (size_t i = 0; i < test_num; i++) {
-//         fieldstat_hist_record(instance, 0, 0, cell_id, vals[i]);
-//     }
-//     clock_t end = clock();
-//     double seconds = (double)(end - start) / test_num;
-//     printf("performance_test_add_cells_histogram_record time cost: %f\n", seconds);
-//     EXPECT_TRUE(seconds < 1);
-//     fieldstat_free(instance);
-// }
-
-// TEST(test_performance, performance_test_add_cells_hll_add)
-// {
-//     struct fieldstat *instance = fieldstat_new();
-//     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-//     fieldstat_register_hll(instance, 0, "test", 6);
-//     int cell_id = fieldstat_cube_add(instance, 0, &TEST_TAG_DOUBLE, 1, 1);
-//     size_t test_num = 100000;
-//     std::string vals[test_num];
-//     for (size_t i = 0; i < test_num; i++) {
-//         vals[i] = std::to_string(rand() % 1000000 + 1);
-//     }
-
-//     clock_t start = clock();
-//     for (size_t i = 0; i < test_num; i++) {
-//         fieldstat_hll_add(instance, 0, 0, cell_id, vals[i].c_str(), vals[i].length());
-//     }
-//     clock_t end = clock();
-//     double seconds = (double)(end - start) / test_num;
-//     printf("performance_test_add_cells_hll_add time cost: %f\n", seconds);
-//     EXPECT_TRUE(seconds < 1);
-//     fieldstat_free(instance);
-// }
+    clock_t start = clock();
+    // getchar();
+    for (int i = 0; i < INSTANCE_NUM; i++) {
+        fieldstat_merge(instance_dest, instances[i]);
+    }
+    // exit(0);
+    clock_t end = clock();
 
-// /* -------------------------------------------------------------------------- */
-// /*                                   export                                   */
-// /* -------------------------------------------------------------------------- */
-// using namespace std;
-
-// TEST(test_performance, export_many_cells)
-// {
-//     const int MAX_CELL_NUM = 1000;
-//     const int TAG_NUM = 3000;
-//     const int CUBE_NUM = 10;
-//     const int METRIC_NUM = 10;
-
-//     Fieldstat_tag_list_wrapper *tags[TAG_NUM];
-//     for (int i = 0; i < TAG_NUM; i++) {
-//         tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
-//     }
-
-//     struct fieldstat *instance = fieldstat_new();
-//     int cell_id[MAX_CELL_NUM];
-//     for (int i = 0; i < CUBE_NUM; i++) {
-//         Fieldstat_tag_list_wrapper cube_tag("shared key", i);
-//         int cube_id = fieldstat_register_cube(instance, cube_tag.get_tag(), cube_tag.get_tag_count(), SAMPLING_MODE_COMPREHENSIVE, MAX_CELL_NUM);
-//         for (int k = 0; k < MAX_CELL_NUM; k++) {
-//             cell_id[k] = fieldstat_cube_add(instance, cube_id, tags[rand() % TAG_NUM]->get_tag(), 1, 1);
-//         }
-//         for (int j = 0; j < METRIC_NUM; j++) {
-//             string metric_name = "metric name" + to_string(i) + to_string(j);
-//             int metric_id = fieldstat_register_counter(instance, cube_id, metric_name.c_str(), COUNTER_MERGE_BY_SUM);
-
-//             for (int k = 0; k < MAX_CELL_NUM; k++) {
-//                 fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id[k], 1);
-//             }
-//         }
-//     }
-
-//     struct fieldstat_json_exporter *fieldstat_json_exporter = fieldstat_json_exporter_new(instance);
-//     printf("export_many_cells\n");
-//     // getchar();
-//     clock_t start = clock();
-//     char *json_string = fieldstat_json_exporter_export(fieldstat_json_exporter);
-//     clock_t end = clock();
-//     // exit(0);
-//     free(json_string);
-//     fieldstat_json_exporter_free(fieldstat_json_exporter);
-
-//     printf("export_many_cells us: %ld\n", end - start);
-//     fieldstat_free(instance);
-
-//     for (int i = 0; i < TAG_NUM; i++) {
-//         delete tags[i];
-//     }
-// }
+    double elapsed_secs = double(end - start) / CLOCKS_PER_SEC;
+    printf("merge_performance_when_comprehensive_sampling_multi_instance elapsed_secs: %f\n", elapsed_secs);
+    EXPECT_TRUE(elapsed_secs < 0.1);
+
+    fieldstat_free(instance_dest);
+    for (int i = 0; i < INSTANCE_NUM; i++) {
+        fieldstat_free(instances[i]);
+    }
+    for (int i = 0; i < DIMENSION_TOTAL; i++) {
+        delete tags[i];
+    }
+}
+
+clock_t perform_merge_test(std::function<void (struct fieldstat*, int, int, int)> metric_add_func, 
+    std::function<int(struct fieldstat*, int)> metric_register_func, enum sampling_mode mode, bool merge_empty_dest)
+{
+    const int MAX_CELL_NUM = 1000;
+    Fieldstat_tag_list_wrapper *tags[MAX_CELL_NUM];
+    for (int i = 0; i < MAX_CELL_NUM; i++) {
+        tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
+    }
+    struct fieldstat *instance = fieldstat_new();
+    int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, mode, MAX_CELL_NUM);
+    int metric_id = metric_register_func(instance, cube_id);
+    for (int j = 0; j < MAX_CELL_NUM; j++) {
+        int cell_id = fieldstat_cube_add(instance, cube_id, tags[j]->get_tag(), 1, 1);
+        metric_add_func(instance, cube_id, metric_id, cell_id);
+    }
+
+    struct fieldstat *instance_dest = fieldstat_new();
+    if (!merge_empty_dest) {
+        fieldstat_merge(instance_dest, instance);
+    }
+
+    clock_t start = clock();
+    fieldstat_merge(instance_dest, instance);
+    clock_t end = clock();
+
+    fieldstat_free(instance_dest);
+    fieldstat_free(instance);
+    for (int i = 0; i < MAX_CELL_NUM; i++) {
+        delete tags[i];
+    }
+
+    return end - start;
+}
+
+TEST(test_performance, merge_performance_one_instance_comprehensive_counter_empty_dest)
+{   
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
+    printf("merge_performance_one_instance_comprehensive_counter_empty_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 1000000);
+}
+
+TEST(test_performance, merge_performance_one_instance_comprehensive_hll_empty_dest)
+{   
+    //     int metric_id = fieldstat_register_hll(instance, cube_id, "czz_test hll metric", 10);
+    // int ret = fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
+
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_hll(instance, cube_id, "hll metric", 6);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
+    printf("merge_performance_one_instance_comprehensive_hll_empty_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 1500);
+}
+
+TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_empty_dest)
+{   
+    // int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test", 1, 100000, 1);
+    // int ret = fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
+
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_hist(instance, cube_id, "histogram metric", 1, 100000, 1);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
+    printf("merge_performance_one_instance_comprehensive_histogram_empty_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 5000);
+}
+
+TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
+{   
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, rand() % 1000);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_TOPK, true);
+    printf("merge_performance_one_instance_topk_counter_empty_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 1000);
+}
+
+TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full_dest)
+{   
+    // int metric_id = fieldstat_register_counter(tmp_i, cube_id, "metric name", false);
+    // fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
+    printf("merge_performance_one_instance_comprehensive_counter_full_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 1000);
+}
+
+TEST(test_performance, merge_performance_one_instance_comprehensive_hll_full_dest)
+{   
+    //     int metric_id = fieldstat_register_hll(instance, cube_id, "czz_test hll metric", 10);
+    // int ret = fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
+
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_hll_add(instance, cube_id, metric_id, cell_id, "hello", 5);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_hll(instance, cube_id, "hll metric", 6);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
+    printf("merge_performance_one_instance_comprehensive_hll_full_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 1300);
+}
+
+TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_full_dest)
+{   
+    // int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test", 1, 600000, 3);
+    // int ret = fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
+
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_hist_record(instance, cube_id, metric_id, cell_id, 1234);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_hist(instance, cube_id, "histogram metric", 1, 100000, 1);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
+    printf("merge_performance_one_instance_comprehensive_histogram_full_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 3 * 1000);
+}
+
+TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
+{   
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, int cell_id) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, rand() % 1000);
+    };
+    auto metric_register_func = [](struct fieldstat *instance, int cube_id) {
+        return fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
+    };
+
+    clock_t elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_TOPK, false);
+    printf("merge_performance_one_instance_topk_counter_full_dest elapsed_secs: %ld\n", elapsed);
+    EXPECT_TRUE(elapsed < 1500);
+}
+
+/* -------------------------------------------------------------------------- */
+/*                                     add                                    */
+/* -------------------------------------------------------------------------- */
+TEST(test_performance, performance_test_add_cells_comprehensive)
+{
+    size_t cell_count = 100000;
+    struct fieldstat_tag tags[cell_count];
+    for (size_t i = 0; i < cell_count; i++) {
+        tags[i] = TEST_TAG_INT;
+        tags[i].value_longlong = i;
+    }
+    // getchar();
+    struct fieldstat *instance = fieldstat_new();
+    fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, cell_count);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
+
+    clock_t start = clock();
+    for (size_t i = 0; i < cell_count; i++) {
+        fieldstat_cube_add(instance, 0, &tags[i % cell_count], 1, 1);
+    }
+    clock_t end = clock();
+    double seconds = (double)(end - start) / cell_count;
+    printf("performance_test_add_cells_comprehensive time cost: %f\n", seconds);
+    EXPECT_TRUE(seconds < 1);
+    fieldstat_free(instance);
+}
+
+TEST(test_performance, performance_test_add_cells_topk)
+{
+    size_t cell_count = 100000;
+    struct fieldstat_tag tags[cell_count];
+    for (size_t i = 0; i < cell_count; i++) {
+        tags[i] = TEST_TAG_INT;
+        // tags[i].value_longlong = rand() % 10000;
+        if (rand()%2)
+            tags[i].value_longlong = i;
+        else
+            tags[i].value_longlong = rand() % 1000;
+    }
+    struct fieldstat *instance = fieldstat_new();
+    fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 1000);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
+
+    // getchar();
+    clock_t start = clock();
+    for (size_t i = 0; i < cell_count; i++) {
+        fieldstat_cube_add(instance, 0, &tags[i % cell_count], 1, 1);
+    }
+    clock_t end = clock();
+    double seconds = (double)(end - start) / cell_count;
+    // exit(0);
+
+    EXPECT_TRUE(seconds < 1);
+    printf("performance_test_on_1000_cells_topk_1000000_times time cost: %f\n", seconds);
+
+    fieldstat_free(instance);
+}
+
+TEST(test_performance, performance_test_add_cells_histogram_record)
+{
+    struct fieldstat *instance = fieldstat_new();
+    fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
+    fieldstat_register_hist(instance, 0, "test", 1, 1000000, 3);
+    int cell_id = fieldstat_cube_add(instance, 0, &TEST_TAG_DOUBLE, 1, 1);
+    size_t test_num = 100000;
+    long long vals[test_num];
+    for (size_t i = 0; i < test_num; i++) {
+        vals[i] = rand() % 1000000 + 1;
+    }
+
+    clock_t start = clock();
+    for (size_t i = 0; i < test_num; i++) {
+        fieldstat_hist_record(instance, 0, 0, cell_id, vals[i]);
+    }
+    clock_t end = clock();
+    double seconds = (double)(end - start) / test_num;
+    printf("performance_test_add_cells_histogram_record time cost: %f\n", seconds);
+    EXPECT_TRUE(seconds < 1);
+    fieldstat_free(instance);
+}
+
+TEST(test_performance, performance_test_add_cells_hll_add)
+{
+    struct fieldstat *instance = fieldstat_new();
+    fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
+    fieldstat_register_hll(instance, 0, "test", 6);
+    int cell_id = fieldstat_cube_add(instance, 0, &TEST_TAG_DOUBLE, 1, 1);
+    size_t test_num = 100000;
+    std::string vals[test_num];
+    for (size_t i = 0; i < test_num; i++) {
+        vals[i] = std::to_string(rand() % 1000000 + 1);
+    }
+
+    clock_t start = clock();
+    for (size_t i = 0; i < test_num; i++) {
+        fieldstat_hll_add(instance, 0, 0, cell_id, vals[i].c_str(), vals[i].length());
+    }
+    clock_t end = clock();
+    double seconds = (double)(end - start) / test_num;
+    printf("performance_test_add_cells_hll_add time cost: %f\n", seconds);
+    EXPECT_TRUE(seconds < 1);
+    fieldstat_free(instance);
+}
+
+/* -------------------------------------------------------------------------- */
+/*                                   export                                   */
+/* -------------------------------------------------------------------------- */
+using namespace std;
+
+TEST(test_performance, export_many_cells)
+{
+    const int MAX_CELL_NUM = 1000;
+    const int TAG_NUM = 3000;
+    const int CUBE_NUM = 10;
+    const int METRIC_NUM = 10;
+
+    Fieldstat_tag_list_wrapper *tags[TAG_NUM];
+    for (int i = 0; i < TAG_NUM; i++) {
+        tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
+    }
+
+    struct fieldstat *instance = fieldstat_new();
+    int cell_id[MAX_CELL_NUM];
+    for (int i = 0; i < CUBE_NUM; i++) {
+        Fieldstat_tag_list_wrapper cube_tag("shared key", i);
+        int cube_id = fieldstat_register_cube(instance, cube_tag.get_tag(), cube_tag.get_tag_count(), SAMPLING_MODE_COMPREHENSIVE, MAX_CELL_NUM);
+        for (int k = 0; k < MAX_CELL_NUM; k++) {
+            cell_id[k] = fieldstat_cube_add(instance, cube_id, tags[rand() % TAG_NUM]->get_tag(), 1, 1);
+        }
+        for (int j = 0; j < METRIC_NUM; j++) {
+            string metric_name = "metric name" + to_string(i) + to_string(j);
+            int metric_id = fieldstat_register_counter(instance, cube_id, metric_name.c_str(), COUNTER_MERGE_BY_SUM);
+
+            for (int k = 0; k < MAX_CELL_NUM; k++) {
+                fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id[k], 1);
+            }
+        }
+    }
+
+    struct fieldstat_json_exporter *fieldstat_json_exporter = fieldstat_json_exporter_new(instance);
+    printf("export_many_cells\n");
+    // getchar();
+    clock_t start = clock();
+    char *json_string = fieldstat_json_exporter_export(fieldstat_json_exporter);
+    clock_t end = clock();
+    // exit(0);
+    free(json_string);
+    fieldstat_json_exporter_free(fieldstat_json_exporter);
+
+    printf("export_many_cells us: %ld\n", end - start);
+    fieldstat_free(instance);
+
+    for (int i = 0; i < TAG_NUM; i++) {
+        delete tags[i];
+    }
+}
 
 /* -------------------------------------------------------------------------- */
 /*                                  serialize                                 */
@@ -389,7 +389,7 @@
 clock_t perform_serialize_test(std::function<void (struct fieldstat*, int, int, int)> metric_add_func, 
     std::function<int(struct fieldstat*, int)> metric_register_func, enum sampling_mode mode)
 {
-    const int MAX_CELL_NUM = 10000;
+    const int MAX_CELL_NUM = 100000;
     Fieldstat_tag_list_wrapper *tags[MAX_CELL_NUM];
     for (int i = 0; i < MAX_CELL_NUM; i++) {
         tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
@@ -434,7 +434,7 @@ TEST(test_performance, serialize_counter)
 
     clock_t elapsed = perform_serialize_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE);
     printf("serialize_counter elapsed_secs: %ld\n", elapsed);
-    EXPECT_TRUE(elapsed < 1000000); // every one 1us
+    EXPECT_TRUE(elapsed < 100000); // every one 1us
 }
 
 TEST(test_performance, serialize_histogram)
@@ -448,7 +448,7 @@ TEST(test_performance, serialize_histogram)
 
     clock_t elapsed = perform_serialize_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE);
     printf("serialize_histogram elapsed_secs: %ld\n", elapsed);
-    EXPECT_TRUE(elapsed < 1000000); // every one 1us
+    EXPECT_TRUE(elapsed < 100000); // every one 1us
 }
 
 TEST(test_performance, serialize_hll)
@@ -462,7 +462,7 @@ TEST(test_performance, serialize_hll)
 
     clock_t elapsed = perform_serialize_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE);
     printf("serialize_hll elapsed_secs: %ld\n", elapsed);
-    EXPECT_TRUE(elapsed < 1000000); // every one 1us
+    EXPECT_TRUE(elapsed < 100000); // every one 1us
 }
 
 int main(int argc, char *argv[])