register metric to cube

17 files changed, 528 insertions, 526 deletions

diff --git a/include/fieldstat/fieldstat.h b/include/fieldstat/fieldstat.h
index 92e8ceb..f9dcfda 100644
--- a/include/fieldstat/fieldstat.h
+++ b/include/fieldstat/fieldstat.h
@@ -90,14 +90,14 @@ int fieldstat_destroy_cube(struct fieldstat *instance, int cube_id);
     * @param metric_name: name of the metric. Cannot be NULL. Must be unique.
     * @return metric id>=0 if success. If failed, return FS_ERR_NULL_HANDLER, FS_ERR_INVALID_KEY(when metric_name is not unique in this cube)
 */
-int fieldstat_register_counter(struct fieldstat *instance, const char *metric_name);
+int fieldstat_register_counter(struct fieldstat *instance, int cube_id, const char *metric_name);
 
 /*
     * @brief refer to fieldstat_register_counter.
     * @param precision: the bigger, the larger memory consumption, while accuracy improved. Must be in [4, 18].
     * @return metric id if success. If failed, return FS_ERR_NULL_HANDLER, FS_ERR_INVALID_KEY(when metric_name is not unique in this cube), or FS_ERR_INVALID_PARAM(if precision not in range)
 */
-int fieldstat_register_hll(struct fieldstat *instance, const char *metric_name, unsigned char precision);
+int fieldstat_register_hll(struct fieldstat *instance, int cube_id, const char *metric_name, unsigned char precision);
 
 /*
     * @brief refer to fieldstat_register_counter.
@@ -106,7 +106,7 @@ int fieldstat_register_hll(struct fieldstat *instance, const char *metric_name,
     * @param significant_figures: the precision of the histogram. Must be in [1, 5].
         * @return metric id if success. If failed, return FS_ERR_NULL_HANDLER, FS_ERR_INVALID_KEY(when metric_name is not unique in this cube), or FS_ERR_INVALID_PARAM(if any of the 3 params are out of range)
 */
-int fieldstat_register_hist(struct fieldstat *instance, const char *metric_name, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures);
+int fieldstat_register_hist(struct fieldstat *instance, int cube_id, const char *metric_name, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures);
 
 /*
     * @brief let the value of counter metric of cell_id increase by `increment`.
@@ -180,15 +180,15 @@ void fieldstat_get_cubes(const struct fieldstat *instance, int **cube_ids, int *
 /*
     * @brief Get all the registered metrics by fieldstat_register_counter, fieldstat_register_hll, fieldstat_register_hist.
 */
-void fieldstat_get_metrics(const struct fieldstat *instance, int **metric_id_out, size_t *n_metric);
+void fieldstat_cube_get_metrics(const struct fieldstat *instance, int cube_id, int **metric_id_out, size_t *n_metric);
 
 void fieldstat_get_metric_in_cell(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int **metric_id_out, size_t *n_metric_out);
 
 // query the name of the metric, return NULL if metric_id is invalid.
-const char *fieldstat_get_metric_name(const struct fieldstat *instance, int metric_id);
+const char *fieldstat_get_metric_name(const struct fieldstat *instance, int cube_id, int metric_id);
 
 // query the type of the metric. return (enum metric_type)-1 if metric_id is invalid.
-enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int metric_id);
+enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int cube_id, int metric_id);
 
 /*
     get the cell_dimensions added to cube when calling fieldstat_counter_incrby, fieldstat_counter_set, fieldstat_hll_add, fieldstat_hist_record.
diff --git a/src/cube.c b/src/cube.c
index a01b775..71e2acd 100644
--- a/src/cube.c
+++ b/src/cube.c
@@ -3,6 +3,7 @@
 #include <stdlib.h>
 #include <assert.h>
 #include <string.h>
+#include <stdarg.h>
 
 #include "uthash.h"
 #define XXH_INLINE_ALL
@@ -46,7 +47,8 @@ struct cube {
         struct spread_sketch *spread_sketch;
     };
     size_t max_n_cell;
-
+    struct metric_manifest_manager *manifest_manager;
+    
     struct field *cube_dimensions;
     size_t n_dimensions;
 
@@ -95,20 +97,20 @@ static void fieldstat_free_tag_array(struct field *fields, size_t n_tags)
     free(fields);
 }
 
-void add_cube_to_position(struct cube_manager *instance, struct cube *cube, int id)
+void add_cube_to_position(struct cube_manager *pthis, struct cube *cube, int id)
 {
-    if (id >= instance->cube_size) {
-        struct cube **old_cube_arr = instance->cube;
-        instance->cube = calloc(instance->cube_size * 2, sizeof(struct cube *));
-        memcpy(instance->cube, old_cube_arr, sizeof(struct cube *) * instance->cube_size);
+    if (id >= pthis->cube_size) {
+        struct cube **old_cube_arr = pthis->cube;
+        pthis->cube = calloc(pthis->cube_size * 2, sizeof(struct cube *));
+        memcpy(pthis->cube, old_cube_arr, sizeof(struct cube *) * pthis->cube_size);
         free(old_cube_arr);
 
-        instance->cube_size *= 2;
+        pthis->cube_size *= 2;
     }
-    instance->cube[id] = cube;
+    pthis->cube[id] = cube;
 
-    if (id >= instance->cube_cnt) {
-        instance->cube_cnt = id + 1;
+    if (id >= pthis->cube_cnt) {
+        pthis->cube_cnt = id + 1;
     }
 }
 
@@ -356,12 +358,15 @@ void cube_manager_calibrate(struct cube_manager *pthis, const struct cube_manage
 {
     struct cube *node_in_master, *node_in_dest, *tmp;
 
-    // exist in self but not in master
+    
     HASH_ITER(hh, pthis->hash_table, node_in_dest, tmp) {
         HASH_FIND(hh, master->hash_table, node_in_dest->key, node_in_dest->key_len, node_in_master);
 
-        if (node_in_master == NULL) {
+        if (node_in_master == NULL) { // exist in self but not in master
             cube_manager_delete(pthis, node_in_dest);
+        } else {
+            metric_manifest_manager_free(node_in_dest->manifest_manager);
+            node_in_dest->manifest_manager = metric_manifest_manager_copy(node_in_master->manifest_manager);
         }
     }
 
@@ -373,6 +378,14 @@ void cube_manager_calibrate(struct cube_manager *pthis, const struct cube_manage
             cube_manager_add(pthis, cube_fork(node_in_master));
         }
     }
+
+    // for (int i = 0; i < pthis->cube_cnt; i++) {
+    //     if (pthis->cube[i] == NULL) {
+    //         continue;
+    //     }
+    //     metric_manifest_manager_free(pthis->cube[i]->manifest_manager);
+    //     pthis->cube[i]->manifest_manager = metric_manifest_manager_copy(master->cube[i]->manifest_manager);
+    // }
 }
 
 struct cube_manager *cube_manager_fork(const struct cube_manager *src)
@@ -386,10 +399,11 @@ struct cube_manager *cube_manager_fork(const struct cube_manager *src)
     return pthis;
 }
 
-void cube_manager_merge(struct cube_manager *dest, const struct cube_manager *src)
+int cube_manager_merge(struct cube_manager *dest, const struct cube_manager *src)
 {
     struct cube *node = NULL;
     struct cube *tmp = NULL;
+    int ret = FS_OK;
     HASH_ITER(hh, src->hash_table, node, tmp) {
         struct cube *node_in_dest = NULL;
         HASH_FIND(hh, dest->hash_table, node->key, node->key_len, node_in_dest);
@@ -397,9 +411,14 @@ void cube_manager_merge(struct cube_manager *dest, const struct cube_manager *sr
         if (node_in_dest == NULL) {
             cube_manager_add(dest, cube_copy(node));
         } else {
-            cube_merge(node_in_dest, node);
+            int tmp_ret = cube_merge(node_in_dest, node);
+            if (tmp_ret != FS_OK) {
+                ret = tmp_ret;
+            }
         }
     }
+
+    return ret;
 }
 
 void cube_manager_reset(struct cube_manager *pthis)
@@ -561,6 +580,7 @@ struct cube *cube_info_new(const struct field *dimensions, size_t n_dimensions,
 struct cube *cube_new(const struct field *dimensions, size_t n_dimensions, enum sampling_mode mode, size_t max_n_cell)
 {
     struct cube *cube = cube_info_new(dimensions, n_dimensions, mode, max_n_cell);
+    cube->manifest_manager = metric_manifest_manager_new();
 
     switch (mode)
     {
@@ -603,6 +623,7 @@ void cube_free(struct cube *cube) {
 
     fieldstat_free_tag_array(cube->cube_dimensions, cube->n_dimensions);
     free(cube->key);
+    metric_manifest_manager_free(cube->manifest_manager);
 
     free(cube);
 }
@@ -630,8 +651,18 @@ void cube_reset(struct cube *cube) {
     }
 }
 
-void cube_set_primary_metric(struct cube *cube, int metric_id) {
+int cube_set_primary_metric(struct cube *cube, int metric_id) {
+    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (manifest == NULL) {
+        return FS_ERR_INVALID_METRIC_ID;
+    }
+    if (cube->sampling_mode == SAMPLING_MODE_COMPREHENSIVE ||
+        (cube->sampling_mode == SAMPLING_MODE_TOPK && manifest->type != METRIC_TYPE_COUNTER) ||
+        (cube->sampling_mode == SAMPLING_MODE_SPREADSKETCH && manifest->type != METRIC_TYPE_HLL)) {
+        return FS_ERR_INVALID_PARAM;
+    }
     cube->primary_metric_id = metric_id;
+    return FS_OK;
 }
 
 struct cell *get_cell_in_comprehensive_cube(struct cube *cube, const struct field *dimensions, size_t n_dimension) {
@@ -754,10 +785,106 @@ struct cell *get_cell_in_spread_sketch_cube(struct cube *cube, const struct fiel
     return cell_data;
 }
 
+union metric_parameter *construct_parameters(enum metric_type type, ...)
+{
+    union metric_parameter *paras = (union metric_parameter *)malloc(sizeof(union metric_parameter));
+    va_list ap;
+    va_start(ap, type);
+    switch (type) {
+        case METRIC_TYPE_COUNTER:
+            break;
+        case METRIC_TYPE_HLL:
+            paras->hll.precision = (char)va_arg(ap, int);
+            break;
+        case METRIC_TYPE_HISTOGRAM:
+            paras->hdr.lowest_trackable_value = va_arg(ap, long long);
+            paras->hdr.highest_trackable_value = va_arg(ap, long long);
+            paras->hdr.significant_figures = va_arg(ap, int);
+            break;
+        default:
+            assert(0);
+    }
+    va_end(ap);
+    return paras;
+}
+
+int cube_register_counter(struct cube *cube, const char *metric_name) {
+    struct metric_manifest *metric = malloc(sizeof(struct metric_manifest));
+    metric->name = strdup(metric_name);
+    metric->parameters = construct_parameters(METRIC_TYPE_COUNTER);
+    metric->type = METRIC_TYPE_COUNTER;
+
+    int id = metric_manifest_manager_add(cube->manifest_manager, metric);
+    if (id < 0) {
+        free(metric->name);
+        free(metric->parameters);
+        free(metric);
+        return FS_ERR_INVALID_KEY;
+    }
 
-int cube_histogram_record(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, long long value) {
-    assert(manifest->type == METRIC_TYPE_HISTOGRAM);
-    assert(cube->sampling_mode == SAMPLING_MODE_COMPREHENSIVE || (cube->primary_metric_id != manifest->id));
+    metric->id = id;
+    return id;
+}
+
+int cube_register_hll(struct cube *cube,const char *metric_name, unsigned char precision) {
+    if (precision < 4 || precision > 18) {
+        return FS_ERR_INVALID_PARAM;
+    }
+
+    struct metric_manifest *metric = malloc(sizeof(struct metric_manifest));
+    metric->name = strdup(metric_name);
+    metric->parameters = construct_parameters(METRIC_TYPE_HLL, precision);
+    metric->type = METRIC_TYPE_HLL;
+
+    int id = metric_manifest_manager_add(cube->manifest_manager, metric);
+    if (id < 0) {
+        free(metric->name);
+        free(metric->parameters);
+        free(metric);
+        return FS_ERR_INVALID_KEY;
+    }
+
+    metric->id = id;
+    return id;
+}
+
+int cube_register_hist(struct cube *cube,const char *metric_name, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures) {
+    // refer to hdr_histogram.h for the rules of parameters. Just copy them here
+    if (lowest_trackable_value < 1) {
+        return FS_ERR_INVALID_PARAM;
+    }
+    if (significant_figures < 1 || significant_figures > 5) {
+        return FS_ERR_INVALID_PARAM;
+    }
+    if (lowest_trackable_value * 2 > highest_trackable_value)
+	{
+		return FS_ERR_INVALID_PARAM;
+	}
+
+    struct metric_manifest *metric = malloc(sizeof(struct metric_manifest));
+    metric->name = strdup(metric_name);
+    metric->parameters = construct_parameters(METRIC_TYPE_HISTOGRAM, lowest_trackable_value, highest_trackable_value, significant_figures);
+    metric->type = METRIC_TYPE_HISTOGRAM;
+
+    int id = metric_manifest_manager_add(cube->manifest_manager, metric);
+    if (id < 0) {
+        free(metric->name);
+        free(metric->parameters);
+        free(metric);
+        return FS_ERR_INVALID_KEY;
+    }
+    metric->id = id;
+
+    return id;
+}
+
+int cube_histogram_record(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value) {
+    assert(cube->sampling_mode == SAMPLING_MODE_COMPREHENSIVE || (cube->primary_metric_id != metric_id));
+
+    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (manifest == NULL || manifest->type != METRIC_TYPE_HISTOGRAM) {
+        return FS_ERR_INVALID_METRIC_ID;
+    }
 
     struct cell *cell_data = NULL;
     switch (cube->sampling_mode)  {
@@ -765,10 +892,10 @@ int cube_histogram_record(struct cube *cube, const struct metric_manifest *manif
         cell_data = get_cell_in_comprehensive_cube(cube, dimensions, n_dimensions);
         break;}
     case SAMPLING_MODE_TOPK: {
-        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, manifest->id);
+        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, metric_id);
         break;}
     case SAMPLING_MODE_SPREADSKETCH: {
-        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, 0, manifest->id);
+        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, 0, metric_id);
         break;}
     default:
         assert(0);
@@ -787,12 +914,16 @@ int cube_histogram_record(struct cube *cube, const struct metric_manifest *manif
     return FS_OK;
 }
 
-int cube_hll_add(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, const char *key, size_t key_len) {
-    assert(manifest->type == METRIC_TYPE_HLL);
-    assert(cube->sampling_mode != SAMPLING_MODE_TOPK || cube->primary_metric_id != manifest->id);
+int cube_hll_add(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const char *key, size_t key_len) {
+    assert(cube->sampling_mode != SAMPLING_MODE_TOPK || cube->primary_metric_id != metric_id);
+
+    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (manifest == NULL || manifest->type != METRIC_TYPE_HLL) {
+        return FS_ERR_INVALID_METRIC_ID;
+    }
 
     uint64_t hash = 0; // just any value, if we do not need to update the primary metric of spread sketch cube, hash value is not used
-    if (cube->sampling_mode == SAMPLING_MODE_SPREADSKETCH && cube->primary_metric_id == manifest->id) {
+    if (cube->sampling_mode == SAMPLING_MODE_SPREADSKETCH && cube->primary_metric_id == metric_id) {
         hash = XXH3_64bits(key, key_len);
     }
     struct cell *cell_data = NULL;
@@ -801,10 +932,10 @@ int cube_hll_add(struct cube *cube, const struct metric_manifest *manifest, cons
         cell_data = get_cell_in_comprehensive_cube(cube, dimensions, n_dimensions);
         break;}
     case SAMPLING_MODE_TOPK: {
-        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, manifest->id);
+        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, metric_id);
         break;}
     case SAMPLING_MODE_SPREADSKETCH: {
-        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, hash, manifest->id);
+        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, hash, metric_id);
         break;}
     default:
         assert(0);
@@ -835,13 +966,16 @@ uint64_t field_array_to_hash(const struct field *field, size_t n_dimensions) {
     return XXH3_64bits_digest(&state);
 }
 
-int cube_hll_add_field(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, const struct field *tags_key, size_t n_tag_key) 
+int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const struct field *tags_key, size_t n_tag_key) 
 {
-    assert(manifest->type == METRIC_TYPE_HLL);
-    assert(cube->sampling_mode != SAMPLING_MODE_TOPK || (cube->primary_metric_id != manifest->id));
+    assert(cube->sampling_mode != SAMPLING_MODE_TOPK || (cube->primary_metric_id != metric_id));
+    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (manifest == NULL || manifest->type != METRIC_TYPE_HLL) {
+        return FS_ERR_INVALID_METRIC_ID;
+    }
 
     uint64_t hash = 0; // just any value, if we do not need to update the primary metric of spread sketch cube, hash value is not used
-    if (cube->sampling_mode == SAMPLING_MODE_SPREADSKETCH && cube->primary_metric_id == manifest->id) {
+    if (cube->sampling_mode == SAMPLING_MODE_SPREADSKETCH && cube->primary_metric_id == metric_id) {
         hash = field_array_to_hash(tags_key, n_tag_key);
     }
     struct cell *cell_data = NULL;
@@ -850,10 +984,10 @@ int cube_hll_add_field(struct cube *cube, const struct metric_manifest *manifest
         cell_data = get_cell_in_comprehensive_cube(cube, dimensions, n_dimensions);
         break;}
     case SAMPLING_MODE_TOPK: {
-        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, manifest->id);
+        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, metric_id);
         break;}
     case SAMPLING_MODE_SPREADSKETCH: {
-        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, hash, manifest->id);
+        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, hash, metric_id);
         break;}
     default:
         assert(0);
@@ -871,23 +1005,27 @@ int cube_hll_add_field(struct cube *cube, const struct metric_manifest *manifest
     return FS_OK;
 }
 
-int cube_counter_incrby(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, long long increment) {
-    assert(manifest->type == METRIC_TYPE_COUNTER);
+int cube_counter_incrby(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long increment) {
     assert(cube->sampling_mode == SAMPLING_MODE_COMPREHENSIVE || 
-          (cube->sampling_mode == SAMPLING_MODE_TOPK && (cube->primary_metric_id != manifest->id || increment >= 0)) ||
-          (cube->sampling_mode == SAMPLING_MODE_SPREADSKETCH && cube->primary_metric_id != manifest->id)
+          (cube->sampling_mode == SAMPLING_MODE_TOPK && (cube->primary_metric_id != metric_id || increment >= 0)) ||
+          (cube->sampling_mode == SAMPLING_MODE_SPREADSKETCH && cube->primary_metric_id != metric_id)
           );
 
+    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (manifest == NULL || manifest->type != METRIC_TYPE_COUNTER) {
+        return FS_ERR_INVALID_METRIC_ID;
+    }
+    
     struct cell *cell_data = NULL;
     switch (cube->sampling_mode)  {
     case SAMPLING_MODE_COMPREHENSIVE: {
         cell_data = get_cell_in_comprehensive_cube(cube, dimensions, n_dimensions);
         break;}
     case SAMPLING_MODE_TOPK: {
-        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, increment, manifest->id);
+        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, increment, metric_id);
         break;}
     case SAMPLING_MODE_SPREADSKETCH: {
-        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, 0, manifest->id);
+        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, 0, metric_id);
         break;}
     default:
         assert(0);
@@ -904,9 +1042,13 @@ int cube_counter_incrby(struct cube *cube, const struct metric_manifest *manifes
     return FS_OK;
 }
 
-int cube_counter_set(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, long long value) {
-    assert(manifest->type == METRIC_TYPE_COUNTER);
-    assert(cube->sampling_mode == SAMPLING_MODE_COMPREHENSIVE || (cube->primary_metric_id != manifest->id));
+int cube_counter_set(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value) {
+    assert(cube->sampling_mode == SAMPLING_MODE_COMPREHENSIVE || (cube->primary_metric_id != metric_id));
+
+    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (manifest == NULL || manifest->type != METRIC_TYPE_COUNTER) {
+        return FS_ERR_INVALID_METRIC_ID;
+    }
 
     struct cell *cell_data = NULL;
     switch (cube->sampling_mode)  {
@@ -914,10 +1056,10 @@ int cube_counter_set(struct cube *cube, const struct metric_manifest *manifest,
         cell_data = get_cell_in_comprehensive_cube(cube, dimensions, n_dimensions);
         break;}
     case SAMPLING_MODE_TOPK: {
-        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, manifest->id);
+        cell_data = get_cell_in_topk_cube(cube, dimensions, n_dimensions, 0, metric_id);
         break;}
     case SAMPLING_MODE_SPREADSKETCH: {
-        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, 0, manifest->id);
+        cell_data = get_cell_in_spread_sketch_cube(cube, dimensions, n_dimensions, 0, metric_id);
         break;}
     default:
         assert(0);
@@ -953,12 +1095,33 @@ struct cube *cube_copy(const struct cube *cube)
         break;
     }
 
+    cube_dup->manifest_manager = metric_manifest_manager_copy(cube->manifest_manager);
+
     return cube_dup;
 }
 
-void cube_merge(struct cube *dest, const struct cube *src)
+int cube_merge(struct cube *dest, const struct cube *src)
 {
-    assert(dest->sampling_mode == src->sampling_mode);
+    if (dest->sampling_mode != src->sampling_mode) {
+        return FS_ERR_INVALID_PARAM;
+    }
+
+    size_t n_metric_src = 0;
+    const struct metric_manifest **list_src = metric_manifest_manager_list(src->manifest_manager, &n_metric_src);
+    size_t n_metric_dst = 0;
+    const struct metric_manifest **list_dst = metric_manifest_manager_list(dest->manifest_manager, &n_metric_dst);
+    int len_min = n_metric_src < n_metric_dst ? n_metric_src : n_metric_dst;
+    for (int i = 0; i < len_min; i++) {
+        if (list_src[i]->type != list_dst[i]->type) {
+            return FS_ERR_INVALID_PARAM;
+        }
+        if (strcmp(list_src[i]->name, list_dst[i]->name) != 0) {
+            return FS_ERR_INVALID_PARAM;
+        }
+    }
+    for (int i = n_metric_dst; i < n_metric_src; i++) {
+        metric_manifest_manager_add(dest->manifest_manager, metric_manifest_copy(list_src[i]));
+    }
 
     switch (dest->sampling_mode)
     {
@@ -975,15 +1138,39 @@ void cube_merge(struct cube *dest, const struct cube *src)
         assert(0);
         break;
     }
+
+    return FS_OK;
 }
 
 struct cube *cube_fork(const struct cube *cube) {
-    struct cube *ret = cube_new(cube->cube_dimensions, cube->n_dimensions, cube->sampling_mode, cube->max_n_cell);
+    struct cube *ret = cube_info_new(cube->cube_dimensions, cube->n_dimensions, cube->sampling_mode, cube->max_n_cell);
     ret->primary_metric_id = cube->primary_metric_id;
+    ret->manifest_manager = metric_manifest_manager_copy(cube->manifest_manager);
 
+    switch (cube->sampling_mode) {
+        case SAMPLING_MODE_TOPK:
+            ret->topk = heavy_keeper_new(cube->max_n_cell);
+            heavy_keeper_set_exdata_schema(ret->topk, exdata_new_i, exdata_free_i, exdata_merge_i, exdata_reset_i, exdata_copy_i);
+            break;
+        case SAMPLING_MODE_COMPREHENSIVE:
+            ret->comprehensive = hash_table_new(cube->max_n_cell);
+            hash_table_set_exdata_schema(ret->comprehensive, exdata_new_i, exdata_free_i, exdata_merge_i, exdata_reset_i, exdata_copy_i);
+            break;
+        case SAMPLING_MODE_SPREADSKETCH:
+            ret->spread_sketch = spread_sketch_new(cube->max_n_cell);
+            spread_sketch_set_exdata_schema(ret->spread_sketch, exdata_new_i, exdata_free_i, exdata_merge_i, exdata_reset_i, exdata_copy_i);
+            break;
+        default:
+            assert(0);
+            break;
+    }
     return ret;
 }
 
+/* -------------------------------------------------------------------------- */
+/*                                    query                                   */
+/* -------------------------------------------------------------------------- */
+
 struct tmp_sorted_data_spread_sketch_cell {
     double hll_value;
     struct cell *data;
@@ -1236,6 +1423,37 @@ struct field_list *cube_get_identifier(const struct cube *cube) {
     return tag_list;
 }
 
-enum sampling_mode cube_get_sampling_mode(const struct cube *cube) {
-    return cube->sampling_mode;
+const char *cube_get_metric_name(const struct cube *cube, int metric_id) {
+    const struct metric_manifest *metric = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (metric == NULL) {
+        printf("metric is null\n");
+        return NULL;
+    }
+
+    return metric->name;
+}
+
+enum metric_type cube_get_metric_type(const struct cube *cube, int metric_id) {
+    const struct metric_manifest *metric = metric_manifest_manager_get_by_id(cube->manifest_manager, metric_id);
+    if (metric == NULL) {
+        return (enum metric_type)(-1);
+    }
+
+    return metric->type;
+}
+
+void cube_get_metrics(const struct cube *cube, int **metric_id_out, size_t *n_metric)
+{
+    const struct metric_manifest **list = metric_manifest_manager_list(cube->manifest_manager, n_metric);
+    if (*n_metric == 0) {
+        *metric_id_out = NULL;
+        return;
+    }
+
+    int *tmp_ids = (int *)malloc(sizeof(int) * (*n_metric));
+    *metric_id_out = tmp_ids;
+
+    for (int i = 0; i < *n_metric; i++) {
+        tmp_ids[i] = list[i]->id;
+    }
 }
diff --git a/src/cube.h b/src/cube.h
index 6802b2d..8b6db1c 100644
--- a/src/cube.h
+++ b/src/cube.h
@@ -17,15 +17,20 @@ struct cube *cube_new(const struct field *dimensions, size_t n_dimensions, enum
 void cube_free(struct cube *cube);
 void cube_reset(struct cube *cube);
 struct cube *cube_copy(const struct cube *cube);
-void cube_merge(struct cube *dest, const struct cube *src);
+int cube_merge(struct cube *dest, const struct cube *src);
 struct cube *cube_fork(const struct cube *cube); // only copy the cube configurations, leave the cells empty
 
-int cube_histogram_record(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, long long value);
-int cube_hll_add(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, const char *key, size_t key_len);
-int cube_hll_add_field(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, const struct field *tags_key, size_t n_tag_key);
-int cube_counter_incrby(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, long long increment);
-int cube_counter_set(struct cube *cube, const struct metric_manifest *manifest, const struct field *dimensions, size_t n_dimensions, long long value);
+int cube_register_counter(struct cube *cube, const char *metric_name);
+int cube_register_hll(struct cube *cube,const char *metric_name, unsigned char precision);
+int cube_register_hist(struct cube *cube,const char *metric_name, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures);
 
+int cube_histogram_record(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value);
+int cube_hll_add(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const char *key, size_t key_len);
+int cube_hll_add_field(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, const struct field *tags_key, size_t n_tag_key);
+int cube_counter_incrby(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long increment);
+int cube_counter_set(struct cube *cube, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value);
+
+/* ---------------------------------- query --------------------------------- */
 int cube_counter_get(const struct cube *cube, int metric_id, const struct field_list *dimensions, long long *value);
 int cube_hll_get(const struct cube *cube, int metric_id, const struct field_list *dimensions, double *value);
 int cube_histogram_value_at_percentile(const struct cube *cube, int metric_id, const struct field_list *dimensions, double percentile, long long *value);
@@ -35,10 +40,16 @@ int cube_get_serialization(const struct cube *cube, int metric_id, const struct
 int cube_get_cell_count(const struct cube *cube);
 enum sampling_mode cube_get_sampling_mode(const struct cube *cube);
 void cube_get_cells(const struct cube *cube, struct field_list **tag_list, size_t *n_cell);
+void cube_get_metrics(const struct cube *cube, int **metric_id_out, size_t *n_metric);
 void cube_get_metrics_in_cell(const struct cube *cube, const struct field_list *dimensions, int **metric_id_out, size_t *n_metric_out);
-void cube_set_primary_metric(struct cube *cube, int metric_id);
+int cube_set_primary_metric(struct cube *cube, int metric_id);
 struct field_list *cube_get_identifier(const struct cube *cube);
+const char *cube_get_metric_name(const struct cube *cube, int metric_id);
+enum metric_type cube_get_metric_type(const struct cube *cube, int metric_id);
 
+/* -------------------------------------------------------------------------- */
+/*                                cube manager                                */
+/* -------------------------------------------------------------------------- */
 struct cube *cube_manager_get_cube_by_id(const struct cube_manager *manager, int cube_id);
 
 // the cube will be taken over by the manager, user do not free it.
@@ -47,7 +58,7 @@ void cube_manager_delete(struct cube_manager *pthis, struct cube *cube); // the
 int cube_manager_find(const struct cube_manager *pthis, const struct field *cube_dimensions, size_t n_dimensions);
 struct cube_manager *cube_manager_new();
 void cube_manager_free(struct cube_manager *pthis);
-void cube_manager_merge(struct cube_manager *dest, const struct cube_manager *src);
+int cube_manager_merge(struct cube_manager *dest, const struct cube_manager *src);
 
 void cube_manager_reset(struct cube_manager *pthis);
 void cube_manager_calibrate(struct cube_manager *pthis, const struct cube_manager *master);
diff --git a/src/exporter/cjson_exporter.c b/src/exporter/cjson_exporter.c
index 9466f01..3fecf40 100644
--- a/src/exporter/cjson_exporter.c
+++ b/src/exporter/cjson_exporter.c
@@ -524,16 +524,17 @@ int cell_iter_next(struct cell_iter *iter) {
 /* -------------------------------------------------------------------------- */
 
 struct export_kv_pair *cell_query_with_iter(const struct cell_iter *iter, int metric_id) {
-    enum metric_type type = fieldstat_get_metric_type(iter->instance, metric_id);
+    int cube_id = iter->cube_ids[iter->curr_cube_idx];
+    enum metric_type type = fieldstat_get_metric_type(iter->instance, cube_id, metric_id);
     struct export_kv_pair *ret = NULL;
     if (type == METRIC_TYPE_COUNTER) {
         long long value;
-        int tmp_ret = fieldstat_counter_get(iter->instance, iter->cube_ids[iter->curr_cube_idx], &iter->tag_list[iter->curr_cell_idx], metric_id, &value);
+        int tmp_ret = fieldstat_counter_get(iter->instance, cube_id, &iter->tag_list[iter->curr_cell_idx], metric_id, &value);
         if (tmp_ret < 0) {
             return NULL;
         }
         ret = malloc(sizeof(struct export_kv_pair));
-        ret->key = strdup(fieldstat_get_metric_name(iter->instance, metric_id));
+        ret->key = strdup(fieldstat_get_metric_name(iter->instance, cube_id, metric_id));
         ret->type = TAG_INTEGER;
         ret->value_longlong = value;
         return ret;
@@ -541,12 +542,12 @@ struct export_kv_pair *cell_query_with_iter(const struct cell_iter *iter, int me
     if (type == METRIC_TYPE_HLL || type == METRIC_TYPE_HISTOGRAM) {
         char *value;
         size_t len;
-        fieldstat_get_serialized_blob(iter->instance, iter->cube_ids[iter->curr_cube_idx], metric_id, &iter->tag_list[iter->curr_cell_idx], &value, &len);
+        fieldstat_get_serialized_blob(iter->instance, cube_id, metric_id, &iter->tag_list[iter->curr_cell_idx], &value, &len);
         if (value == NULL) {
             return NULL;
         }
         ret = malloc(sizeof(struct export_kv_pair));
-        ret->key = strdup(fieldstat_get_metric_name(iter->instance, metric_id));
+        ret->key = strdup(fieldstat_get_metric_name(iter->instance, cube_id, metric_id));
         ret->type = TAG_CSTRING;
         ret->value_str = value;
         return ret;
diff --git a/src/fieldstat.c b/src/fieldstat.c
index b847bd5..0e2fb81 100644
--- a/src/fieldstat.c
+++ b/src/fieldstat.c
@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
-#include <stdarg.h>
 
 #include "cjson/cJSON.h"
 #include "uthash.h"
@@ -11,92 +10,11 @@
 #include "fieldstat.h"
 #include "metrics/metric.h"
 #include "cube.h"
-#include "metric_manifest.h"
-
 
 struct fieldstat {
-    struct metric_manifest_manager *manifest_manager;
-
     struct cube_manager *cube_manager;
 };
 
-union metric_parameter *construct_parameters(enum metric_type type, ...)
-{
-    union metric_parameter *paras = (union metric_parameter *)malloc(sizeof(union metric_parameter));
-    va_list ap;
-    va_start(ap, type);
-    switch (type) {
-        case METRIC_TYPE_COUNTER:
-            break;
-        case METRIC_TYPE_HLL:
-            paras->hll.precision = (char)va_arg(ap, int);
-            break;
-        case METRIC_TYPE_HISTOGRAM:
-            paras->hdr.lowest_trackable_value = va_arg(ap, long long);
-            paras->hdr.highest_trackable_value = va_arg(ap, long long);
-            paras->hdr.significant_figures = va_arg(ap, int);
-            break;
-        default:
-            assert(0);
-    }
-    va_end(ap);
-    return paras;
-}
-
-void tag_array_copy(struct field *tags_dst, const struct field *tags_src, size_t n_field)
-{
-    for (size_t i = 0; i < n_field; i++) {
-        tags_dst[i].key = strdup(tags_src[i].key);
-        tags_dst[i].type = tags_src[i].type;
-        switch (tags_src[i].type)
-        {
-        case TAG_INTEGER:
-            tags_dst[i].value_longlong = tags_src[i].value_longlong;
-            break;
-        case TAG_CSTRING:
-            tags_dst[i].value_str = strdup(tags_src[i].value_str);
-            break;
-        case TAG_DOUBLE:
-            tags_dst[i].value_double = tags_src[i].value_double;
-            break;
-        default:
-            break;
-        }
-    }
-}
-
-bool is_tag_array_same(const struct field *tags1, const struct field *tags2, size_t n_field)
-{
-    for (size_t i = 0; i < n_field; i++) {
-        if (tags1[i].type != tags2[i].type) {
-            return false;
-        }
-        if (strcmp(tags1[i].key, tags2[i].key) != 0) {
-            return false;
-        }
-        switch (tags1[i].type)
-        {
-        case TAG_INTEGER:
-            if (tags1[i].value_longlong != tags2[i].value_longlong) {
-                return false;
-            }
-            break;
-        case TAG_CSTRING:
-            if (strcmp(tags1[i].value_str, tags2[i].value_str) != 0) {
-                return false;
-            }
-            break;
-        case TAG_DOUBLE:
-            if (tags1[i].value_double != tags2[i].value_double) {
-                return false;
-            }
-            break;
-        default:
-            break;
-        }
-    }
-    return 0;
-}
 
 /* -------------------------------------------------------------------------- */
 /*                                  fieldstat                                 */
@@ -106,8 +24,6 @@ struct fieldstat *fieldstat_new()
 {
     struct fieldstat *instance = calloc(1, sizeof(struct fieldstat));
 
-    instance->manifest_manager = metric_manifest_manager_new();
-
     instance->cube_manager = cube_manager_new();
 
     return instance;
@@ -121,8 +37,6 @@ void fieldstat_free(struct fieldstat *instance)
 
     cube_manager_free(instance->cube_manager);
 
-    metric_manifest_manager_free(instance->manifest_manager);
-
     free(instance);
 }
 
@@ -200,96 +114,41 @@ int fieldstat_cube_set_primary_metric(struct fieldstat *instance, int cube_id, i
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
-    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (manifest == NULL) {
-        return FS_ERR_INVALID_METRIC_ID;
-    }
-    if (cube_get_sampling_mode(cube) == SAMPLING_MODE_COMPREHENSIVE ||
-        (cube_get_sampling_mode(cube) == SAMPLING_MODE_TOPK && manifest->type != METRIC_TYPE_COUNTER) ||
-        (cube_get_sampling_mode(cube) == SAMPLING_MODE_SPREADSKETCH && manifest->type != METRIC_TYPE_HLL)) {
-        return FS_ERR_INVALID_PARAM;
-    }
-
-    cube_set_primary_metric(cube, metric_id);
-
-    return FS_OK;
+    
+    return cube_set_primary_metric(cube, metric_id);
 }
 
 /* -------------------------------------------------------------------------- */
 /*                               metric register                              */
 /* -------------------------------------------------------------------------- */
-int fieldstat_register_counter(struct fieldstat *instance, const char *metric_name)
-{
-    struct metric_manifest *metric = malloc(sizeof(struct metric_manifest));
-    metric->name = strdup(metric_name);
-    metric->parameters = construct_parameters(METRIC_TYPE_COUNTER);
-    metric->type = METRIC_TYPE_COUNTER;
-
-    int id = metric_manifest_manager_add(instance->manifest_manager, metric);
-    if (id < 0) {
-        free(metric->name);
-        free(metric->parameters);
-        free(metric);
-        return FS_ERR_INVALID_KEY;
+// cppcheck-suppress [constParameterPointer, unmatchedSuppression]
+int fieldstat_register_counter(struct fieldstat *instance, int cube_id, const char *metric_name)
+{
+    struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
+    if (cube == NULL) {
+        return FS_ERR_INVALID_CUBE_ID;
     }
-
-    metric->id = id;
-    return id;
+    return cube_register_counter(cube, metric_name);
 }
 
-int fieldstat_register_hll(struct fieldstat *instance, const char *metric_name, unsigned char precision)
+// cppcheck-suppress [constParameterPointer, unmatchedSuppression]
+int fieldstat_register_hll(struct fieldstat *instance, int cube_id, const char *metric_name, unsigned char precision)
 {
-    if (precision < 4 || precision > 18) {
-        return FS_ERR_INVALID_PARAM;
-    }
-
-    struct metric_manifest *metric = malloc(sizeof(struct metric_manifest));
-    metric->name = strdup(metric_name);
-    metric->parameters = construct_parameters(METRIC_TYPE_HLL, precision);
-    metric->type = METRIC_TYPE_HLL;
-
-    int id = metric_manifest_manager_add(instance->manifest_manager, metric);
-    if (id < 0) {
-        free(metric->name);
-        free(metric->parameters);
-        free(metric);
-        return FS_ERR_INVALID_KEY;
+    struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
+    if (cube == NULL) {
+        return FS_ERR_INVALID_CUBE_ID;
     }
-
-    metric->id = id;
-    return id;
+    return cube_register_hll(cube, metric_name, precision);
 }
 
-int fieldstat_register_hist(struct fieldstat *instance, const char *metric_name, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures)
+// cppcheck-suppress [constParameterPointer, unmatchedSuppression]
+int fieldstat_register_hist(struct fieldstat *instance, int cube_id, const char *metric_name, long long lowest_trackable_value, long long highest_trackable_value, int significant_figures)
 {
-    // refer to hdr_histogram.h for the rules of parameters. Just copy them here
-    if (lowest_trackable_value < 1) {
-        return FS_ERR_INVALID_PARAM;
-    }
-    if (significant_figures < 1 || significant_figures > 5) {
-        return FS_ERR_INVALID_PARAM;
-    }
-    if (lowest_trackable_value * 2 > highest_trackable_value)
-	{
-		return FS_ERR_INVALID_PARAM;
-	}
-
-
-    struct metric_manifest *metric = malloc(sizeof(struct metric_manifest));
-    metric->name = strdup(metric_name);
-    metric->parameters = construct_parameters(METRIC_TYPE_HISTOGRAM, lowest_trackable_value, highest_trackable_value, significant_figures);
-    metric->type = METRIC_TYPE_HISTOGRAM;
-
-    int id = metric_manifest_manager_add(instance->manifest_manager, metric);
-    if (id < 0) {
-        free(metric->name);
-        free(metric->parameters);
-        free(metric);
-        return FS_ERR_INVALID_KEY;
+    struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
+    if (cube == NULL) {
+        return FS_ERR_INVALID_CUBE_ID;
     }
-    metric->id = id;
-
-    return id;
+    return cube_register_hist(cube, metric_name, lowest_trackable_value, highest_trackable_value, significant_figures);
 }
 
 /* -------------------------------------------------------------------------- */
@@ -303,12 +162,8 @@ int fieldstat_counter_incrby(struct fieldstat *instance, int cube_id, int metric
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
-    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (manifest == NULL || manifest->type != METRIC_TYPE_COUNTER) {
-        return FS_ERR_INVALID_METRIC_ID;
-    }
-    
-    return cube_counter_incrby(cube, manifest, cell_dimensions, n_dimensions, increment);
+
+    return cube_counter_incrby(cube, metric_id, cell_dimensions, n_dimensions, increment);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
@@ -318,12 +173,8 @@ int fieldstat_counter_set(struct fieldstat *instance, int cube_id, int metric_id
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
-    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (manifest == NULL || manifest->type != METRIC_TYPE_COUNTER) {
-        return FS_ERR_INVALID_METRIC_ID;
-    }
 
-    return cube_counter_set(cube, manifest, cell_dimensions, n_dimensions, value);
+    return cube_counter_set(cube, metric_id, cell_dimensions, n_dimensions, value);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
@@ -333,12 +184,8 @@ int fieldstat_hll_add(struct fieldstat *instance, int cube_id, int metric_id, co
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
-    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (manifest == NULL || manifest->type != METRIC_TYPE_HLL) {
-        return FS_ERR_INVALID_METRIC_ID;
-    }
 
-    return cube_hll_add(cube, manifest, cell_dimensions, n_dimensions, key, key_len);
+    return cube_hll_add(cube, metric_id, cell_dimensions, n_dimensions, key, key_len);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
@@ -348,12 +195,8 @@ int fieldstat_hll_add_field(struct fieldstat *instance, int cube_id, int metric_
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
-    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (manifest == NULL || manifest->type != METRIC_TYPE_HLL) {
-        return FS_ERR_INVALID_METRIC_ID;
-    }
 
-    return cube_hll_add_field(cube, manifest, cell_dimensions, n_dimensions, item, item_len);
+    return cube_hll_add_field(cube, metric_id, cell_dimensions, n_dimensions, item, item_len);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
@@ -363,12 +206,8 @@ int fieldstat_hist_record(struct fieldstat *instance, int cube_id, int metric_id
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
-    const struct metric_manifest *manifest = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (manifest == NULL || manifest->type != METRIC_TYPE_HISTOGRAM) {
-        return FS_ERR_INVALID_METRIC_ID;
-    }
 
-    return cube_histogram_record(cube, manifest, cell_dimensions, n_dimensions, value);
+    return cube_histogram_record(cube, metric_id, cell_dimensions, n_dimensions, value);
 }
 
 int fieldstat_merge(struct fieldstat *instance, const struct fieldstat *src)
@@ -377,27 +216,7 @@ int fieldstat_merge(struct fieldstat *instance, const struct fieldstat *src)
         return FS_ERR_NULL_HANDLER;
     }
 
-    size_t n_metric_src = 0;
-    const struct metric_manifest **list_src = metric_manifest_manager_list(src->manifest_manager, &n_metric_src);
-    size_t n_metric_dst = 0;
-    const struct metric_manifest **list_dst = metric_manifest_manager_list(instance->manifest_manager, &n_metric_dst);
-    int len_min = n_metric_src < n_metric_dst ? n_metric_src : n_metric_dst;
-    for (int i = 0; i < len_min; i++) {
-        if (list_src[i]->type != list_dst[i]->type) {
-            return FS_ERR_INVALID_PARAM;
-        }
-        if (strcmp(list_src[i]->name, list_dst[i]->name) != 0) {
-            return FS_ERR_INVALID_PARAM;
-        }
-    }
-    for (int i = n_metric_dst; i < n_metric_src; i++) {
-        metric_manifest_manager_add(instance->manifest_manager, metric_manifest_copy(list_src[i]));
-    }
-
-
-    cube_manager_merge(instance->cube_manager, src->cube_manager);
-
-    return FS_OK;
+    return cube_manager_merge(instance->cube_manager, src->cube_manager);
 }
 
 struct fieldstat *fieldstat_fork(const struct fieldstat *instance)
@@ -408,16 +227,12 @@ struct fieldstat *fieldstat_fork(const struct fieldstat *instance)
     struct fieldstat *new_instance = calloc(1, sizeof(struct fieldstat));
     new_instance->cube_manager = cube_manager_fork(instance->cube_manager);
 
-    new_instance->manifest_manager = metric_manifest_manager_copy(instance->manifest_manager);
-
     return new_instance;
 }
 
 int fieldstat_calibrate(const struct fieldstat *master, struct fieldstat *replica)
 {
     cube_manager_calibrate(replica->cube_manager, master->cube_manager);
-    metric_manifest_manager_free(replica->manifest_manager);
-    replica->manifest_manager = metric_manifest_manager_copy(master->manifest_manager);
 
     return FS_OK;
 }
@@ -430,22 +245,6 @@ void fieldstat_get_cubes(const struct fieldstat *instance, int **cube_ids, int *
     cube_manager_list(instance->cube_manager, cube_ids, n_cube);
 }
 
-void fieldstat_get_metrics(const struct fieldstat *instance, int **metric_id_out, size_t *n_metric)
-{
-    const struct metric_manifest **list = metric_manifest_manager_list(instance->manifest_manager, n_metric);
-    if (*n_metric == 0) {
-        *metric_id_out = NULL;
-        return;
-    }
-
-    int *tmp_ids = (int *)malloc(sizeof(int) * (*n_metric));
-    *metric_id_out = tmp_ids;
-
-    for (int i = 0; i < *n_metric; i++) {
-        tmp_ids[i] = list[i]->id;
-    }
-}
-
 struct field_list *fieldstat_cube_get_tags(const struct fieldstat *instance, int cube_id)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
@@ -530,24 +329,23 @@ void fieldstat_tag_list_arr_free(struct field_list *tag_list, size_t n_cell)
     free(tag_list);
 }
 
-const char *fieldstat_get_metric_name(const struct fieldstat *instance, int metric_id)
+const char *fieldstat_get_metric_name(const struct fieldstat *instance, int cube_id, int metric_id)
 {
-    const struct metric_manifest *metric = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (metric == NULL) {
+    const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
+    if (cube == NULL) {
+        printf("cube is NULL\n");
         return NULL;
     }
-
-    return metric->name;
+    return cube_get_metric_name(cube, metric_id);
 }
 
-enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int metric_id)
+enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int cube_id, int metric_id)
 {
-    const struct metric_manifest *metric = metric_manifest_manager_get_by_id(instance->manifest_manager, metric_id);
-    if (metric == NULL) {
+    const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
+    if (cube == NULL) {
         return (enum metric_type)(-1);
     }
-
-    return metric->type;
+    return cube_get_metric_type(cube, metric_id);
 }
 
 void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, struct field_list **cell_dimensions, size_t *n_cell)
@@ -592,4 +390,9 @@ void fieldstat_get_metric_in_cell(const struct fieldstat *instance, int cube_id,
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     return cube_get_metrics_in_cell(cube, cell_dimensions, metric_id_out, n_metric_out);
-}
\ No newline at end of file
+}
+
+void fieldstat_cube_get_metrics(const struct fieldstat *instance, int cube_id, int **metric_id_out, size_t *n_metric) {
+    const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
+    cube_get_metrics(cube, metric_id_out, n_metric);
+}
diff --git a/src/fieldstat_easy.c b/src/fieldstat_easy.c
index b5f811c..ef1a921 100644
--- a/src/fieldstat_easy.c
+++ b/src/fieldstat_easy.c
@@ -192,17 +192,17 @@ int fieldstat_easy_register_counter(struct fieldstat_easy *fse, const char *name
         pthread_spin_lock(&fse->fsu[i].lock);
     }
 
-    int ret = fieldstat_register_counter(fse->fsu[0].active, name); // try to register
+    int ret = fieldstat_register_counter(fse->fsu[0].active, 0, name); // try to register
     if (ret < 0) {
         for (int i = 0; i < fse->max_thread_num; i++) {
             pthread_spin_unlock(&fse->fsu[i].lock);
         }
         return ret;
     }
-    fieldstat_register_counter(fse->fsu[0].read_only, name);
+    fieldstat_register_counter(fse->fsu[0].read_only, 0, name);
     for (int i = 1; i < fse->max_thread_num; i++) {
-        fieldstat_register_counter(fse->fsu[i].active, name);
-        fieldstat_register_counter(fse->fsu[i].read_only, name);
+        fieldstat_register_counter(fse->fsu[i].active, 0, name);
+        fieldstat_register_counter(fse->fsu[i].read_only, 0, name);
     }
 
     for (int i = 0; i < fse->max_thread_num; i++) {
@@ -218,17 +218,17 @@ int fieldstat_easy_register_histogram(struct fieldstat_easy *fse, const char *na
         pthread_spin_lock(&fse->fsu[i].lock);
     }
 
-    int ret = fieldstat_register_hist(fse->fsu[0].active, name, lowest_trackable_value, highest_trackable_value, significant_figures); // try to register
+    int ret = fieldstat_register_hist(fse->fsu[0].active, 0, name, lowest_trackable_value, highest_trackable_value, significant_figures); // try to register
     if (ret < 0) {
         for (int i = 0; i < fse->max_thread_num; i++) {
             pthread_spin_unlock(&fse->fsu[i].lock);
         }
         return ret;
     }
-    fieldstat_register_hist(fse->fsu[0].read_only, name, lowest_trackable_value, highest_trackable_value, significant_figures);
+    fieldstat_register_hist(fse->fsu[0].read_only, 0, name, lowest_trackable_value, highest_trackable_value, significant_figures);
     for (int i = 1; i < fse->max_thread_num; i++) {
-        fieldstat_register_hist(fse->fsu[i].active, name, lowest_trackable_value, highest_trackable_value, significant_figures);
-        fieldstat_register_hist(fse->fsu[i].read_only, name, lowest_trackable_value, highest_trackable_value, significant_figures);
+        fieldstat_register_hist(fse->fsu[i].active, 0, name, lowest_trackable_value, highest_trackable_value, significant_figures);
+        fieldstat_register_hist(fse->fsu[i].read_only, 0, name, lowest_trackable_value, highest_trackable_value, significant_figures);
     }
 
     for (int i = 0; i < fse->max_thread_num; i++) {
diff --git a/test/test_easy_fs.cpp b/test/test_easy_fs.cpp
index 8b6ef85..e723828 100644
--- a/test/test_easy_fs.cpp
+++ b/test/test_easy_fs.cpp
@@ -305,6 +305,6 @@ TEST(test_easy_fieldstat, accuracy_in_multithread)
 int main(int argc, char **argv)
 {
     ::testing::InitGoogleTest(&argc, argv);
-    testing::GTEST_FLAG(filter) = "test_easy_fieldstat.accuracy_in_multithread";
+    // testing::GTEST_FLAG(filter) = "test_easy_fieldstat.accuracy_in_multithread";
     return RUN_ALL_TESTS();
 }
\ No newline at end of file
diff --git a/test/test_empty_tags.cpp b/test/test_empty_tags.cpp
index 54e243a..1d1484a 100644
--- a/test/test_empty_tags.cpp
+++ b/test/test_empty_tags.cpp
@@ -26,7 +26,7 @@ TEST(test_empty_tag, add_many_times)
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, NULL, 0, SAMPLING_MODE_COMPREHENSIVE, 1);
 
-    int metric_id = fieldstat_register_counter(instance, "metric");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric");
     fieldstat_counter_incrby(instance, cube_id, metric_id, NULL, 0, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, NULL, 0, 1);
 
@@ -39,7 +39,7 @@ struct fieldstat *test_empty_my_init(enum sampling_mode mode = SAMPLING_MODE_COM
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, NULL, 0, mode, 1);
-    int metric_id = fieldstat_register_counter(instance, "metric");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric");
     fieldstat_counter_incrby(instance, cube_id, metric_id, NULL, 0, 1);
 
     return instance;
@@ -98,7 +98,7 @@ TEST(test_empty_tag, merge_spreadsketch)
 {
     struct fieldstat *instance_src = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance_src, NULL, 0, SAMPLING_MODE_SPREADSKETCH, 1);
-    int metric_id = fieldstat_register_hll(instance_src, "metric", 4);
+    int metric_id = fieldstat_register_hll(instance_src, cube_id, "metric", 4);
     fieldstat_hll_add(instance_src, cube_id, metric_id, NULL, 0, "1", 1);
     struct fieldstat *instance_dst = fieldstat_new();
 
diff --git a/test/test_exporter_json.cpp b/test/test_exporter_json.cpp
index 259091b..288bdac 100644
--- a/test/test_exporter_json.cpp
+++ b/test/test_exporter_json.cpp
@@ -168,8 +168,8 @@ void topk_init(struct fieldstat *instance, unsigned int test_expected_big_count)
 {
     const char *metric_name[TEST_METRIC_NUM] = {"topk1", "topk2"};
     int cube_id = fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_TOPK, TEST_TOPK_STANDARD_K);
-    int m1 = fieldstat_register_counter(instance, metric_name[0]);
-    int m2 = fieldstat_register_counter(instance, metric_name[1]);
+    int m1 = fieldstat_register_counter(instance, cube_id, metric_name[0]);
+    int m2 = fieldstat_register_counter(instance, cube_id, metric_name[1]);
 
     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]) {
@@ -187,9 +187,9 @@ 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_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, tag_list_num);
-    int id_counter = fieldstat_register_counter(instance, "counter");
-    int id_gauge = fieldstat_register_hll(instance, "gauge", g_hll_standard->cfg.precision);
-    int id_histogram = fieldstat_register_hist(instance, "histogram",
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter");
+    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);
 
     Fieldstat_tag_list_wrapper *fields[tag_list_num];
@@ -294,10 +294,10 @@ TEST(export_test, only_registered_but_not_added_export_null_with_global_tag)
 {
     struct fieldstat *instance = fieldstat_new();
 
-    fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
-    fieldstat_register_counter(instance, "counter");
-    fieldstat_register_hll(instance, "gauge", g_hll_standard->cfg.precision);
-    fieldstat_register_hist(instance, "histogram",
+    int cube_id = fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
+    fieldstat_register_counter(instance, cube_id, "counter");
+    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);
 
     // add global field
@@ -313,9 +313,9 @@ TEST(export_test, skip_two_empty_cube_and_export_last_one_with_global_tag)
     (void)fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
     (void)fieldstat_create_cube(instance, TEST_TAG_SHARED2, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
     int cube_id_3 = fieldstat_create_cube(instance, TEST_TAG_SHARED3, 1, SAMPLING_MODE_COMPREHENSIVE, 3);
-    (void)fieldstat_register_counter(instance, "counter");
-    (void)fieldstat_register_hll(instance, "gauge", g_hll_standard->cfg.precision);
-    int id_histogram = fieldstat_register_hist(instance, "histogram",
+    (void)fieldstat_register_counter(instance, cube_id_3, "counter");
+    (void)fieldstat_register_hll(instance, cube_id_3, "gauge", g_hll_standard->cfg.precision);
+    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);
 
     const int tag_num = 1;
@@ -361,10 +361,10 @@ TEST(export_test, skip_empty_metrics_given_cube_deleted) {
     int cube_id_del = fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
     int cube_id = fieldstat_create_cube(instance, TEST_TAG_SHARED2, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
     fieldstat_destroy_cube(instance, cube_id_del);
-    (void)fieldstat_register_counter(instance, "counter");
-    (void)fieldstat_register_counter(instance, "counter2");
-    int metric_id = fieldstat_register_counter(instance, "counter3");
-    (void)fieldstat_register_counter(instance, "counter4");
+    (void)fieldstat_register_counter(instance, cube_id, "counter");
+    (void)fieldstat_register_counter(instance, cube_id, "counter2");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter3");
+    (void)fieldstat_register_counter(instance, cube_id, "counter4");
 
     const int tag_num = 1;
     Fieldstat_tag_list_wrapper *fields[tag_num];
@@ -408,7 +408,7 @@ TEST(export_test, enable_delta_and_export_twice_without_new_metric)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int id_counter = fieldstat_register_counter(instance, "counter");
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, id_counter, &TEST_TAG_INT, 1, 1);
 
     // export test
@@ -477,8 +477,8 @@ TEST(export_test, enable_delta_and_export_twice_with_new_metric_and_omit_histogr
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int id_counter = fieldstat_register_counter(instance, "counter");
-    int id_histogram = fieldstat_register_hist(instance, "histogram",
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter");
+    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);
     fieldstat_counter_incrby(instance, cube_id, id_counter, &TEST_TAG_INT, 1, 1);
     fieldstat_hist_record(instance, cube_id, id_histogram, &TEST_TAG_INT, 1, 123);
@@ -516,7 +516,7 @@ TEST(export_test, enable_delta_and_export_twice_with_new_metric_and_omit_histogr
 
     struct timeval new_ts = TEST_TIMEVAL;
     new_ts.tv_sec += 1;
-    int id_counter2 = fieldstat_register_counter(instance, "counter2");
+    int id_counter2 = fieldstat_register_counter(instance, cube_id, "counter2");
     fieldstat_counter_incrby(instance, cube_id, id_counter2, &TEST_TAG_INT, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, id_counter, &TEST_TAG_INT, 1, 10);
 
@@ -559,8 +559,8 @@ TEST(export_test, enable_delta_and_export_three_times_skipping_cube_with_no_coun
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int id_counter = fieldstat_register_counter(instance, "counter");
-    int id_histogram = fieldstat_register_hist(instance, "histogram",
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter");
+    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);
     fieldstat_counter_incrby(instance, cube_id, id_counter, &TEST_TAG_INT, 1, 1);
     fieldstat_hist_record(instance, cube_id, id_histogram, &TEST_TAG_STRING, 1, 123);
@@ -668,13 +668,14 @@ TEST(export_test, enable_delta_and_export_instance_with_many_cells_with_global_t
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id1 = fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int id_counter1 = fieldstat_register_counter(instance, "counter");
+    int id_counter1 = fieldstat_register_counter(instance, cube_id1, "counter");
     fieldstat_counter_incrby(instance, cube_id1, id_counter1, &TEST_TAG_INT, 1, 11);
     fieldstat_counter_incrby(instance, cube_id1, id_counter1, &TEST_TAG_STRING, 1, 12);
 
     int cube_id2 = fieldstat_create_cube(instance, TEST_TAG_SHARED3, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_counter_incrby(instance, cube_id2, id_counter1, &TEST_TAG_INT, 1, 21);
-    fieldstat_counter_incrby(instance, cube_id2, id_counter1, &TEST_TAG_DOUBLE, 1, 22);
+    int id_counter2 = fieldstat_register_counter(instance, cube_id2, "counter");
+    fieldstat_counter_incrby(instance, cube_id2, id_counter2, &TEST_TAG_INT, 1, 21);
+    fieldstat_counter_incrby(instance, cube_id2, id_counter2, &TEST_TAG_DOUBLE, 1, 22);
 
     // export test
     struct fieldstat_json_exporter *fieldstat_json_exporter = fieldstat_json_exporter_new();
@@ -753,7 +754,7 @@ void test_reset_one_round(std::function<void(struct fieldstat *, struct fieldsta
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 1);
-    int id_counter = fieldstat_register_counter(instance, "counter");
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, id_counter, &TEST_TAG_INT, 1, 11);
 
     // export test
@@ -779,6 +780,7 @@ void test_reset_one_round(std::function<void(struct fieldstat *, struct fieldsta
     fieldstat_counter_set(instance, cube_id, id_counter, &TEST_TAG_INT, 1, 123);
 
     json_string = fieldstat_json_exporter_export(fieldstat_json_exporter, instance, &TEST_TIMEVAL);
+    printf("test_reset_one_round :\n%s\n", json_string);
     root_arr = cJSON_Parse(json_string);
     free(json_string);
 
@@ -817,6 +819,7 @@ TEST(export_test, enable_delta_and_reset_on_delete_cube) {
     auto trigger = [](struct fieldstat *instance, struct fieldstat_json_exporter *fieldstat_json_exporter) {
         fieldstat_destroy_cube(instance, 0);
         fieldstat_create_cube(instance, TEST_TAG_SHARED1, 3, SAMPLING_MODE_COMPREHENSIVE, 3);
+        fieldstat_register_counter(instance, 0, "counter");
     };
 
     test_reset_one_round(trigger);
@@ -825,11 +828,11 @@ TEST(export_test, enable_delta_and_reset_on_delete_cube) {
 TEST(export_test, delta_with_two_instance_same_config)
 {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, NULL, 0, SAMPLING_MODE_COMPREHENSIVE, 0);
-    int id_counter = fieldstat_register_counter(instance, "counter");
+    int cube_id = fieldstat_create_cube(instance, NULL, 0, SAMPLING_MODE_COMPREHENSIVE, 0);
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, 0, id_counter, &TEST_TAG_INT, 1, 123);
-    int id_hist = fieldstat_register_hist(instance, "histogram", 1, 1000, 3);
-    fieldstat_hist_record(instance, 0, id_hist, &TEST_TAG_INT, 1, 5);
+    int id_hist = fieldstat_register_hist(instance, cube_id, "histogram", 1, 1000, 3);
+    fieldstat_hist_record(instance, cube_id, id_hist, &TEST_TAG_INT, 1, 5);
     
     struct fieldstat *acc = fieldstat_new();
     fieldstat_merge(acc, instance);
@@ -865,10 +868,10 @@ TEST(export_test, delta_with_two_instance_same_config)
 TEST(export_test, delta_with_two_instance_one_empty)
 {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_create_cube(instance, NULL, 0, SAMPLING_MODE_COMPREHENSIVE, 0);
-    int id_counter = fieldstat_register_counter(instance, "counter");
+    int cube_id = fieldstat_create_cube(instance, NULL, 0, SAMPLING_MODE_COMPREHENSIVE, 0);
+    int id_counter = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, 0, id_counter, &TEST_TAG_INT, 1, 123);
-    int id_hist = fieldstat_register_hist(instance, "histogram", 1, 1000, 3);
+    int id_hist = fieldstat_register_hist(instance, cube_id, "histogram", 1, 1000, 3);
     fieldstat_hist_record(instance, 0, id_hist, &TEST_TAG_INT, 1, 5);
     
     struct fieldstat *delta = fieldstat_fork(instance);
@@ -876,7 +879,6 @@ TEST(export_test, delta_with_two_instance_one_empty)
     // export test
     struct fieldstat_json_exporter *fieldstat_json_exporter = fieldstat_json_exporter_new();
     char *json = fieldstat_json_exporter_export_with_delta(fieldstat_json_exporter, instance, delta, &TEST_TIMEVAL, &TEST_TIMEVAL);
-    printf("delta_with_two_instance_one_empty :\n%s\n", json);
     cJSON *root_arr = cJSON_Parse(json);
     free(json);
 
@@ -906,7 +908,7 @@ TEST(export_test, delta_with_two_instance_different_cell)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, NULL, 0, SAMPLING_MODE_COMPREHENSIVE, 0);
-    int id_counter = fieldstat_register_counter(instance, "counter");
+    int id_counter = fieldstat_register_counter(instance, 0, "counter");
     fieldstat_counter_incrby(instance, 0, id_counter, &TEST_TAG_INT, 1, 123);
 
     struct fieldstat *delta = fieldstat_fork(instance);
diff --git a/test/test_fuzz_test.cpp b/test/test_fuzz_test.cpp
index 8d896b5..3b70f05 100644
--- a/test/test_fuzz_test.cpp
+++ b/test/test_fuzz_test.cpp
@@ -79,10 +79,11 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
         shared_tags[i] = new Fieldstat_tag_list_wrapper("shared_tag", i);
         int cube_id = fieldstat_create_cube(master, shared_tags[i]->get_tag(), shared_tags[i]->get_tag_count(), SAMPLING_MODE_COMPREHENSIVE, CELL_MAX);
         EXPECT_EQ(cube_id, i);
+
+        fieldstat_register_counter(master, cube_id, metric_name[METRIC_ID_COUNTER]);
+        fieldstat_register_hll(master, cube_id, metric_name[METRIC_ID_HLL], 6);
     }
-    // init metric
-    fieldstat_register_counter(master, metric_name[METRIC_ID_COUNTER]);
-    fieldstat_register_hll(master, metric_name[METRIC_ID_HLL], 6);
+
     // all the possible fields
     Fieldstat_tag_list_wrapper *tag_list_wrapper[FLOW_NUM];
     fill_random_tag_of_length_1_to_3(tag_list_wrapper, FLOW_NUM);
@@ -121,6 +122,8 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
             shared_tags[cube_id_to_change] = new_tag;
             fieldstat_destroy_cube(master, cube_id_to_change);
             int cube_id_new = fieldstat_create_cube(master, new_tag->get_tag(), new_tag->get_tag_count(), SAMPLING_MODE_COMPREHENSIVE, CELL_MAX);
+            fieldstat_register_counter(master, cube_id_new, metric_name[METRIC_ID_COUNTER]);
+            fieldstat_register_hll(master, cube_id_new, metric_name[METRIC_ID_HLL], 6);
             EXPECT_EQ(cube_id_new, cube_id_to_change); // should new the cube in the hole leaved by the destroyed cube
             // calibrate
             for (int j = 0; j < INSTANCE_NUM; j++) {
@@ -219,9 +222,9 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
         shared_tags[i] = new Fieldstat_tag_list_wrapper("shared_tag", i);
         int cube_id = fieldstat_create_cube(master, shared_tags[i]->get_tag(), shared_tags[i]->get_tag_count(), SAMPLING_MODE_TOPK, CELL_MAX);
         EXPECT_EQ(cube_id, i);
+        fieldstat_register_counter(master, cube_id, "topk");
     }
-    // init metric
-    fieldstat_register_counter(master, "topk");
+    
     // all the possible fields
     Fieldstat_tag_list_wrapper *tag_list_wrapper[FLOW_NUM];
     fill_with_elephant_flows(tag_list_wrapper, FLOW_NUM);
@@ -257,6 +260,7 @@ TEST(Fuzz_test, many_instance_random_flow_unregister_calibrate_reset_fork_merge_
             shared_tags[cube_id_to_change] = new_tag;
             fieldstat_destroy_cube(master, cube_id_to_change);
             int cube_id_new = fieldstat_create_cube(master, new_tag->get_tag(), new_tag->get_tag_count(), SAMPLING_MODE_TOPK, CELL_MAX);
+            fieldstat_register_counter(master, cube_id_new, "topk");
             EXPECT_EQ(cube_id_new, cube_id_to_change); // should new the cube in the hole leaved by the destroyed cube
             // calibrate
             for (int j = 0; j < INSTANCE_NUM; j++) {
@@ -335,9 +339,10 @@ TEST(Fuzz_test, add_and_reset_with_randomly_generated_flows_and_randomly_chosen_
     fill_with_elephant_flows(tag_list_wrapper, FLOW_NUM);
 
     struct fieldstat *instance = fieldstat_new();
-    int primary_metric_id = fieldstat_register_counter(instance, "counter");
-    int counter2_id = fieldstat_register_counter(instance, "counter2");
+
     int cube_id = fieldstat_create_cube(instance,NULL,0,SAMPLING_MODE_TOPK, 1); // K = 1, just to increase the possibility of FS_ERR_TOO_MANY_CELLS
+    int primary_metric_id = fieldstat_register_counter(instance, cube_id, "counter");
+    int counter2_id = fieldstat_register_counter(instance, cube_id, "counter2");
     fieldstat_counter_incrby(instance, cube_id, primary_metric_id, tag_list_wrapper[0]->get_tag(), tag_list_wrapper[0]->get_tag_count(), 1);
     fieldstat_counter_incrby(instance, cube_id, counter2_id, tag_list_wrapper[0]->get_tag(), tag_list_wrapper[0]->get_tag_count(), 1);
 
@@ -388,9 +393,10 @@ TEST(Fuzz_test, simple_one_for_perf)
         shared_tags[i] = new Fieldstat_tag_list_wrapper("shared_tag", i);
         int cube_id = fieldstat_create_cube(master, shared_tags[i]->get_tag(), shared_tags[i]->get_tag_count(), SAMPLING_MODE_TOPK, CELL_MAX);
         EXPECT_EQ(cube_id, i);
+        fieldstat_register_counter(master, cube_id, "topk");
     }
     // init metric
-    fieldstat_register_counter(master, "topk");
+    
     // all the possible fields
     Fieldstat_tag_list_wrapper *tag_list_wrapper[FLOW_NUM];
     fill_with_elephant_flows(tag_list_wrapper, FLOW_NUM);
diff --git a/test/test_merge.cpp b/test/test_merge.cpp
index 7a07baf..ecf45fd 100644
--- a/test/test_merge.cpp
+++ b/test/test_merge.cpp
@@ -46,51 +46,12 @@ double merge_test_fieldstat_hll_get(const struct fieldstat *instance, int cube_i
     return ret;
 }
 
-TEST(unit_test_merge, test_metric_name_mapping_by_adding_metric_to_dest)
-{
-    struct fieldstat *instance = fieldstat_new();
-
-    int cube_id1 = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id_1 = fieldstat_register_counter(instance, "shared name");
-    struct fieldstat *instance_dest = fieldstat_fork(instance);
-
-    int metric_id_only_src = fieldstat_register_counter(instance, "metric_name cube1 cube2");
-    fieldstat_counter_incrby(instance, cube_id1, metric_id_1, &TEST_TAG_STRING, 1, 1);
-    fieldstat_counter_incrby(instance, cube_id1, metric_id_only_src, &TEST_TAG_STRING, 1, 2);
-    int cube_id2 = fieldstat_create_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_counter_incrby(instance, cube_id2, metric_id_only_src, &TEST_TAG_STRING, 1, 3);
-
-    EXPECT_EQ(fieldstat_merge(instance_dest, instance), FS_OK);
-
-    int *cube_id;
-    int n_cube;
-    fieldstat_get_cubes(instance_dest, &cube_id, &n_cube);
-    EXPECT_TRUE(n_cube == 2);
-    EXPECT_TRUE(cube_id[0] == cube_id1);
-
-    int *metric_ids;
-    size_t n_metrics;
-    fieldstat_get_metrics(instance_dest, &metric_ids, &n_metrics);
-    EXPECT_EQ(n_metrics, 2);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, metric_ids[0]), "shared name");
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, metric_ids[1]), "metric_name cube1 cube2");
-
-    EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, cube_id1, metric_ids[0]), 1); // shared name
-    EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, cube_id1, metric_ids[1]), 2); // metric_name cube1 cube2 on cube1
-    EXPECT_EQ(merge_test_fieldstat_counter_get(instance_dest, cube_id[1], metric_ids[1]), 3); // metric_name cube1 cube2 on cube2
-
-    fieldstat_free(instance);
-    fieldstat_free(instance_dest);
-    free(cube_id);
-    free(metric_ids);
-}
-
 TEST(unit_test_merge, cube_shared_tag_mapping_with_new_cube)
 {
     struct fieldstat *instance = fieldstat_new();
     (void)fieldstat_create_cube(instance, &TEST_TAG_DOUBLE, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int cube_id2 = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, "metric in cube 2");
+    int metric_id = fieldstat_register_counter(instance,cube_id2,"metric in cube 2");
     fieldstat_counter_incrby(instance, cube_id2, metric_id, &TEST_TAG_STRING, 1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
     int cube_id_dest = fieldstat_create_cube(instance_dest, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
@@ -127,7 +88,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_comprehensive)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(instance, "metric_name");
+    fieldstat_register_counter(instance, 0, "metric_name");
 
     struct fieldstat *instance_dest = fieldstat_new();
 
@@ -137,7 +98,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_comprehensive)
     int n_cube;
     fieldstat_get_cubes(instance_dest, &cube_id_dest, &n_cube);
     EXPECT_TRUE(n_cube == 1);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric_name");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id_dest[0], 0), "metric_name");
 
     fieldstat_free(instance);
     fieldstat_free(instance_dest);
@@ -148,7 +109,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_comprehensive)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, "metric_name");
+    int metric_id = fieldstat_register_counter(instance, 0, "metric_name");
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
 
@@ -160,7 +121,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_comprehensive)
     fieldstat_get_cubes(instance_dest, &cube_id_dest, &n_cube);
     EXPECT_TRUE(n_cube == 1);
     free(cube_id_dest);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric_name");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id_dest[0], 0), "metric_name");
     long long measure = merge_test_fieldstat_counter_get(instance, cube_id, metric_id);
     EXPECT_EQ(measure, 10086);
 
@@ -180,14 +141,14 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_comprehens
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, "metric_name");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_STRING, 1, 5);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
 
     fieldstat_merge(instance_dest, instance);
 
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric_name");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id, 0), "metric_name");
     long long measure = merge_test_fieldstat_counter_get(instance_dest, cube_id, metric_id);
     EXPECT_EQ(measure, 10);
 
@@ -199,7 +160,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_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 2); // limit is 2
-    int metric_id = fieldstat_register_counter(instance, "metric name");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_STRING, 1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
@@ -227,14 +188,14 @@ TEST(unit_test_merge, new_too_many_cells_on_multiple_metric_given_source_cube_re
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 2);
-    int metric_id1 = fieldstat_register_counter(instance, "metric name1");
-    int metric_id2 = fieldstat_register_counter(instance, "metric name2");
+    int metric_id1 = fieldstat_register_counter(instance, cube_id, "metric name1");
+    int metric_id2 = fieldstat_register_counter(instance, cube_id, "metric name2");
     fieldstat_counter_incrby(instance, cube_id, metric_id1, &TEST_TAG_STRING, 1, 1); // 1st cell on metric name1
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
     fieldstat_reset(instance);
 
-    int metric_id3 = fieldstat_register_counter(instance, "metric name3");
+    int metric_id3 = fieldstat_register_counter(instance, cube_id, "metric name3");
     fieldstat_counter_incrby(instance, cube_id, metric_id3, &TEST_TAG_INT, 1, 2); // 2nd cell on metric name3, this is a metric dest dont have
     fieldstat_counter_incrby(instance, cube_id, metric_id2, &TEST_TAG_DOUBLE, 1, 3); // 3nd cell on metric name2
     fieldstat_merge(instance_dest, instance);
@@ -243,12 +204,12 @@ TEST(unit_test_merge, new_too_many_cells_on_multiple_metric_given_source_cube_re
     size_t n_metrics = 0;
     fieldstat_get_metric_in_cell(instance_dest, 0, &TEST_TAG_LIST_STRING, &metric_ids, &n_metrics);
     EXPECT_EQ(n_metrics, 1);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, metric_ids[0]), "metric name1");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0, metric_ids[0]), "metric name1");
     free(metric_ids);
 
     fieldstat_get_metric_in_cell(instance_dest, 0, &TEST_TAG_LIST_INT, &metric_ids, &n_metrics);
     EXPECT_EQ(n_metrics, 1);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, metric_ids[0]), "metric name3");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0, metric_ids[0]), "metric name3");
     free(metric_ids);
      // 3nd cell failed to merge, because max sampling is 2
     fieldstat_get_metric_in_cell(instance_dest, 0, &TEST_TAG_LIST_DOUBLE, &metric_ids, &n_metrics);
@@ -262,7 +223,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, "metric_name");
+    fieldstat_register_counter(instance, 0, "metric_name");
 
     struct fieldstat *instance_dest = fieldstat_new();
 
