Merge branch 'refactor-heavykeeper-newkey' into develop-version4

1 files changed, 109 insertions, 99 deletions

diff --git a/test/test_performance.cpp b/test/test_performance.cpp
index 11c05ce..48d3859 100644
--- a/test/test_performance.cpp
+++ b/test/test_performance.cpp
@@ -6,22 +6,32 @@
 #include "fieldstat_exporter.h"
 #include "utils.hpp"
 
+
+int test_fieldstat_cube_create(struct fieldstat *instance, const struct field *tag, size_t tag_count, enum sampling_mode mode, int k, int primary_metric_id=0)
+{
+    int ret = fieldstat_cube_create(instance, tag, tag_count);
+    fieldstat_cube_set_sampling(instance, ret, mode, k, primary_metric_id);
+    return ret;
+}
+
+
 // /* -------------------------------------------------------------------------- */
 // /*                                    merge                                   */
 // /* -------------------------------------------------------------------------- */
-double perform_merge_test(std::function<void (struct fieldstat*, int, int, const struct fieldstat_tag *, int)> metric_add_func, 
+double perform_merge_test(std::function<void (struct fieldstat*, int, int, const struct field *, int)> metric_add_func, 
     std::function<int(struct fieldstat*)> 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];
+    Fieldstat_tag_list_wrapper *fields[MAX_CELL_NUM];
     for (int i = 0; i < MAX_CELL_NUM; i++) {
-        tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
+        fields[i] = new Fieldstat_tag_list_wrapper("my key", i);
     }
     struct fieldstat *instance = fieldstat_new();
-    int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, mode, MAX_CELL_NUM);
+    int cube_id = fieldstat_cube_create(instance, &TEST_SHARED_TAG, 1);
     int metric_id = metric_register_func(instance);
+    fieldstat_cube_set_sampling(instance, cube_id, mode, MAX_CELL_NUM, metric_id);
     for (int j = 0; j < MAX_CELL_NUM; j++) {
-        metric_add_func(instance, cube_id, metric_id, tags[j]->get_tag(), 1);
+        metric_add_func(instance, cube_id, metric_id, fields[j]->get_tag(), 1);
     }
 
     struct fieldstat *instance_dest = fieldstat_new();
@@ -36,7 +46,7 @@ double perform_merge_test(std::function<void (struct fieldstat*, int, int, const
     fieldstat_free(instance_dest);
     fieldstat_free(instance);
     for (int i = 0; i < MAX_CELL_NUM; i++) {
-        delete tags[i];
+        delete fields[i];
     }
 
     return (end - start) / 1000.0;
@@ -44,11 +54,11 @@ double perform_merge_test(std::function<void (struct fieldstat*, int, int, const
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_counter_empty_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, 1);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, 1);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_counter(instance, "metric name");
+        return fieldstat_register_counter(instance, 0, "metric name");
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
@@ -61,11 +71,11 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_hll_empty_de
     //     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, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hll_add(instance, cube_id, metric_id, tags, n_tag, "hello", 5);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_hll_add(instance, cube_id, metric_id, fields, n_field, "hello", 5);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_hll(instance, "hll metric", 6);
+        return fieldstat_register_hll(instance, 0, "hll metric", 6);
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
@@ -75,14 +85,11 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_hll_empty_de
 
 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, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hist_record(instance, cube_id, metric_id, tags, n_tag, 1234);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_histogram_record(instance, cube_id, metric_id, fields, n_field, 1234);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_hist(instance, "histogram metric", 1, 100000, 1);
+        return fieldstat_register_histogram(instance, 0, "histogram metric", 1, 100000, 1);
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
@@ -92,11 +99,11 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_em
 
 TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, rand() % 1000);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, rand() % 1000);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_counter(instance, "metric name");
