couner merge mode

13 files changed, 131 insertions, 95 deletions

diff --git a/include/fieldstat/fieldstat.h b/include/fieldstat/fieldstat.h
index 6bf60ba..561c645 100644
--- a/include/fieldstat/fieldstat.h
+++ b/include/fieldstat/fieldstat.h
@@ -29,6 +29,12 @@ enum sampling_mode {
     SAMPLING_MODE_TOPK,
 };
 
+enum counter_mode {
+    COUNTER_MERGE_BY_SUM,
+    COUNTER_MERGE_BY_MAX,
+    COUNTER_MERGE_BY_MIN,
+};
+
 struct fieldstat_tag {
 	const char *key;
     enum fs_tag_type type;
@@ -63,10 +69,11 @@ unsigned long fieldstat_get_cube_version(const struct fieldstat *instance, int c
     * @brief add a metric to the cube of cube_id. One metric may have multiple sub-metric that are associated with different cells.
     * @param cube_id: cube id, previously returned by fieldstat_register_cube.
     * @param field_name: name of the metric. Cannot be NULL. Must be unique in this cube.
-    * @param is_gauge: whether this metric is a gauge. Only affects merging.
+    * @param counter_mode: merge method of the metric. Refer to enum counter_mode.
     * @return metric id, if success; otherwise, return -1. Fail when cube is not registered, or the parameter is invalid.
 */
-int fieldstat_register_counter(struct fieldstat *instance, int cube_id, const char *field_name, bool is_gauge);
+int fieldstat_register_counter(struct fieldstat *instance, int cube_id, const char *field_name, enum counter_mode mode);
+// is_gauge: merge 方法：最大 最小 求和 
 
 /*
     * @brief add a metric to the cube of cube_id. One metric may have multiple sub-metric that are associated with different cells. other parameters are the same as fieldstat_register_counter.
@@ -155,6 +162,7 @@ struct fieldstat_tag_list
 };
 
 void fieldstat_get_cubes(const struct fieldstat *instance, int **cube_ids, int *n_cube);
+
 int fieldstat_get_max_metric_id(const struct fieldstat *instance, int cube_id);
 void fieldstat_cube_read_cell(const struct fieldstat *instance, int cube_id,
     int **cell_ids, struct fieldstat_tag_list **tag_list, size_t *n_cell);
diff --git a/src/fieldstat.c b/src/fieldstat.c
index e934bdb..e83f269 100644
--- a/src/fieldstat.c
+++ b/src/fieldstat.c
@@ -353,7 +353,7 @@ static int append_metric_to_cube(struct fs_cube *cube, struct metric *metric)
     return cube->n_metric - 1;
 }
 
-int fieldstat_register_counter(struct fieldstat *instance, int cube_id, const char *field_name, bool is_gauge)
+int fieldstat_register_counter(struct fieldstat *instance, int cube_id, const char *field_name, enum counter_mode mode)
 {
     if (instance == NULL) {
         printf("ERR: fieldstat instance is NULL\n");
@@ -368,7 +368,7 @@ int fieldstat_register_counter(struct fieldstat *instance, int cube_id, const ch
         printf("ERR: fieldstat_register_counter cube is not registered yet\n");
         return -1;
     }
-    struct metric *metric = metric_counter_new(field_name, is_gauge);
+    struct metric *metric = metric_counter_new(field_name, mode);
 
     return append_metric_to_cube(cube, metric);
 }
diff --git a/src/metrics/metric.c b/src/metrics/metric.c
index 64fbb8f..97e166b 100644
--- a/src/metrics/metric.c
+++ b/src/metrics/metric.c
@@ -17,18 +17,13 @@
 
 #define MAX_N_DATA_ARRAY_ITEM_INIT 1024
 
-enum counter_metric_type {
-    COUNTER_TYPE_COUNTER,
-    COUNTER_TYPE_GAUGE,
-};
-
 struct metric_counter_or_gauge {
-    enum counter_metric_type type;
+    enum counter_mode mode;
     long long value;
 };
 
 struct para_counter {
-    enum counter_metric_type type;
+    enum counter_mode mode;
 };
 
 struct para_hdr{
@@ -129,7 +124,7 @@ struct metric_measure_data *metric_scheme_counter_new(const struct metric_parame
     struct metric_counter_or_gauge *counter = (struct metric_counter_or_gauge *)malloc(sizeof(struct metric_counter_or_gauge));
     data->counter = counter;
     counter->value = 0;
-    counter->type = para->counter.type;
+    counter->mode = para->counter.mode;
     return data;
 }
 
@@ -142,7 +137,7 @@ static void metric_scheme_counter_free(struct metric_measure_data *data)
 /*
     "counter": {
         "value": 0
-        "type": 0(counter) / 1(gauge)
+        "mode": 0(sum) / 1(max)  /  2(min)
     }
 */
 static void metric_scheme_counter_serialize(const struct metric_measure_data *data, char **blob, size_t *blob_size)
@@ -154,8 +149,8 @@ static void metric_scheme_counter_serialize(const struct metric_measure_data *da
 
     mpack_write_cstr(&writer, "value");
     mpack_write_i64(&writer, counter->value);
-    mpack_write_cstr(&writer, "type");
-    mpack_write_i8(&writer, counter->type);
+    mpack_write_cstr(&writer, "mode");
+    mpack_write_i8(&writer, counter->mode);
 
     mpack_complete_map(&writer);
     if (mpack_writer_destroy(&writer) != mpack_ok) {
@@ -168,17 +163,20 @@ static int metric_scheme_counter_merge(struct metric_measure_data *pthis, const
     struct metric_counter_or_gauge *counter = pthis->counter;
     struct metric_counter_or_gauge *from_counter = from->counter;
     
-    if (counter->type != from_counter->type) {
+    if (counter->mode != from_counter->mode) {
         printf("ERR: counter type not match!\n");
         return -1;
     }
-    switch (counter->type) {
-        case COUNTER_TYPE_COUNTER:
+    switch (counter->mode) {
+        case COUNTER_MERGE_BY_SUM:
             counter->value += from_counter->value;
             break;
-        case COUNTER_TYPE_GAUGE:
+        case COUNTER_MERGE_BY_MAX:
             counter->value = counter->value > from_counter->value ? counter->value : from_counter->value;
             break;
+        case COUNTER_MERGE_BY_MIN:
+            counter->value = counter->value < from_counter->value ? counter->value : from_counter->value;
+            break;
         default:
             printf("ERR: unknown counter type\n");
             return -1;
@@ -192,7 +190,7 @@ static int metric_scheme_counter_copy(struct metric_measure_data *pthis, const s
     struct metric_counter_or_gauge *counter = pthis->counter;
     const struct metric_counter_or_gauge *from_counter = from->counter;
     counter->value = from_counter->value;
-    counter->type = from_counter->type;
+    counter->mode = from_counter->mode;
     return 0;
 }
 
@@ -208,7 +206,7 @@ struct metric_measure_data *metric_scheme_counter_deserialize(const char *blob,
     ret->counter = counter;
 
     counter->value = mpack_node_i64(mpack_node_map_cstr(content_root, "value"));
-    counter->type = mpack_node_i8(mpack_node_map_cstr(content_root, "type"));
+    counter->mode = mpack_node_i8(mpack_node_map_cstr(content_root, "mode"));
 
     if (mpack_tree_destroy(&content_tree) != mpack_ok) {
         printf("ERR: An error occurred in counter_metric_deserialize!\n");
@@ -349,7 +347,7 @@ struct metric_parameter *construct_parameters(enum metric_type type, ...)
     va_start(ap, type);
     switch (type) {
         case METRIC_TYPE_COUNTER:
-            paras->counter.type = (enum counter_metric_type)va_arg(ap, int);
+            paras->counter.mode = (enum counter_mode)va_arg(ap, int);
             break;
         case METRIC_TYPE_HLL:
             paras->hll.precision = (char)va_arg(ap, int);
@@ -495,7 +493,7 @@ void metric_serialize_parameters(const struct metric *metric, char **blob, size_
     {
     case METRIC_TYPE_COUNTER:
         mpack_write_cstr(&writer, "merge_type");
-        mpack_write_i32(&writer, para->counter.type);
+        mpack_write_i32(&writer, para->counter.mode);
     case METRIC_TYPE_HLL:
         mpack_write_cstr(&writer, "prec");
         mpack_write_i32(&writer, para->hll.precision);
@@ -752,9 +750,9 @@ struct metric_measure_data *metric_find_or_new_cell(struct metric *pthis, int ce
     return data;
 }
 
-struct metric *metric_counter_new(const char *name, bool is_gauge)
+struct metric *metric_counter_new(const char *name, enum counter_mode mode)
 {
-    struct metric_parameter *metric_para = construct_parameters(METRIC_TYPE_COUNTER, is_gauge ? COUNTER_TYPE_GAUGE : COUNTER_TYPE_COUNTER);
+    struct metric_parameter *metric_para = construct_parameters(METRIC_TYPE_COUNTER, mode);
     struct metric *pthis = metric_new(name, METRIC_TYPE_COUNTER, metric_para);
 
     return pthis;
@@ -771,7 +769,7 @@ int metric_counter_set(struct metric *pthis, int cell_id, long long value)
 {
     struct metric_measure_data *data = metric_find_or_new_cell(pthis, cell_id);
     struct metric_counter_or_gauge *counter = data->counter;
-    if (counter->type == COUNTER_TYPE_COUNTER) {
+    if (counter->mode == COUNTER_MERGE_BY_SUM) {
         return -1;
     }
     counter->value = value;
diff --git a/src/metrics/metric.h b/src/metrics/metric.h
index 8e645a6..6122746 100644
--- a/src/metrics/metric.h
+++ b/src/metrics/metric.h
@@ -20,7 +20,7 @@ int metric_merge_or_copy_cell(struct metric *dest, const struct metric *src, int
 void metric_get_plain_blob(const struct metric *pthis, int cell_id, char **blob, size_t *blob_size);
 void metric_delete_cell(struct metric *pthis, int cell_id);
 
-struct metric *metric_counter_new(const char *name, bool is_gauge);
+struct metric *metric_counter_new(const char *name, enum counter_mode mode);
 void metric_counter_incrby(struct metric *pthis, int cell_id, long long value);
 int metric_counter_set(struct metric *pthis, int cell_id, long long value);
 long long metric_counter_get(const struct metric *pthis, int cell_id);
diff --git a/test/profiling/main.c b/test/profiling/main.c
index f4a25fd..91dc6e3 100644
--- a/test/profiling/main.c
+++ b/test/profiling/main.c
@@ -81,7 +81,7 @@ void performance_cube_add_comprehensive()
     clock_t start, end;
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_COMPREHENSIVE, 64000);
-    fieldstat_register_counter(instance, 0, "test", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
     start = clock();
     for (int i = 0; i < 64000; i++) {
         (void)fieldstat_cube_add(instance, 0, &tags[i], 1, 1);
@@ -119,7 +119,7 @@ void topk_K_100_tag_2()
     getchar();
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_TOPK, 1000);
-    fieldstat_register_counter(instance, 0, "test", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
     struct fieldstat_tag server_ip_tag = {"server_ip", TAG_CSTRING, {.value_str = "192.168.0.1"}};
     char client_ip[] = "123.123.123.123.1234";
     struct fieldstat_tag client_ip_tag = {"client_ip", TAG_CSTRING, {.value_str = client_ip}};
@@ -151,7 +151,7 @@ int topk_and_find_max_cell_id(int K, int *tag_vals, int n_tags)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_TOPK, K);
-    fieldstat_register_counter(instance, 0, "test", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
     struct fieldstat_tag total = TEST_TAG_INT;
     for (int i = 0; i < n_tags; i++) {
         total.value_longlong = tag_vals[i];
diff --git a/test/test_exporter_json.cpp b/test/test_exporter_json.cpp
index 97a387a..8fdee94 100644
--- a/test/test_exporter_json.cpp
+++ b/test/test_exporter_json.cpp
@@ -163,8 +163,8 @@ void topk_init(struct fieldstat *instance, unsigned int test_expected_big_count)
 {
     const char *field_name[TEST_METRIC_NUM] = {"topk1", "topk2"};
     int cube_id = fieldstat_register_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_TOPK, TEST_TOPK_STANDARD_K);
-    int m1 = fieldstat_register_counter(instance, cube_id, field_name[0], 0);
-    int m2 = fieldstat_register_counter(instance, cube_id, field_name[1], 0);
+    int m1 = fieldstat_register_counter(instance, cube_id, field_name[0], COUNTER_MERGE_BY_SUM);
+    int m2 = fieldstat_register_counter(instance, cube_id, field_name[1], COUNTER_MERGE_BY_SUM);
 
     std::function<void(Fieldstat_tag_list_wrapper *, unsigned int *)> topk_add = [instance, cube_id, m1, m2](
             const Fieldstat_tag_list_wrapper *my_tags, unsigned int counts[TEST_METRIC_NUM]) {
@@ -186,7 +186,7 @@ TEST(export_test, cjson_export_with_fixed_tag_and_many_metrics_on_one_cube_of_co
     // new instance
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, tag_list_num);
-    int id_counter = fieldstat_register_counter(instance, cube_id, "counter", 0);
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     int id_gauge = fieldstat_register_hll(instance, cube_id, "gauge", g_hll_standard->cfg.precision);
     int id_histogram = fieldstat_register_hist(instance, cube_id, "histogram",
         g_histogram_standard->lowest_discernible_value, g_histogram_standard->highest_trackable_value, g_histogram_standard->significant_figures);
@@ -287,7 +287,7 @@ TEST(export_test, only_registered_but_not_added_export_null_with_global_tag)
     struct fieldstat *instance = fieldstat_new();
 
     int cube_id = fieldstat_register_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
-    fieldstat_register_counter(instance, cube_id, "counter", 0);
+    fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     fieldstat_register_hll(instance, cube_id, "gauge", g_hll_standard->cfg.precision);
     fieldstat_register_hist(instance, cube_id, "histogram",
         g_histogram_standard->lowest_discernible_value, g_histogram_standard->highest_trackable_value, g_histogram_standard->significant_figures);
@@ -305,7 +305,7 @@ TEST(export_test, skip_two_empty_cube_and_export_last_one_with_global_tag)
     int cube_id_1 = fieldstat_register_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
     (void)fieldstat_register_hll(instance, cube_id_1, "gauge", g_hll_standard->cfg.precision);
     int cube_id_2 = fieldstat_register_cube(instance, TEST_TAG_SHARED2, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
-    (void)fieldstat_register_counter(instance, cube_id_2, "counter", false);
+    (void)fieldstat_register_counter(instance, cube_id_2, "counter", COUNTER_MERGE_BY_SUM);
     int cube_id_3 = fieldstat_register_cube(instance, TEST_TAG_SHARED3, 1, SAMPLING_MODE_COMPREHENSIVE, 3);
     int id_histogram = fieldstat_register_hist(instance, cube_id_3, "histogram",
         g_histogram_standard->lowest_discernible_value, g_histogram_standard->highest_trackable_value, g_histogram_standard->significant_figures);
@@ -354,10 +354,10 @@ TEST(export_test, skip_empty_metrics_given_cube_deleted) {
     int cube_id_del = fieldstat_register_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
     int cube_id = fieldstat_register_cube(instance, TEST_TAG_SHARED2, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
     fieldstat_unregister_cube(instance, cube_id_del);
-    (void)fieldstat_register_counter(instance, cube_id, "counter", false);
-    (void)fieldstat_register_counter(instance, cube_id, "counter2", false);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "counter3", false);
-    (void)fieldstat_register_counter(instance, cube_id, "counter4", false);
+    (void)fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
+    (void)fieldstat_register_counter(instance, cube_id, "counter2", COUNTER_MERGE_BY_SUM);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter3", COUNTER_MERGE_BY_SUM);
+    (void)fieldstat_register_counter(instance, cube_id, "counter4", COUNTER_MERGE_BY_SUM);
 
     const int tag_num = 1;
     Fieldstat_tag_list_wrapper *tags[tag_num];
diff --git a/test/test_fuzz_test.cpp b/test/test_fuzz_test.cpp
index e05b28e..de5be99 100644
--- a/test/test_fuzz_test.cpp
+++ b/test/test_fuzz_test.cpp
@@ -54,12 +54,12 @@ TEST(Fuzz_test, both_comp_and_topk_cubes_with_merge_and_reset_expecting_correct_
     }
 
     std::function<int(int)> metric_reg_funcs_comp[METRIC_NUM] = {
-        std::bind(fieldstat_register_counter, instance, std::placeholders::_1, metric_name_of_comprehensive[0], false),
+        std::bind(fieldstat_register_counter, instance, std::placeholders::_1, metric_name_of_comprehensive[0], COUNTER_MERGE_BY_SUM),
         std::bind(fieldstat_register_hll, instance, std::placeholders::_1, metric_name_of_comprehensive[1], 10), // 4: precision
     };
     std::function<int(int)> metric_reg_funcs_topk[METRIC_NUM] = {
-        std::bind(fieldstat_register_counter, instance, std::placeholders::_1, metric_name_of_topk[0], false),
-        std::bind(fieldstat_register_counter, instance, std::placeholders::_1, metric_name_of_topk[1], false),
+        std::bind(fieldstat_register_counter, instance, std::placeholders::_1, metric_name_of_topk[0], COUNTER_MERGE_BY_SUM),
+        std::bind(fieldstat_register_counter, instance, std::placeholders::_1, metric_name_of_topk[1], COUNTER_MERGE_BY_SUM),
     };
 
     for (int i = 0; i < CUBE_NUM; i++) {
diff --git a/test/test_merge.cpp b/test/test_merge.cpp
index 9cf1989..4e7a9b1 100644
--- a/test/test_merge.cpp
+++ b/test/test_merge.cpp
@@ -35,20 +35,20 @@ TEST(unit_test_merge, test_metric_name_mapping_with_new_metric_on_existing_cube)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id1 = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id_1_0 = fieldstat_register_counter(instance, cube_id1, "metric_name cube1 cube2", false);
+    int metric_id_1_0 = fieldstat_register_counter(instance, cube_id1, "metric_name cube1 cube2", COUNTER_MERGE_BY_SUM);
     int cell_id_1_0 = fieldstat_cube_add(instance, cube_id1, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id1, metric_id_1_0, cell_id_1_0, 1);
-    int metric_id_1_1 = fieldstat_register_counter(instance, cube_id1, "shared name", false);
+    int metric_id_1_1 = fieldstat_register_counter(instance, cube_id1, "shared name", COUNTER_MERGE_BY_SUM);
     int cell_id_1_1 = fieldstat_cube_add(instance, cube_id1, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id1, metric_id_1_1, cell_id_1_1, 2);
     int cube_id2 = fieldstat_register_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id_2_0 = fieldstat_register_counter(instance, cube_id2, "metric_name cube1 cube2", false);
+    int metric_id_2_0 = fieldstat_register_counter(instance, cube_id2, "metric_name cube1 cube2", COUNTER_MERGE_BY_SUM);
     int cell_id_2_0 = fieldstat_cube_add(instance, cube_id2, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id2, metric_id_2_0, cell_id_2_0, 3);
 
     struct fieldstat *instance_dest = fieldstat_new();
     int cube_id_dest = fieldstat_register_cube(instance_dest, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    (void)fieldstat_register_counter(instance_dest, cube_id_dest, "shared name", false);
+    (void)fieldstat_register_counter(instance_dest, cube_id_dest, "shared name", COUNTER_MERGE_BY_SUM);
 
     fieldstat_merge(instance_dest, instance);
 
@@ -79,7 +79,7 @@ TEST(unit_test_merge, cube_shared_tag_mapping_with_new_cube)
     struct fieldstat *instance = fieldstat_new();
     (void)fieldstat_register_cube(instance, &TEST_TAG_DOUBLE, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int cube_id2 = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(instance, cube_id2, "metric in cube 2", false);
+    fieldstat_register_counter(instance, cube_id2, "metric in cube 2", COUNTER_MERGE_BY_SUM);
     struct fieldstat *instance_dest = fieldstat_new();
     int cube_id_dest = fieldstat_register_cube(instance_dest, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
 
@@ -115,7 +115,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_comprehensive)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(instance, cube_id, "metric_name", false);
+    fieldstat_register_counter(instance, cube_id, "metric_name", COUNTER_MERGE_BY_SUM);
 
     struct fieldstat *instance_dest = fieldstat_new();
 
@@ -136,7 +136,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_comprehensive)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", COUNTER_MERGE_BY_SUM);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
 
@@ -174,7 +174,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_comprehens
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", COUNTER_MERGE_BY_SUM);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 5);
     struct fieldstat *instance_dest = fieldstat_new();
@@ -201,7 +201,7 @@ TEST(unit_test_merge, new_too_many_cells_on_one_metric_given_source_cube_reset_a
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 2);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
     int cell_id1 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
@@ -233,15 +233,15 @@ TEST(unit_test_merge, new_too_many_cells_on_multiple_metric_given_source_cube_re
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 2);
-    int metric_id1 = fieldstat_register_counter(instance, cube_id, "metric name1", false);
-    int metric_id2 = fieldstat_register_counter(instance, cube_id, "metric name2", false);
+    int metric_id1 = fieldstat_register_counter(instance, cube_id, "metric name1", COUNTER_MERGE_BY_SUM);
+    int metric_id2 = fieldstat_register_counter(instance, cube_id, "metric name2", COUNTER_MERGE_BY_SUM);
     int cell_id1 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id1, cell_id1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
     fieldstat_reset(instance);
 
-    int metric_id3 = fieldstat_register_counter(instance, cube_id, "metric name3", false);
+    int metric_id3 = fieldstat_register_counter(instance, cube_id, "metric name3", COUNTER_MERGE_BY_SUM);
     int cell_id2 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_INT, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id3, cell_id2, 2);
     int cell_id3 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_DOUBLE, 1, 1);
@@ -275,7 +275,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, cube_id, "metric_name", false);
+    fieldstat_register_counter(instance, cube_id, "metric_name", COUNTER_MERGE_BY_SUM);
 
     struct fieldstat *instance_dest = fieldstat_new();
 
@@ -296,7 +296,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", COUNTER_MERGE_BY_SUM);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
 
@@ -334,7 +334,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name", COUNTER_MERGE_BY_SUM);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 5);
     struct fieldstat *instance_dest = fieldstat_new();
@@ -369,7 +369,7 @@ TEST(unit_test_merge, new_too_many_cells_on_one_metric_given_source_cube_reset_a
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
     int cell_id1 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
@@ -399,15 +399,15 @@ TEST(unit_test_merge, new_too_many_cells_on_multiple_metric_given_source_cube_re
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_id1 = fieldstat_register_counter(instance, cube_id, "metric name1", false);
-    int metric_id2 = fieldstat_register_counter(instance, cube_id, "metric name2", false);
+    int metric_id1 = fieldstat_register_counter(instance, cube_id, "metric name1", COUNTER_MERGE_BY_SUM);
+    int metric_id2 = fieldstat_register_counter(instance, cube_id, "metric name2", COUNTER_MERGE_BY_SUM);
     int cell_id1 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id1, cell_id1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
     fieldstat_reset(instance);
 
-    int metric_id3 = fieldstat_register_counter(instance, cube_id, "metric name3", false);
+    int metric_id3 = fieldstat_register_counter(instance, cube_id, "metric name3", COUNTER_MERGE_BY_SUM);
     int cell_id2 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_INT, 1, 2);
     fieldstat_counter_incrby(instance, cube_id, metric_id3, cell_id2, 2);
     int cell_id3 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_DOUBLE, 1, 3);
@@ -480,7 +480,7 @@ struct fieldstat *test_push_flows(vector<Fieldstat_tag_list_wrapper *> &flows_in
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, K);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name", COUNTER_MERGE_BY_SUM);
     for (size_t i = 0; i < flows_in_test.size(); i++) {
         int cell_id = fieldstat_cube_add(instance, cube_id, flows_in_test[i]->get_tag(), flows_in_test[i]->get_tag_count(), count);
         if (cell_id < 0) {
@@ -613,7 +613,7 @@ TEST(unit_test_merge, exception_test_given_cell_added_but_no_metric_operation_gi
     struct fieldstat *instance = fieldstat_new();
     struct fieldstat *instance2 = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name1", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name1", COUNTER_MERGE_BY_SUM);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
 
     fieldstat_merge(instance2, instance);
@@ -634,11 +634,11 @@ TEST(unit_test_merge, exception_test_given_cell_added_but_no_metric_operation_gi
     struct fieldstat *instance = fieldstat_new();
     struct fieldstat *instance2 = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name1", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name1", COUNTER_MERGE_BY_SUM);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
 
     int cube_id_dst = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_id_dst = fieldstat_register_counter(instance, cube_id_dst, "metric name1", false);
+    int metric_id_dst = fieldstat_register_counter(instance, cube_id_dst, "metric name1", COUNTER_MERGE_BY_SUM);
     int cell_id_dst = fieldstat_cube_add(instance, cube_id_dst, &TEST_TAG_STRING, 1, 1);
     fieldstat_counter_incrby(instance, cube_id_dst, metric_id_dst, cell_id_dst, 123);
 
diff --git a/test/test_metric_counter.cpp b/test/test_metric_counter.cpp
index 76efbf3..9b63e13 100644
--- a/test/test_metric_counter.cpp
+++ b/test/test_metric_counter.cpp
@@ -13,7 +13,7 @@ struct fieldstat *test_init_standard_instance_one_cube_one_metric_one_cell_count
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     EXPECT_EQ(cube_id, 0);
 
-    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", is_gauge);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", is_gauge ? COUNTER_MERGE_BY_MAX : COUNTER_MERGE_BY_SUM);
     EXPECT_EQ(metric_id, 0);
 
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
@@ -194,7 +194,7 @@ TEST(metric_test_counter, topk_add_and_test_accuracy)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, 0, "test", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
 
     int tag_list_num = 10000;
     Fieldstat_tag_list_wrapper *tags[tag_list_num];
@@ -253,7 +253,7 @@ TEST(metric_test_counter, topk_add_with_monotonically_increasing_flow_expecting_
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, 0, "test", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
 
     const int end_cell_id = 10 * 8;
     const int tag_list_num = 100;
@@ -282,7 +282,7 @@ TEST(metric_test_counter, add_or_set_with_wrong_cell_id_expecting_fail)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, 0, "test", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
 
     int ret = fieldstat_counter_incrby(instance, 0, 0, 1, 1);
     EXPECT_EQ(ret, -3);
@@ -309,7 +309,7 @@ TEST(metric_test_counter, add_with_wrong_metric_id_expecting_fail)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "test", 0);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "test", COUNTER_MERGE_BY_SUM);
 
     int ret = fieldstat_counter_incrby(instance, cube_id, metric_id + 1, 1, 1);
     EXPECT_EQ(ret, -2);
@@ -323,7 +323,7 @@ TEST(metric_test_counter, set_with_wrong_cell_id_expecting_fail)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, 0, "test", 1);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_MAX);
 
     int ret = fieldstat_counter_set(instance, 0, 0, 1, 1);
     EXPECT_EQ(ret, -3);
@@ -350,7 +350,7 @@ TEST(metric_test_counter, set_with_wrong_metric_id_expecting_fail)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "test", 1);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "test", COUNTER_MERGE_BY_MAX);
 
     int ret = fieldstat_counter_set(instance, cube_id, metric_id + 1, 1, 1);
     EXPECT_EQ(ret, -2);
diff --git a/test/test_performance.cpp b/test/test_performance.cpp
index 281a917..361d010 100644
--- a/test/test_performance.cpp
+++ b/test/test_performance.cpp
@@ -25,7 +25,7 @@ TEST(test_performance, merge_performance_when_comprehensive_sampling_multi_insta
     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", false);
+        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) {
@@ -98,13 +98,11 @@ clock_t perform_merge_test(std::function<void (struct fieldstat*, int, int, int)
 
 TEST(test_performance, merge_performance_one_instance_comprehensive_counter_empty_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", false);
+        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);
@@ -152,7 +150,7 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
         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", false);
+        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);
@@ -168,7 +166,7 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full
         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", false);
+        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);
@@ -216,7 +214,7 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
         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", false);
+        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);
@@ -238,7 +236,7 @@ TEST(test_performance, performance_test_add_cells_comprehensive)
     // 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", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
 
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
@@ -265,7 +263,7 @@ TEST(test_performance, performance_test_add_cells_topk)
     }
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 1000);
-    fieldstat_register_counter(instance, 0, "test", 0);
+    fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
 
     // getchar();
     clock_t start = clock();
@@ -355,7 +353,7 @@ TEST(test_performance, export_many_cells)
         }
         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(), false);
+            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);
diff --git a/test/test_register_and_reset.cpp b/test/test_register_and_reset.cpp
index 7ca489c..8376f97 100644
--- a/test/test_register_and_reset.cpp
+++ b/test/test_register_and_reset.cpp
@@ -48,7 +48,7 @@ TEST(test_register, delete_comprehensive_cube_with_cells_and_metrics)
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_INT, 1, 1);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
 
     fieldstat_unregister_cube(instance, cube_id);
@@ -60,7 +60,7 @@ TEST(test_register, delete_topk_cube_with_cells_and_metrics)
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_INT, 1, 1);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
 
     fieldstat_unregister_cube(instance, cube_id);
@@ -72,7 +72,7 @@ TEST(test_register, reset_and_try_to_query_cell)
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_INT, 1, 1);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
 
     fieldstat_reset(instance);
@@ -93,7 +93,7 @@ TEST(test_register, register_many_cubes)
     // try to use the cube
     for (int i = 0; i < registered_cube; i++) {
         int cell_id = fieldstat_cube_add(instance, i, &TEST_TAG_INT, 1, 1);
-        int metric_id = fieldstat_register_counter(instance, i, "counter", false);
+        int metric_id = fieldstat_register_counter(instance, i, "counter", COUNTER_MERGE_BY_SUM);
         fieldstat_counter_incrby(instance, i, metric_id, cell_id, i);
     }
 
@@ -116,7 +116,7 @@ TEST(test_register, add_long_tagged_cells)
     int cell_id = fieldstat_cube_add(instance, cube_id, test_tag_long, 100, 1);
     EXPECT_EQ(cell_id, 0);
 
-    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 10086);
 
     EXPECT_EQ(fieldstat_counter_get(instance, cube_id, metric_id, cell_id), 10086);
@@ -130,7 +130,7 @@ TEST(test_register, register_too_many_metrics)
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int metric_id = 0;
     for (int i = 0; i < 50; i++) {
-        metric_id = fieldstat_register_counter(instance, cube_id, (std::string("counter ") + std::to_string(i)).c_str(), false);
+        metric_id = fieldstat_register_counter(instance, cube_id, (std::string("counter ") + std::to_string(i)).c_str(), COUNTER_MERGE_BY_SUM);
         EXPECT_EQ(metric_id, i);
     }
 
@@ -161,8 +161,8 @@ TEST(test_register, dup_registered_info_with_cube_and_metric_without_cell)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", false);
-    int metric_id2 = fieldstat_register_counter(instance, cube_id, "counter2", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
+    int metric_id2 = fieldstat_register_counter(instance, cube_id, "counter2", COUNTER_MERGE_BY_SUM);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_INT, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
     int cube_id_del = fieldstat_register_cube(instance, &TEST_TAG_DOUBLE_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
@@ -199,8 +199,8 @@ TEST(test_register, unregister_cube_on_wrong_instance)
 
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int cube_id2 = fieldstat_register_cube(instance, &TEST_TAG_DOUBLE, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", false);
-    int metric_id2 = fieldstat_register_counter(instance, cube_id2, "counter2", false);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
+    int metric_id2 = fieldstat_register_counter(instance, cube_id2, "counter2", COUNTER_MERGE_BY_SUM);
     int cell_id = fieldstat_cube_add(instance, cube_id, &TEST_TAG_INT, 1, 1);
     int cell_id2 = fieldstat_cube_add(instance, cube_id2, &TEST_TAG_INT, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id, 1);
diff --git a/test/test_serialize.cpp b/test/test_serialize.cpp
index 23ec9d3..95bf70a 100644
--- a/test/test_serialize.cpp
+++ b/test/test_serialize.cpp
@@ -8,7 +8,7 @@ TEST(unit_test_serialize, serialize_and_deserialize_fieldstat_instance_comprehen
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", true);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", COUNTER_MERGE_BY_MAX);
     int cell_id1 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     int cell_id2 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING_collided, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id1, 10086);
@@ -57,7 +57,7 @@ TEST(unit_test_serialize, serialize_and_deserialize_fieldstat_instance_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", true);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", COUNTER_MERGE_BY_MAX);
     int cell_id1 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING, 1, 1);
     int cell_id2 = fieldstat_cube_add(instance, cube_id, &TEST_TAG_STRING_collided, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, cell_id1, 10086);
@@ -105,7 +105,7 @@ TEST(unit_test_serialize, rearrange_tags_when_serialize)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", true);
+    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric", COUNTER_MERGE_BY_MAX);
     struct fieldstat_tag tag1 = {"tag1", TAG_INTEGER, 1};
     struct fieldstat_tag tag2 = {"tag1", TAG_INTEGER, 2};
     struct fieldstat_tag tag3 = {"tag1", TAG_DOUBLE, {.value_double = 3.0}};
diff --git a/tmp/leetcode.cpp b/tmp/leetcode.cpp
new file mode 100644
index 0000000..1b7b8d4
--- /dev/null
+++ b/tmp/leetcode.cpp
@@ -0,0 +1,32 @@
+// 1289. 下降路径最小和 II
+
+
+// 给你一个 n x n 整数矩阵 grid ，请你返回 非零偏移下降路径 数字和的最小值。
+
+// 非零偏移下降路径 定义为：从 grid 数组中的每一行选择一个数字，且按顺序选出来的数字中，相邻数字不在原数组的同一列。
+
+// https://leetcode.cn/problems/minimum-falling-path-sum-ii/description/
+
+// 百分之一百动态规划
+/* 
+注意到：一行选哪个不会影响下面第二行选哪个。对于每个位置，记录下来最小的和第二小的就行
+选最小的，如果上方的最小和下方的最小都不在同一行。或者选第二小的。
+额，总之分支成两种情况。
+
+s[i, j] = s[i - 1, p] + v[i, j] or 
+        = s[i - 1, j] + v[i, p]
+
+算是想出来了，但是灵感是copilot给的
+*/
+
+
+
+#include <vector>
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+public:
+    
+};
\ No newline at end of file