@@ -272,7 +233,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_topk)
     int n_cube;
     fieldstat_get_cubes(instance_dest, &cube_id_dest, &n_cube);
     EXPECT_TRUE(n_cube == 1);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric_name");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id_dest[0], 0), "metric_name");
 
     fieldstat_free(instance);
     fieldstat_free(instance_dest);
@@ -283,7 +244,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, "metric_name");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name");
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
 
@@ -295,7 +256,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_topk)
     fieldstat_get_cubes(instance_dest, &cube_id_dest, &n_cube);
     EXPECT_TRUE(n_cube == 1);
     free(cube_id_dest);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric_name");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest,cube_id_dest[0], 0), "metric_name");
     long long measure = merge_test_fieldstat_counter_get(instance, cube_id, metric_id);
     EXPECT_EQ(measure, 10086);
 
@@ -315,7 +276,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, "metric_name");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric_name");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_STRING, 1, 5);
     struct fieldstat *instance_dest = fieldstat_new();
 
@@ -328,7 +289,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_topk)
     EXPECT_TRUE(n_cube == 1);
     int ret_cube_id = cube_id_dest[0];
     free(cube_id_dest);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric_name");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest,cube_id_dest[0], 0), "metric_name");
 
     struct field_list *tag_list = NULL;
     size_t n_cell = 0;