+        return fieldstat_register_counter(instance, 0, "metric name");
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_TOPK, true);
@@ -106,11 +113,11 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, 1);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, 1);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_counter(instance, "metric name");
+        return fieldstat_register_counter(instance, 0, "metric name");
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
@@ -120,11 +127,11 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_hll_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hll_add(instance, cube_id, metric_id, tags, n_tag, "hello", 5);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_hll_add(instance, cube_id, metric_id, fields, n_field, "hello", 5);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_hll(instance, "hll metric", 6);
+        return fieldstat_register_hll(instance, 0, "hll metric", 6);
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
@@ -134,11 +141,11 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_hll_full_des
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_hist_record(instance, cube_id, metric_id, tags, n_tag, 1234);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_histogram_record(instance, cube_id, metric_id, fields, n_field, 1234);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_hist(instance, "histogram metric", 1, 100000, 1);
+        return fieldstat_register_histogram(instance, 0, "histogram metric", 1, 100000, 1);
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
@@ -148,11 +155,11 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_fu
 
 TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
 {   
-    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct fieldstat_tag *tags, int n_tag) {
-        fieldstat_counter_incrby(instance, cube_id, metric_id, tags, n_tag, rand() % 1000);
+    auto metric_add_func = [](struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, int n_field) {
+        fieldstat_counter_incrby(instance, cube_id, metric_id, fields, n_field, rand() % 1000);
     };
     auto metric_register_func = [](struct fieldstat *instance) {
-        return fieldstat_register_counter(instance, "metric name");
+        return fieldstat_register_counter(instance,0, "metric name");
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_TOPK, false);
@@ -163,14 +170,16 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
 struct fieldstat *construct_fs_with_many_empty_cubes(int cube_num, int metric_num, enum sampling_mode mode)
 {
     struct fieldstat *instance = fieldstat_new();
-    struct fieldstat_tag tmp_tag = TEST_TAG_INT;
+    struct field tmp_tag = TEST_FIELD_INT;
     for (int i = 0; i < cube_num; i++) {
         tmp_tag.value_longlong = i;
-        fieldstat_create_cube(instance, &tmp_tag, 1, mode, 1000);
+        int cube_id = fieldstat_cube_create(instance, &tmp_tag, 1);
 
         for (int j = 0; j < metric_num; j++) {
-            fieldstat_register_counter(instance, std::to_string(j).c_str());
+            fieldstat_register_counter(instance, cube_id, std::to_string(j).c_str());
         }
+
+        fieldstat_cube_set_sampling(instance, cube_id, mode, 1000, 0);
     }
     return instance;
 }
@@ -215,19 +224,19 @@ TEST(test_performance, merge_empty_cubes_topk)
 TEST(test_performance, performance_test_add_cells_comprehensive)
 {
     size_t cell_count = 100000;
-    struct fieldstat_tag tags[cell_count];
+    struct field fields[cell_count];
     for (size_t i = 0; i < cell_count; i++) {
-        tags[i] = TEST_TAG_INT;
-        tags[i].value_longlong = i;
+        fields[i] = TEST_FIELD_INT;
+        fields[i].value_longlong = i;
     }
     // getchar();
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, cell_count);
-    fieldstat_register_counter(instance, "test");
+    test_fieldstat_cube_create(instance, &TEST_FIELD_INT_2, 1, SAMPLING_MODE_COMPREHENSIVE, cell_count);
+    fieldstat_register_counter(instance, 0, "test");
 
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
-        fieldstat_counter_incrby(instance, 0, 0, &tags[i % cell_count], 1, 1);
+        fieldstat_counter_incrby(instance, 0, 0, &fields[i % cell_count], 1, 1);
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / cell_count;
@@ -239,23 +248,24 @@ TEST(test_performance, performance_test_add_cells_comprehensive)
 TEST(test_performance, performance_test_add_cells_topk)
 {
     size_t cell_count = 100000;
-    struct fieldstat_tag tags[cell_count];
+    struct field fields[cell_count];
     for (size_t i = 0; i < cell_count; i++) {
-        tags[i] = TEST_TAG_INT;
-        // tags[i].value_longlong = rand() % 10000;
+        fields[i] = TEST_FIELD_INT;
+        // fields[i].value_longlong = rand() % 10000;
         if (rand()%2)
-            tags[i].value_longlong = i;
+            fields[i].value_longlong = i;
         else
-            tags[i].value_longlong = rand() % 1000;
+            fields[i].value_longlong = rand() % 1000;
     }
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 1000);
-    fieldstat_register_counter(instance, "test");
+    fieldstat_cube_create(instance, &TEST_FIELD_INT_2, 1);
+    fieldstat_register_counter(instance, 0, "test");
+    fieldstat_cube_set_sampling(instance, 0, SAMPLING_MODE_TOPK, 1000, 0);
 
     // getchar();
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
-        fieldstat_counter_incrby(instance, 0, 0, &tags[i % cell_count], 1, 1);
+        fieldstat_counter_incrby(instance, 0, 0, &fields[i % cell_count], 1, 1);
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / cell_count;
@@ -270,8 +280,8 @@ TEST(test_performance, performance_test_add_cells_topk)
 TEST(test_performance, performance_test_add_cells_histogram_record)
 {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_hist(instance, "test", 1, 100000, 3);
+    test_fieldstat_cube_create(instance, &TEST_FIELD_INT_2, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
+    fieldstat_register_histogram(instance, 0, "test", 1, 100000, 3);
     size_t test_num = 100000;
     long long vals[test_num];
     for (size_t i = 0; i < test_num; i++) {
@@ -279,7 +289,7 @@ TEST(test_performance, performance_test_add_cells_histogram_record)
     }
     clock_t start = clock();
     for (size_t i = 0; i < test_num; i++) {
-        fieldstat_hist_record(instance, 0, 0, &TEST_TAG_INT, 1, vals[i]);
+        fieldstat_histogram_record(instance, 0, 0, &TEST_FIELD_INT, 1, vals[i]);
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / test_num;
@@ -291,8 +301,8 @@ TEST(test_performance, performance_test_add_cells_histogram_record)
 TEST(test_performance, performance_test_add_cells_hll_add)
 {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_hll(instance, "test", 6);
+    test_fieldstat_cube_create(instance, &TEST_FIELD_INT_2, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
+    fieldstat_register_hll(instance, 0, "test", 6);
     size_t test_num = 100000;
     std::string vals[test_num];
     for (size_t i = 0; i < test_num; i++) {
@@ -301,7 +311,7 @@ TEST(test_performance, performance_test_add_cells_hll_add)
 
     clock_t start = clock();
     for (size_t i = 0; i < test_num; i++) {
-        fieldstat_hll_add(instance, 0, 0, &TEST_TAG_INT, 1, vals[i].c_str(), vals[i].length());
+        fieldstat_hll_add(instance, 0, 0, &TEST_FIELD_INT, 1, vals[i].c_str(), vals[i].length());
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / test_num;
@@ -313,23 +323,23 @@ TEST(test_performance, performance_test_add_cells_hll_add)
 TEST(test_performance, performance_test_add_cells_comprehensive_5_tags)
 {
     size_t cell_count = 100000;
-    struct fieldstat_tag *tag_v[cell_count];
+    struct field *tag_v[cell_count];
     for (size_t i = 0; i < cell_count; i++) {
-        struct fieldstat_tag *tags = (struct fieldstat_tag *)malloc(sizeof(struct fieldstat_tag) * 5);
+        struct field *fields = (struct field *)malloc(sizeof(struct field) * 5);
 
-        tags[0] = TEST_TAG_INT;
-        tags[1] = TEST_TAG_INT;
-        tags[2] = TEST_TAG_INT;
-        tags[3] = TEST_TAG_INT;
-        tags[4] = TEST_TAG_INT;
-        tags[0].value_longlong = i;
+        fields[0] = TEST_FIELD_INT;
+        fields[1] = TEST_FIELD_INT;
+        fields[2] = TEST_FIELD_INT;
+        fields[3] = TEST_FIELD_INT;
+        fields[4] = TEST_FIELD_INT;
+        fields[0].value_longlong = i;
 
-        tag_v[i] = tags;
+        tag_v[i] = fields;
     }
     // getchar();
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, cell_count);
-    fieldstat_register_counter(instance, "test");
+    test_fieldstat_cube_create(instance, &TEST_FIELD_INT_2, 1, SAMPLING_MODE_COMPREHENSIVE, cell_count);
+    fieldstat_register_counter(instance, 0, "test");
 
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
@@ -337,7 +347,7 @@ TEST(test_performance, performance_test_add_cells_comprehensive_5_tags)
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / cell_count;
-    printf("performance_test_add_cells_comprehensive time 5 tags cost: %f\n", seconds);
+    printf("performance_test_add_cells_comprehensive time 5 fields cost: %f\n", seconds);
     EXPECT_TRUE(seconds < 2);
     fieldstat_free(instance);
 
@@ -349,27 +359,27 @@ TEST(test_performance, performance_test_add_cells_comprehensive_5_tags)
 TEST(test_performance, performance_test_add_cells_histogram_record_5tags)
 {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_hist(instance, "test", 1, 100000, 3);
+    test_fieldstat_cube_create(instance, &TEST_FIELD_INT_2, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
+    fieldstat_register_histogram(instance, 0, "test", 1, 100000, 3);
     size_t test_num = 100000;
     long long vals[test_num];
     for (size_t i = 0; i < test_num; i++) {
         vals[i] = rand() % 100000 + 1;
     }
 
-    struct fieldstat_tag tags[5];
-    tags[0] = TEST_TAG_INT;
-    tags[1] = TEST_TAG_STRING;
-    tags[2] = TEST_TAG_DOUBLE;
-    tags[3] = TEST_TAG_INT;
-    tags[4] = TEST_TAG_INT;
+    struct field fields[5];
+    fields[0] = TEST_FIELD_INT;
+    fields[1] = TEST_FIELD_STRING;
+    fields[2] = TEST_FIELD_DOUBLE;
+    fields[3] = TEST_FIELD_INT;
+    fields[4] = TEST_FIELD_INT;
     clock_t start = clock();
     for (size_t i = 0; i < test_num; i++) {
-        fieldstat_hist_record(instance, 0, 0, tags, 5, vals[i]);
+        fieldstat_histogram_record(instance, 0, 0, fields, 5, vals[i]);
     }
     clock_t end = clock();
     double seconds = (double)(end - start) / test_num;
-    printf("performance_test_add_cells_histogram_record time 5 tags cost: %f\n", seconds);
+    printf("performance_test_add_cells_histogram_record time 5 fields cost: %f\n", seconds);
     EXPECT_TRUE(seconds < 1);
     fieldstat_free(instance);
 }
@@ -377,27 +387,27 @@ TEST(test_performance, performance_test_add_cells_histogram_record_5tags)
 TEST(test_performance, performance_test_add_cells_hll_add_5tags)
 {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_hll(instance, "test", 6);
+    test_fieldstat_cube_create(instance, &TEST_FIELD_INT_2, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
+    fieldstat_register_hll(instance, 0, "test", 6);
     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);
     }
 
-    struct fieldstat_tag tags[5];
-    tags[0] = TEST_TAG_INT;
-    tags[1] = TEST_TAG_STRING;
-    tags[2] = TEST_TAG_DOUBLE;
-    tags[3] = TEST_TAG_INT;
-    tags[4] = TEST_TAG_INT;
+    struct field fields[5];
+    fields[0] = TEST_FIELD_INT;
+    fields[1] = TEST_FIELD_STRING;
+    fields[2] = TEST_FIELD_DOUBLE;
+    fields[3] = TEST_FIELD_INT;
+    fields[4] = TEST_FIELD_INT;
     clock_t start = clock();
     for (size_t i = 0; i < test_num; i++) {
-        fieldstat_hll_add(instance, 0, 0, tags, 5, vals[i].c_str(), vals[i].length());
+        fieldstat_hll_add(instance, 0, 0, fields, 5, 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 5 tags cost: %f\n", seconds);
+    printf("performance_test_add_cells_hll_add time 5 fields cost: %f\n", seconds);
     EXPECT_TRUE(seconds < 1);
     fieldstat_free(instance);
 }
@@ -414,22 +424,22 @@ TEST(test_performance, export_many_cells)
     const int CUBE_NUM = 10;
     const int METRIC_NUM = 10;
 
-    Fieldstat_tag_list_wrapper *tags[TAG_NUM];
+    Fieldstat_tag_list_wrapper *fields[TAG_NUM];
     for (int i = 0; i < TAG_NUM; i++) {
-        tags[i] = new Fieldstat_tag_list_wrapper("my key", i);
+        fields[i] = new Fieldstat_tag_list_wrapper("my key", i);
     }
 
     struct fieldstat *instance = fieldstat_new();
     for (int i = 0; i < CUBE_NUM; i++) {
         Fieldstat_tag_list_wrapper cube_tag("shared key", i);
-        int cube_id = fieldstat_create_cube(instance, cube_tag.get_tag(), cube_tag.get_tag_count(), SAMPLING_MODE_COMPREHENSIVE, MAX_CELL_NUM);
+        int cube_id = test_fieldstat_cube_create(instance, cube_tag.get_tag(), cube_tag.get_tag_count(), SAMPLING_MODE_COMPREHENSIVE, MAX_CELL_NUM);
 
         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, metric_name.c_str());
+            int metric_id = fieldstat_register_counter(instance, cube_id, metric_name.c_str());
 
             for (int k = 0; k < MAX_CELL_NUM; k++) {
-                fieldstat_counter_incrby(instance, cube_id, metric_id, tags[rand() % TAG_NUM]->get_tag(), 1, 1);
+                fieldstat_counter_incrby(instance, cube_id, metric_id, fields[rand() % TAG_NUM]->get_tag(), 1, 1);
             }
         }
     }
@@ -447,7 +457,7 @@ TEST(test_performance, export_many_cells)
     fieldstat_free(instance);
 
     for (int i = 0; i < TAG_NUM; i++) {
-        delete tags[i];
+        delete fields[i];
     }
 }
 
@@ -496,12 +506,12 @@ TEST(test_performance, callibrate_unchanged)
     fieldstat_free(instance_dest);
 }
 
-struct fieldstat *construct_fs_with_many_cells(int cell_num, enum sampling_mode mode)
+struct fieldstat *construct_fs_with_many_cells(int cell_num)
 {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, &TEST_TAG_INT, 1, mode, cell_num);
-    fieldstat_register_counter(instance, "test");
-    struct fieldstat_tag tmp_tag = TEST_TAG_INT;
+    test_fieldstat_cube_create(instance, &TEST_FIELD_INT, 1, SAMPLING_MODE_COMPREHENSIVE, cell_num);
+    fieldstat_register_counter(instance, 0, "test");
+    struct field tmp_tag = TEST_FIELD_INT;
     for (int i = 0; i < cell_num; i++) {
         tmp_tag.value_longlong = i;
         fieldstat_counter_incrby(instance, 0, 0, &tmp_tag, 1, 1);
@@ -512,7 +522,7 @@ struct fieldstat *construct_fs_with_many_cells(int cell_num, enum sampling_mode
 
 TEST(test_performance, reset_many_cells)
 {
-    struct fieldstat *instance = construct_fs_with_many_cells(1000, SAMPLING_MODE_COMPREHENSIVE); // many empty cubes, 10 metrics is a common case
+    struct fieldstat *instance = construct_fs_with_many_cells(1000); // many empty cubes, 10 metrics is a common case
     clock_t start = clock();
     fieldstat_reset(instance);
     clock_t end = clock();