@@ -346,7 +307,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_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_id = fieldstat_register_counter(instance, "metric name");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_STRING, 1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
@@ -374,7 +335,7 @@ struct fieldstat *topk_test_push_flows(vector<Fieldstat_tag_list_wrapper *> &flo
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, K);
-    int metric_id = fieldstat_register_counter(instance, "metric name");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "metric name");
     for (size_t i = 0; i < flows_in_test.size(); i++) {
         fieldstat_counter_incrby(instance, cube_id, metric_id, flows_in_test[i]->get_tag(), flows_in_test[i]->get_tag_count(), count);
     }
@@ -489,8 +450,8 @@ TEST(unit_test_merge, primary_metric_has_no_value)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_primary = fieldstat_register_counter(instance, "primary");
-    int metric_operated = fieldstat_register_counter(instance, "operated");
+    int metric_primary = fieldstat_register_counter(instance, cube_id, "primary");
+    int metric_operated = fieldstat_register_counter(instance, cube_id, "operated");
     fieldstat_counter_incrby(instance, cube_id, metric_operated, &TEST_TAG_STRING, 1, 1);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
@@ -514,15 +475,15 @@ TEST(unit_test_merge, primary_metric_id_different)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    int metric_primary = fieldstat_register_counter(instance, "primary");
-    int metric_2 = fieldstat_register_counter(instance, "2");
+    int metric_primary = fieldstat_register_counter(instance, cube_id, "primary");
+    int metric_2 = fieldstat_register_counter(instance, cube_id, "2");
     fieldstat_counter_incrby(instance, cube_id, metric_primary, &TEST_TAG_STRING, 1, 100);
     fieldstat_counter_incrby(instance, cube_id, metric_2, &TEST_TAG_STRING, 1, 1);
 
     struct fieldstat *instance_dst = fieldstat_new();
     int cube_id_dst = fieldstat_create_cube(instance_dst, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 2);
-    fieldstat_register_counter(instance_dst, "2");
-    int metric_primary_dst = fieldstat_register_counter(instance_dst, "primary");
+    fieldstat_register_counter(instance_dst, cube_id_dst, "2");
+    int metric_primary_dst = fieldstat_register_counter(instance_dst, cube_id_dst, "primary");
     fieldstat_cube_set_primary_metric(instance_dst, cube_id_dst, metric_primary_dst);
 
     EXPECT_EQ(fieldstat_merge(instance_dst, instance), FS_ERR_INVALID_PARAM);
@@ -534,7 +495,7 @@ TEST(unit_test_merge, primary_metric_id_different)
 TEST(unit_test_merge, new_cube_and_metric_to_empty_spreadsketch) {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT, 1, SAMPLING_MODE_SPREADSKETCH, 10);
-    fieldstat_register_hll(instance, "metric", 6);
+    fieldstat_register_hll(instance, 0, "metric", 6);
 
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
@@ -543,7 +504,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_spreadsketch) {
     int n_cube;
     fieldstat_get_cubes(instance_dest, &cube_id_dest, &n_cube);
     EXPECT_TRUE(n_cube == 1);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id_dest[0], 0), "metric");
 
     free(cube_id_dest);
     fieldstat_free(instance);
@@ -553,7 +514,7 @@ TEST(unit_test_merge, new_cube_and_metric_to_empty_spreadsketch) {
 TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_spreadsketch) {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, 10);
-    int metric_id = fieldstat_register_hll(instance, "metric", 6);
+    int metric_id = fieldstat_register_hll(instance, cube_id, "metric", 6);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
 
@@ -565,8 +526,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_spreadsketch) {
     int n_cube;
     fieldstat_get_cubes(instance_dest, &cube_id_dest, &n_cube);
     EXPECT_TRUE(n_cube == 1);
-    free(cube_id_dest);
-    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, 0), "metric");
+    EXPECT_STREQ(fieldstat_get_metric_name(instance_dest, cube_id_dest[0], 0), "metric");
     long long measure = merge_test_fieldstat_hll_get(instance, cube_id, metric_id);
     EXPECT_NEAR(measure, 2, 0.3);
 
@@ -577,6 +537,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_spreadsketch) {
     EXPECT_EQ(tag_list->n_field, 1);
     EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_STRING.key);
 
+    free(cube_id_dest);
     fieldstat_free(instance);
     fieldstat_free(instance_dest);
     fieldstat_tag_list_arr_free(tag_list, n_cell);
@@ -585,7 +546,7 @@ TEST(unit_test_merge, new_cell_on_existing_cube_and_metric_spreadsketch) {
 TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_spreadsketch) {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, 10);
-    int metric_id = fieldstat_register_hll(instance, "metric", 6);
+    int metric_id = fieldstat_register_hll(instance, cube_id, "metric", 6);
     fieldstat_hll_add(instance, cube_id, metric_id, &TEST_TAG_STRING, 1, "1", 1);
     struct fieldstat *instance_dest = fieldstat_new();
 
@@ -609,7 +570,7 @@ TEST(unit_test_merge, merge_existing_cell_on_existing_cube_and_metric_spreadsket
 TEST(unit_test_merge, new_too_many_cells_on_one_metric_given_source_cube_reset_and_get_different_cube_spreadsketch) {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, 2);
-    int metric_id = fieldstat_register_hll(instance, "metric", 6);
+    int metric_id = fieldstat_register_hll(instance, cube_id, "metric", 6);
     fieldstat_hll_add(instance, cube_id, metric_id, &TEST_TAG_STRING, 1, "1", 1);
     struct fieldstat *instance_dest = fieldstat_new();
     fieldstat_merge(instance_dest, instance);
@@ -641,7 +602,7 @@ TEST(unit_test_merge, gen_dest_full_all_src_inserted_given_src_flows_larger_spre
     SpreadSketchZipfGenerator flow_generator(1.0, K); // exactly the number of cells, so there will be almost all(in case of hash collision happen) cells added successfully
     struct fieldstat *instance_src = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance_src, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, K);
-    int metric_id = fieldstat_register_hll(instance_src, "metric", 6);
+    int metric_id = fieldstat_register_hll(instance_src, cube_id, "metric", 6);
     struct fieldstat *instance_dest = fieldstat_fork(instance_src);
     const char dest_key[] = "key of dest";
     const char src_key[] = "key of src";
@@ -699,7 +660,7 @@ TEST(unit_test_merge, merge_accuracy_test_gen_dest_full_some_inserted_and_some_m
     SpreadSketchZipfGenerator flow_generator(1.0, K); // exactly the number of cells, so there will be almost all(in case of hash collision happen) cells added successfully
     struct fieldstat *instance_src = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance_src, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, K);
-    int metric_id = fieldstat_register_hll(instance_src, "metric", 6);
+    int metric_id = fieldstat_register_hll(instance_src, cube_id, "metric", 6);
     struct fieldstat *instance_dest = fieldstat_fork(instance_src);
 
     std::unordered_map<std::string, std::unordered_set<std::string>> flow_cnt;
diff --git a/test/test_metric_counter.cpp b/test/test_metric_counter.cpp
index 675c42f..c6774f9 100644
--- a/test/test_metric_counter.cpp
+++ b/test/test_metric_counter.cpp
@@ -13,7 +13,7 @@ struct fieldstat *test_init_standard_instance()
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     EXPECT_EQ(cube_id, 0);
 
-    int metric_id = fieldstat_register_counter(instance, "czz_test counter metric");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "czz_test counter metric");
     EXPECT_EQ(metric_id, 0);
 
     return instance;
@@ -35,7 +35,7 @@ void test_assert_standard_instance(const struct fieldstat *instance)
     int ret_cell_id = ret_cube_id_arr[0];
     free(ret_cube_id_arr);
     EXPECT_EQ(ret_cell_id, 0);
-    const char *name = fieldstat_get_metric_name(instance, 0);
+    const char *name = fieldstat_get_metric_name(instance, ret_cell_id, 0);
     EXPECT_STREQ(name, "czz_test counter metric");
 
     struct field_list *tag_list = NULL;
@@ -111,7 +111,7 @@ TEST(metric_test_counter, topk_add_and_test_accuracy)
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, "test");
+    fieldstat_register_counter(instance, 0, "test");
 
     int tag_list_num = 10000;
     Fieldstat_tag_list_wrapper *fields[tag_list_num];
@@ -179,7 +179,7 @@ TEST(metric_test_counter, add_with_wrong_metric_id_expecting_fail)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, "test");
+    int metric_id = fieldstat_register_counter(instance, 0, "test");
 
     int ret = fieldstat_counter_incrby(instance, cube_id, metric_id + 1, &TEST_TAG_INT, 1, 1);
     EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
@@ -193,8 +193,8 @@ TEST(metric_test_counter, add_and_query_on_dummy_cell_of_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    fieldstat_register_counter(instance, "primary"); // also the dummy one
-    int metric_id = fieldstat_register_counter(instance, "using");
+    fieldstat_register_counter(instance, cube_id, "primary"); // also the dummy one
+    int metric_id = fieldstat_register_counter(instance, cube_id, "using");
 
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
 
@@ -216,8 +216,8 @@ TEST(metric_test_counter, primary_counter_add_after_first)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id_primary = fieldstat_register_counter(instance, "primary");
-    int metric_id2 = fieldstat_register_counter(instance, "using");
+    int metric_id_primary = fieldstat_register_counter(instance, cube_id, "primary");
+    int metric_id2 = fieldstat_register_counter(instance, cube_id, "using");
     fieldstat_cube_set_primary_metric(instance, cube_id, metric_id_primary);
 
 
diff --git a/test/test_metric_histogram.cpp b/test/test_metric_histogram.cpp
index 06fdd17..84244bf 100644
--- a/test/test_metric_histogram.cpp
+++ b/test/test_metric_histogram.cpp
@@ -12,7 +12,7 @@ struct fieldstat *test_init_standard_instance_one_cube_one_metric_one_cell_hdr()
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     EXPECT_EQ(cube_id, 0);
 
-    int metric_id = fieldstat_register_hist(instance, "czz_test hdr metric", 1, 600000, 3);
+    int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test hdr metric", 1, 600000, 3);
     EXPECT_EQ(metric_id, 0);
 
     return instance;
@@ -27,7 +27,7 @@ void test_assert_standard_instance(const struct fieldstat *instance)
     int ret_cell_id = ret_cube_id_arr[0];
     free(ret_cube_id_arr);
     EXPECT_EQ(ret_cell_id, 0);
-    const char *name = fieldstat_get_metric_name(instance, 0);
+    const char *name = fieldstat_get_metric_name(instance, ret_cell_id, 0);
     EXPECT_STREQ(name, "czz_test hdr metric");
 
 
@@ -121,7 +121,7 @@ TEST(metric_test_histogram, add_with_wrong_metric_id_expecting_fail)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_hist(instance, "czz_test", 1, 600000, 3);
+    int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test", 1, 600000, 3);
 
     int ret = fieldstat_hist_record(instance, cube_id, metric_id + 1, &TEST_TAG_INT, 1, 1);
     EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
@@ -170,7 +170,7 @@ TEST(metric_test_histogram, can_add_0value) // histogram only allow min_val > 0,
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_hist(instance, "czz_test", 1, 600000, 3);
+    int metric_id = fieldstat_register_hist(instance, cube_id, "czz_test", 1, 600000, 3);
 
     int ret = fieldstat_hist_record(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 0);
     EXPECT_EQ(ret, 0);
diff --git a/test/test_metric_hll.cpp b/test/test_metric_hll.cpp
index 7c38de2..66ef404 100644
--- a/test/test_metric_hll.cpp
+++ b/test/test_metric_hll.cpp
@@ -14,7 +14,7 @@ struct fieldstat *test_init_standard_instance_one_cube_one_metric_one_cell_hll(b
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     EXPECT_EQ(cube_id, 0);
 
-    int metric_id = fieldstat_register_hll(instance, "czz_test hll metric", 10);
+    int metric_id = fieldstat_register_hll(instance, cube_id, "czz_test hll metric", 10);
     EXPECT_EQ(metric_id, 0);
 
     return instance;
@@ -29,7 +29,7 @@ void test_assert_standard_instance(const struct fieldstat *instance)
     int ret_cell_id = ret_cube_id_arr[0];
     free(ret_cube_id_arr);
     EXPECT_EQ(ret_cell_id, 0);
-    const char *name = fieldstat_get_metric_name(instance, 0);
+    const char *name = fieldstat_get_metric_name(instance, ret_cell_id, 0);
     EXPECT_STREQ(name, "czz_test hll metric");
 
     struct field_list *tag_list = NULL;
@@ -212,7 +212,7 @@ TEST(metric_test_hll, add_with_wrong_metric_id_expecting_fail)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_hll(instance, "czz_test hll metric", 10);
+    int metric_id = fieldstat_register_hll(instance, cube_id, "czz_test hll metric", 10);
 
     int ret = fieldstat_hll_add(instance, cube_id, metric_id + 1, &TEST_TAG_INT, 1, "hello", 5);
     EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
@@ -227,7 +227,7 @@ TEST(metric_test_hll, spread_sketch_add_and_test_accuracy)
     struct fieldstat *instance = fieldstat_new();
     int K = 10;
     fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_SPREADSKETCH, K);
-    fieldstat_register_hll(instance, "testss", 6);
+    fieldstat_register_hll(instance, 0, "testss", 6);
 
     int n_flows = 100000;
     std::unordered_map<std::string, std::unordered_set<std::string>> flow_cnt;
diff --git a/test/test_performance.cpp b/test/test_performance.cpp
index 5931a81..2a8a8e9 100644
--- a/test/test_performance.cpp
+++ b/test/test_performance.cpp
@@ -48,7 +48,7 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_counter_empt
         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);
@@ -65,7 +65,7 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_hll_empty_de
         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 +75,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 field *fields, int n_field) {
         fieldstat_hist_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_hist(instance, 0, "histogram metric", 1, 100000, 1);
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, true);
@@ -96,7 +93,7 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_empty_dest)
         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);
@@ -110,7 +107,7 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_counter_full
         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);
@@ -124,7 +121,7 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_hll_full_des
         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);
@@ -138,7 +135,7 @@ TEST(test_performance, merge_performance_one_instance_comprehensive_histogram_fu
         fieldstat_hist_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_hist(instance, 0, "histogram metric", 1, 100000, 1);
     };
 
     double elapsed = perform_merge_test(metric_add_func, metric_register_func, SAMPLING_MODE_COMPREHENSIVE, false);
@@ -152,7 +149,7 @@ TEST(test_performance, merge_performance_one_instance_topk_counter_full_dest)
         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);
@@ -166,10 +163,10 @@ struct fieldstat *construct_fs_with_many_empty_cubes(int cube_num, int metric_nu
     struct field tmp_tag = TEST_TAG_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_create_cube(instance, &tmp_tag, 1, mode, 1000);
 
         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());
         }
     }
     return instance;
@@ -223,7 +220,7 @@ TEST(test_performance, performance_test_add_cells_comprehensive)
     // 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");
+    fieldstat_register_counter(instance, 0, "test");
 
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
@@ -250,7 +247,7 @@ TEST(test_performance, performance_test_add_cells_topk)
     }
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 1000);
-    fieldstat_register_counter(instance, "test");
+    fieldstat_register_counter(instance, 0, "test");
 
     // getchar();
     clock_t start = clock();
@@ -271,7 +268,7 @@ 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);
+    fieldstat_register_hist(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++) {
@@ -292,7 +289,7 @@ 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);
+    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++) {
@@ -329,7 +326,7 @@ TEST(test_performance, performance_test_add_cells_comprehensive_5_tags)
     // 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");
+    fieldstat_register_counter(instance, 0, "test");
 
     clock_t start = clock();
     for (size_t i = 0; i < cell_count; i++) {
@@ -350,7 +347,7 @@ 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);
+    fieldstat_register_hist(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++) {
@@ -378,7 +375,7 @@ 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);
+    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++) {
@@ -426,7 +423,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, 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, fields[rand() % TAG_NUM]->get_tag(), 1, 1);
@@ -500,7 +497,7 @@ struct fieldstat *construct_fs_with_many_cells(int cell_num, enum sampling_mode
 {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_create_cube(instance, &TEST_TAG_INT, 1, mode, cell_num);
-    fieldstat_register_counter(instance, "test");
+    fieldstat_register_counter(instance, 0, "test");
     struct field tmp_tag = TEST_TAG_INT;
     for (int i = 0; i < cell_num; i++) {
         tmp_tag.value_longlong = i;
diff --git a/test/test_register_and_reset.cpp b/test/test_register_and_reset.cpp
index d94e935..36902e1 100644
--- a/test/test_register_and_reset.cpp
+++ b/test/test_register_and_reset.cpp
@@ -19,7 +19,7 @@ TEST(test_register, delete_comprehensive_cube_with_cells_and_metrics)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
 
     fieldstat_destroy_cube(instance, cube_id);
@@ -36,7 +36,7 @@ TEST(test_register, delete_topk_cube_with_cells_and_metrics)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
 
     fieldstat_destroy_cube(instance, cube_id);
@@ -52,8 +52,8 @@ TEST(test_register, delete_spreadsketch_cube_with_cells_and_metrics)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, 10);
-    int metric_id1 = fieldstat_register_counter(instance, "counter");
-    int metric_primary = fieldstat_register_hll(instance, "hll_primary", 5);
+    int metric_id1 = fieldstat_register_counter(instance, cube_id, "counter");
+    int metric_primary = fieldstat_register_hll(instance, cube_id, "hll_primary", 5);
     fieldstat_cube_set_primary_metric(instance, cube_id, metric_primary);
     fieldstat_counter_incrby(instance, cube_id, metric_id1, &TEST_TAG_INT, 1, 1);
     fieldstat_hll_add_field(instance, cube_id, metric_primary, &TEST_TAG_INT, 1, &TEST_TAG_DOUBLE, 1);
@@ -72,7 +72,7 @@ int test_get_max_metric_id(const struct fieldstat *instance)
 {
     int *metric_id_out;
     size_t n_metric;
-    (void)fieldstat_get_metrics(instance, &metric_id_out, &n_metric);
+    (void)fieldstat_cube_get_metrics(instance, 0, &metric_id_out, &n_metric);
     free(metric_id_out);
     return n_metric - 1;
 }
@@ -81,7 +81,7 @@ TEST(test_register, reset_and_try_to_query_cell_comprehensive)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
 
     fieldstat_reset(instance);
@@ -100,7 +100,7 @@ TEST(test_register, reset_and_try_to_query_cell_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
 
     fieldstat_reset(instance);
@@ -119,7 +119,7 @@ TEST(test_register, reset_and_try_to_query_cell_spreadsketch)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, 10);
-    int metric_id = fieldstat_register_hll(instance, "hll", 5);
+    int metric_id = fieldstat_register_hll(instance, cube_id, "hll", 5);
     fieldstat_hll_add(instance, cube_id, metric_id, &TEST_TAG_INT, 1, "12abc", 5);
 
     fieldstat_reset(instance);
@@ -138,7 +138,7 @@ TEST(test_register, reset_and_new_cell_comprehensive)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 2);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_DOUBLE, 1, 1);
     int ret = fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_STRING, 1, 1);
@@ -155,7 +155,7 @@ TEST(test_register, reset_and_new_cell_topk)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 1);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 100);//100: bigger value
     int ret = fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_DOUBLE, 1, 1);
     EXPECT_EQ(ret, FS_ERR_TOO_MANY_CELLS);
@@ -171,7 +171,7 @@ TEST(test_register, reset_and_new_cell_spreadsketch)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, 1);
-    int metric_id = fieldstat_register_hll(instance, "hll", 5);
+    int metric_id = fieldstat_register_hll(instance, cube_id, "hll", 5);
     // spread sketch will store more data than expected cell number 1. So loop for many cells first to trigger the error
     struct field test_tag_long = TEST_TAG_INT;
     for (int i = 0; i < 10000; i++) {
@@ -192,7 +192,7 @@ TEST(test_register, ensure_recovery_more_faster_comprehensive) {
     struct fieldstat *instance = fieldstat_new();
     int cell_num = 1000;
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, cell_num);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     struct field test_tag_long = TEST_TAG_INT;
 
     clock_t start = clock();
@@ -222,7 +222,7 @@ TEST(test_register, ensure_recovery_more_faster_topk) {
     struct fieldstat *instance = fieldstat_new();
     int cell_num = 1000;
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, cell_num);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     struct field test_tag_long = TEST_TAG_INT;
 
     clock_t start = clock();
@@ -252,7 +252,7 @@ TEST(test_register, ensure_recovery_more_faster_spreadsketch) {
     struct fieldstat *instance = fieldstat_new();
     int cell_num = 1000;
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_SPREADSKETCH, cell_num);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_hll(instance, cube_id, "counter", 6);
     struct field test_tag_long = TEST_TAG_INT;
 
     clock_t start = clock();
@@ -273,7 +273,6 @@ TEST(test_register, ensure_recovery_more_faster_spreadsketch) {
     end = clock();
     clock_t duration_reset = end - start;
 
-    printf("initialize: %ld, reset: %ld\n", duration_initialize, duration_reset);
     EXPECT_LT(duration_reset, duration_initialize);
 
     fieldstat_free(instance);
@@ -288,11 +287,11 @@ TEST(test_register, register_many_cubes)
         shared_tag.value_longlong = i;
         int cube_id = fieldstat_create_cube(instance, &shared_tag, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
         EXPECT_EQ(cube_id, i);
+        fieldstat_register_counter(instance, cube_id, "counter");
     }
     // try to use the cube
-    int metric_id = fieldstat_register_counter(instance, "counter");
     for (int i = 0; i < registered_cube; i++) {
-        fieldstat_counter_incrby(instance, i, metric_id, &TEST_TAG_INT, 1, i);
+        fieldstat_counter_incrby(instance, i, 0, &TEST_TAG_INT, 1, i);
     }
 
     for (int i = 0; i < registered_cube; i++) {
@@ -314,7 +313,7 @@ TEST(test_register, add_many_tagged_cells)
         test_tag_long[i] = TEST_TAG_INT; // will trigger realloc 
     }
 
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, test_tag_long, n_field, 10086);
 
     long long result;
@@ -335,7 +334,7 @@ TEST(test_register, add_long_tagged_cells)
     long_string[5000] = '\0';
     test_tag_long.value_str = long_string;
 
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &test_tag_long, 1, 10086);
 
     long long result;
@@ -353,7 +352,7 @@ TEST(test_register, register_many_metrics)
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int metric_id = 0;
     for (int i = 0; i < 200; i++) {
-        metric_id = fieldstat_register_counter(instance, (std::string("counter ") + std::to_string(i)).c_str());
+        metric_id = fieldstat_register_counter(instance, cube_id, (std::string("counter ") + std::to_string(i)).c_str());
         EXPECT_EQ(metric_id, i);
     }
 
@@ -383,8 +382,8 @@ TEST(test_register, fork_registered_info_with_cube_and_metric)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, "counter");
-    int metric_id2 = fieldstat_register_counter(instance, "counter2");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
+    int metric_id2 = fieldstat_register_counter(instance, cube_id, "counter2");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
     int cube_id_del = fieldstat_create_cube(instance, &TEST_TAG_DOUBLE_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     fieldstat_create_cube(instance, &TEST_TAG_DOUBLE, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
@@ -407,12 +406,14 @@ TEST(test_register, fork_registered_info_with_cube_and_metric)
 
     tag_list = fieldstat_cube_get_tags(dup, cube_ids[1]);
     EXPECT_STREQ(tag_list->field[0].key, TEST_TAG_DOUBLE.key);
-    free(cube_ids);
+    
     fieldstat_tag_list_arr_free(tag_list, 1);
 
-    EXPECT_STREQ(fieldstat_get_metric_name(dup, metric_id), "counter");
-    EXPECT_STREQ(fieldstat_get_metric_name(dup, metric_id2), "counter2");
+    EXPECT_STREQ(fieldstat_get_metric_name(dup, cube_ids[0], metric_id), "counter");
+    EXPECT_STREQ(fieldstat_get_metric_name(dup, cube_ids[0], metric_id2), "counter2");
+    EXPECT_EQ(fieldstat_get_metric_name(dup, cube_ids[1], metric_id), nullptr);
 
+    free(cube_ids);
     fieldstat_free(dup);
     fieldstat_free(instance);
 }
@@ -424,8 +425,8 @@ TEST(test_register, unregister_cube_on_wrong_instance)
 
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     int cube_id2 = fieldstat_create_cube(instance, &TEST_TAG_DOUBLE, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    int metric_id = fieldstat_register_counter(instance, "counter");
-    int metric_id2 = fieldstat_register_counter(instance, "counter2");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
+    int metric_id2 = fieldstat_register_counter(instance, cube_id2, "counter2");
     fieldstat_counter_incrby(instance, cube_id, metric_id, &TEST_TAG_INT, 1, 1);
     fieldstat_counter_incrby(instance, cube_id2, metric_id2, &TEST_TAG_INT, 1, 1);
 
@@ -444,7 +445,7 @@ TEST(test_register, unregister_cube_on_wrong_instance)
     long long val_deleted_once;
     fieldstat_counter_get(instance_dst, cube_id, &TEST_TAG_LIST_INT,metric_id,  &val_deleted_once);
     EXPECT_EQ(val_deleted_once, 1);
-    long long val_merged_twice;
+    long long val_merged_twice = -1;
     fieldstat_counter_get(instance_dst, cube_id2, &TEST_TAG_LIST_INT, metric_id2,  &val_merged_twice);
     EXPECT_EQ(val_merged_twice, 2);
 
@@ -457,7 +458,7 @@ TEST(test_register, register_many_cells_on_unlimited_sized_cube)
 {
     struct fieldstat *instance = fieldstat_new();
     int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 0);
-    int metric_id = fieldstat_register_counter(instance, "counter");
+    int metric_id = fieldstat_register_counter(instance, cube_id, "counter");
     struct field test_tag = {"abc", TAG_INTEGER, {.value_longlong = 0}};
     for (int i = 0; i < 10000; i++) {
         test_tag.value_longlong = i;
@@ -497,8 +498,10 @@ TEST(test_register, find_cube) {
 
 TEST(test_register, register_metric_twice) {
     struct fieldstat *instance = fieldstat_new();
-    fieldstat_register_counter(instance, "counter");
-    int metric_id2 = fieldstat_register_counter(instance, "counter");
+    int cube_id = fieldstat_create_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
+
+    fieldstat_register_counter(instance, cube_id, "counter");
+    int metric_id2 = fieldstat_register_counter(instance, cube_id, "counter");
     EXPECT_EQ(metric_id2, FS_ERR_INVALID_KEY);
     fieldstat_free(instance);
 }
@@ -507,14 +510,14 @@ TEST(calibrate, target_one_more_metric)
 {
     struct fieldstat *master = fieldstat_new();
     int cube_id = fieldstat_create_cube(master, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(master, "counter");
+    fieldstat_register_counter(master, cube_id, "counter");
     struct fieldstat *target = fieldstat_fork(master);
-    EXPECT_EQ(fieldstat_register_counter(target, "counter2"), 1);
+    EXPECT_EQ(fieldstat_register_counter(target, cube_id, "counter2"), 1);
 
     fieldstat_calibrate(master, target);
 
     EXPECT_EQ(test_get_max_metric_id(target), 0);
-    EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
+    EXPECT_STREQ(fieldstat_get_metric_name(target, cube_id, 0), "counter");
     struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
@@ -527,15 +530,15 @@ TEST(calibrate, master_one_more_metric)
 {
     struct fieldstat *master = fieldstat_new();
     int cube_id = fieldstat_create_cube(master, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(master, "counter");
+    fieldstat_register_counter(master, cube_id, "counter");
     struct fieldstat *target = fieldstat_fork(master);
-    EXPECT_EQ(fieldstat_register_counter(master, "counter2"), 1);
+    EXPECT_EQ(fieldstat_register_counter(master, cube_id, "counter2"), 1);
 
     fieldstat_calibrate(master, target);
 
     EXPECT_EQ(test_get_max_metric_id(target), 1);
-    EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
-    EXPECT_STREQ(fieldstat_get_metric_name(target, 1), "counter2");
+    EXPECT_STREQ(fieldstat_get_metric_name(target, cube_id,0), "counter");
+    EXPECT_STREQ(fieldstat_get_metric_name(target, cube_id,1), "counter2");
     struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
@@ -549,16 +552,16 @@ TEST(calibrate, different_metric)
 {
     struct fieldstat *master = fieldstat_new();
     int cube_id = fieldstat_create_cube(master, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(master, "counter");
+    fieldstat_register_counter(master, cube_id, "counter");
     struct fieldstat *target = fieldstat_fork(master);
-    EXPECT_EQ(fieldstat_register_counter(target, "counter2"), 1);
-    EXPECT_EQ(fieldstat_register_counter(master, "hi i am master new"), 1);
+    EXPECT_EQ(fieldstat_register_counter(target, cube_id, "counter2"), 1);
+    EXPECT_EQ(fieldstat_register_counter(master, cube_id, "hi i am master new"), 1);
 
     fieldstat_calibrate(master, target);
 
     EXPECT_EQ(test_get_max_metric_id(target), 1);
-    EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
-    EXPECT_STREQ(fieldstat_get_metric_name(target, 1), "hi i am master new");
+    EXPECT_STREQ(fieldstat_get_metric_name(target, cube_id, 0), "counter");
+    EXPECT_STREQ(fieldstat_get_metric_name(target, cube_id, 1), "hi i am master new");
     struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
@@ -571,11 +574,11 @@ TEST(calibrate, target_more_cube)
 {
     struct fieldstat *master = fieldstat_new();
     int cube_id = fieldstat_create_cube(master, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(master, "counter");
+    fieldstat_register_counter(master, cube_id, "counter");
     struct fieldstat *target = fieldstat_fork(master);
     int cube_id2 = fieldstat_create_cube(target, &TEST_TAG_STRING, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
     EXPECT_EQ(cube_id2, 1);
-    fieldstat_register_counter(target, "counter2");
+    fieldstat_register_counter(target, cube_id, "counter2");
 
     fieldstat_calibrate(master, target);
 
@@ -587,7 +590,7 @@ TEST(calibrate, target_more_cube)
     free(cube_ids);
 
     EXPECT_EQ(test_get_max_metric_id(target), 0);
-    EXPECT_STREQ(fieldstat_get_metric_name(target, 0), "counter");
+    EXPECT_STREQ(fieldstat_get_metric_name(target, cube_id, 0), "counter");
     struct field_list *tag_list = fieldstat_cube_get_tags(target, cube_id);
     EXPECT_STREQ(tag_list->field[0].key, TEST_SHARED_TAG.key);
 
@@ -634,7 +637,6 @@ TEST(calibrate, master_change_cube)
 {
     struct fieldstat *master = fieldstat_new();
     int cube_id = fieldstat_create_cube(master, &TEST_SHARED_TAG, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
-    fieldstat_register_counter(master, "counter");
     struct fieldstat *target = fieldstat_fork(master);
     fieldstat_destroy_cube(master, cube_id);
     fieldstat_create_cube(master, &TEST_TAG_STRING, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
@@ -766,5 +768,6 @@ TEST(calibrate, delete_first_cube)
 int main(int argc, char *argv[]) 
 {
 	testing::InitGoogleTest(&argc, argv);
+    // testing::GTEST_FLAG(filter) = "test_register.ensure_recovery_more_faster_spreadsketch";
 	return RUN_ALL_TESTS();
 }
\ No newline at end of file
diff --git a/test/test_write_json_file.cpp b/test/test_write_json_file.cpp
index 1b5fd5f..1c6a969 100644
--- a/test/test_write_json_file.cpp
+++ b/test/test_write_json_file.cpp
@@ -71,7 +71,7 @@ static void write_hll(struct fieldstat *instance) {
 
     for(unsigned int i = 0; i < sizeof(hll_name) / sizeof(hll_name[0]); i++)
     {
-        int hll_id  = fieldstat_register_hll(instance, hll_name[i], 5);
+        int hll_id  = fieldstat_register_hll(instance, cube_id, hll_name[i], 5);
 
         for(int j = 0; j < 100; j++)
         {
@@ -112,7 +112,7 @@ void write_histogram(struct fieldstat *instance) {
 
     for(unsigned int i = 0; i < sizeof(hist_names)/sizeof(hist_names[0]); i++)
     {
-        int hist_id = fieldstat_register_hist(instance, hist_names[i], 1, 600000, 3);
+        int hist_id = fieldstat_register_hist(instance, cube_id, hist_names[i], 1, 600000, 3);
 
         for(int j = 0; j < 100; j++)
         {
@@ -188,9 +188,9 @@ void write_table(struct fieldstat *instance) {
     int cube_id = fieldstat_create_cube(instance, shared_tags, 2, 
                                           SAMPLING_MODE_COMPREHENSIVE, 100);
 
-    int counter_id_0 = fieldstat_register_counter(instance, "T_success_log");
+    int counter_id_0 = fieldstat_register_counter(instance, cube_id, "T_success_log");
 
-    int counter_id_1 = fieldstat_register_counter(instance, "T_fail_log");
+    int counter_id_1 = fieldstat_register_counter(instance, cube_id, "T_fail_log");
 
     for(unsigned int i = 0; i < sizeof(cell_tag_value)/sizeof(cell_tag_value[0]); i++)
     {