rename: dimension

7 files changed, 147 insertions, 149 deletions

diff --git a/include/fieldstat/fieldstat.h b/include/fieldstat/fieldstat.h
index b7f79a6..2de938e 100644
--- a/include/fieldstat/fieldstat.h
+++ b/include/fieldstat/fieldstat.h
@@ -60,13 +60,13 @@ struct fieldstat *fieldstat_fork(const struct fieldstat *instance);
 int fieldstat_calibrate(const struct fieldstat *master, struct fieldstat *replica);
 /*
     * @brief add an cube to this instance. Cube represents an template with a user-defined set of cells and metrics.
-    * @param cube_identifier: fields that are shared by all cells in this cube. This is the key of the cube. Can be NULL. Must be unique. Shared_tags are ordered, which means that {"TAG_KEY": "123", "TAG_KEY2": "456"} and {"TAG_KEY2": "456", "TAG_KEY": "123"} are map to different cube.
-    * @param n_field: number of shared fields.
+    * @param cube_dimensions: tags that are shared by all cells in this cube. This is the key of the cube. Can be NULL. Must be unique. Shared_tags are ordered, which means that {"TAG_KEY": "123", "TAG_KEY2": "456"} and {"TAG_KEY2": "456", "TAG_KEY": "123"} are map to different cube.
+    * @param n_dimension: number of field in dimension.
     * @param mode: sampling mode. Refer to enum sampling_mode.
     * @param max_n_cell: max number of samplings(cells) in each cube. When mode is TOPK, max_n_cell > 0, while in COMPREHENSIVE mode, max_n_cell can be 0, meaning that there is no limit.
-    * @return cube id, if success; otherwise, return FS_ERR_NULL_HANDLER, or FS_ERR_INVALID_PARAM when (max_n_cell == 0 && mode == TOPK). return FS_ERR_INVALID_KEY when the cube_identifier is not unique.
+    * @return cube id, if success; otherwise, return FS_ERR_NULL_HANDLER, or FS_ERR_INVALID_PARAM when (max_n_cell == 0 && mode == TOPK). return FS_ERR_INVALID_KEY when the cube_dimensions is not unique.
 */
-int fieldstat_create_cube(struct fieldstat *instance, const struct field *cube_identifier, size_t cube_identifier_len, enum sampling_mode mode, size_t max_n_cell);
+int fieldstat_create_cube(struct fieldstat *instance, const struct field *cube_dimensions, size_t n_dimension, enum sampling_mode mode, size_t max_n_cell);
 
 /*
     @brief Change the topk cube primary metric id. When fieldstat_counter_add or fieldstat_counter_set are called on the primary metric, the topk record of such cell will be updated.
@@ -118,14 +118,14 @@ int fieldstat_register_hist(struct fieldstat *instance, const char *metric_name,
     *           In comprehensive mode, a full cube cannot be added any more cells.
     *           In topk mode, every increment matters, so even the cube is full, the cell can also replace the least frequent cell.
 */
-int fieldstat_counter_incrby(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, long long increment);
+int fieldstat_counter_incrby(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, long long increment);
 
 /*
     * @brief let the value of counter metric equal to value. Other annotations refer to fieldstat_counter_incrby.
     * @return Refer to fieldstat_counter_incrby. What's more, be cautious to call this function if the metric is a primary metric of a topk cube,
     *   in such case, FS_ERR_INVALID_PARAM will be the output when the value is set to a smaller one(increment is negative).
 */
-int fieldstat_counter_set(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, long long value);
+int fieldstat_counter_set(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, long long value);
 
 /*
     * @brief add a key to the hll metric of cell_id. HLL approximates the number of distinct elements in a set of `key`s.
@@ -134,8 +134,8 @@ int fieldstat_counter_set(struct fieldstat *instance, int cube_id, int metric_id
     * @return FS_OK if success. FS_ERR_NULL_HANDLER, FS_ERR_INVALID_CUBE_ID, FS_ERR_INVALID_METRIC_ID if fail. 
     *         Since topk only support counter, FS_ERR_INVALID_PARAM is returned when the cube is topk.
 */
-int fieldstat_hll_add(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, const char *key, size_t key_len);
-int fieldstat_hll_add_field(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, const struct field *item, size_t item_len);
+int fieldstat_hll_add(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, const char *key, size_t key_len);
+int fieldstat_hll_add_field(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, const struct field *item, size_t item_len);
 
 
 /* 
@@ -145,7 +145,7 @@ int fieldstat_hll_add_field(struct fieldstat *instance, int cube_id, int metric_
     * @return FS_OK if success. FS_ERR_NULL_HANDLER, FS_ERR_INVALID_CUBE_ID, FS_ERR_INVALID_METRIC_ID if fail.
     *         FS_ERR_INVALID_PARAM when value is less than 0, or the cube is topk.
 */
-int fieldstat_hist_record(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, long long value);
+int fieldstat_hist_record(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, long long value);
 
 /*
     * @brief Delete all the cells, also the content of every metrics. The cube and metrics are not deleted. Increase cell_version by 1.
@@ -181,7 +181,7 @@ void fieldstat_get_cubes(const struct fieldstat *instance, int **cube_ids, int *
 */
 void fieldstat_get_metrics(const struct fieldstat *instance, 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 *fields, int **metric_id_out, size_t *n_metric_out);
+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);
@@ -190,9 +190,9 @@ const char *fieldstat_get_metric_name(const struct fieldstat *instance, int metr
 enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int metric_id);
 
 /*
-    get the fields added to cube when calling fieldstat_counter_incrby, fieldstat_counter_set, fieldstat_hll_add, fieldstat_hist_record.
+    get the cell_dimensions added to cube when calling fieldstat_counter_incrby, fieldstat_counter_set, fieldstat_hll_add, fieldstat_hist_record.
 */
-void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, struct field_list **tag_list, size_t *n_cell);
+void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, struct field_list **cell_dimensions, size_t *n_cell);
 
 /*
     get the field of fieldstat_create_cube. User free them by calling fieldstat_tag_list_arr_free(struct field_list *, 1)
@@ -201,9 +201,9 @@ void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, str
 struct field_list *fieldstat_cube_get_tags(const struct fieldstat *instance, int cube_id);
 
 /*
-    return a cube id corresponding to the shared fields. FS_ERR_INVALID_KEY is returned if the shared fields are not found.
+    return a cube id corresponding to `cube_dimensions`. FS_ERR_INVALID_KEY is returned if the cube is not found.
 */
-int fieldstat_find_cube(const struct fieldstat *instance, const struct field *cube_identifier, size_t n_shared_tags);
+int fieldstat_find_cube(const struct fieldstat *instance, const struct field *cube_dimensions, size_t n_dimensions);
 
 /* 
     get the cell numbers in a cube. Return FS_ERR_INVALID_CUBE_ID if cube_id is invalid.
@@ -214,22 +214,22 @@ int fieldstat_get_used_sampling(const struct fieldstat *instance, int cube_id);
     * @brief Get the value of a metric of a cell.
     * @param cube_id: cube id, previously returned by fieldstat_get_cubes.
     * @param metric_id: metric id, previously returned by fieldstat_get_max_metric_id.
-    * @param fields: previously returned by fieldstat_get_cells_used_by_metric.
+    * @param cell_dimensions: previously returned by fieldstat_get_cells_used_by_metric.
     * @param value_out: the value of the metric. If the cell is not found, *value_out is set to 0.
     * @return FS_OK if success. FS_ERR_NULL_HANDLER, FS_ERR_INVALID_CUBE_ID, FS_ERR_INVALID_METRIC_ID if fail.
 */
-int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, long long *value);
+int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, long long *value);
 
 /*
     @brief Get an approximate count of the number of distinct elements in the cell. Other information refer to fieldstat_counter_get.
     @return >= 0 if success. FS_ERR_INVALID_PARAM if precision is invalid.
 */
-int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, double *value);
-long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, double percentile);
-long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, long long value);
+int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, double *value);
+long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, double percentile);
+long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, long long value);
 
 // get the base 64 encoded string of the serialized blob of a cell
-void fieldstat_get_serialized_blob(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *fields, char **blob, size_t *blob_size);
+void fieldstat_get_serialized_blob(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *cell_dimensions, char **blob, size_t *blob_size);
 
 void fieldstat_tag_list_arr_free(struct field_list *tag_list, size_t n_cell);
 
diff --git a/include/fieldstat/fieldstat_easy.h b/include/fieldstat/fieldstat_easy.h
index b0b70e9..62dd5f8 100644
--- a/include/fieldstat/fieldstat_easy.h
+++ b/include/fieldstat/fieldstat_easy.h
@@ -13,9 +13,9 @@ struct fieldstat_easy;
  * new a fieldstat_easy instance.
     * @param max_thread_num: max thread number of this instance.
     * @param name: name of this instance. Will appear in output json. Can be NULL.
-    * @param fields: fields of this instance. Will appear in output json. Can be NULL.
+    * @param dimensions: dimensions of this instance. Will appear in output json. Can be NULL.
 */
-struct fieldstat_easy *fieldstat_easy_new(int max_thread_num, const char *name, const struct field *fields, size_t n_field);
+struct fieldstat_easy *fieldstat_easy_new(int max_thread_num, const char *name, const struct field *global_dimensions, size_t n_dimension);
 /*
     * free a fieldstat_easy instance.
 */
@@ -67,19 +67,19 @@ void fieldstat_easy_output_array(struct fieldstat_easy *fse, char ***json_object
 */
 int fieldstat_easy_output_array_and_reset(struct fieldstat_easy *fse, char ***json_objects, size_t *n_object);
 /*
-    * @brief let the value of counter metric of fields increase by `increment`.
+    * @brief let the value of counter metric of dimensions increase by `increment`.
     * @param thread_id: thread id. Must be in [0, max_thread_num).
     * @param metric_id: metric id, previously returned by fieldstat_easy_register_counter.
     * @param increment: increment of the counter metric. Can be negative.
     * return -1 also when the thread_id is out of range.FS_ERR_INVALID_METRIC_ID metric_id is not registered.
 */
-int fieldstat_easy_counter_incrby(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *fields, size_t n_field, long long increment);
+int fieldstat_easy_counter_incrby(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *dimensions, size_t n_dimensions, long long increment);
 /*
-    * @brief let the value of counter metric of fields equal to `value`.
+    * @brief let the value of counter metric of dimensions equal to `value`.
     *    for other notes, see fieldstat_easy_counter_incrby.
     * The value will be output by summing each ones in different threads, exactly the same as values set by fieldstat_easy_counter_incrby.
 */
-int fieldstat_easy_counter_set(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *fields, size_t n_field, long long value);
+int fieldstat_easy_counter_set(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value);
 /* 
     * @brief Add a value to the histogram metric of cell_id. Histogram will record the distribution of the values.
              The value bigger than highest_trackable_value will be set to highest_trackable_value. The value less than lowest_trackable_value will be tried to record, and, if succeed, remains in the record as -inf(most of the time) or 0(if value == 0)
@@ -87,7 +87,7 @@ int fieldstat_easy_counter_set(struct fieldstat_easy *fse, int thread_id, int me
     * @return FS_OK if success. FS_ERR_NULL_HANDLER, FS_ERR_INVALID_CUBE_ID, FS_ERR_INVALID_METRIC_ID if fail.
     * return -1 also when the thread_id is out of range.
 */
-int fieldstat_easy_histogram_record(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *fields, size_t n_field, long long value);
+int fieldstat_easy_histogram_record(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value);
 
 #ifdef __cplusplus
 }
diff --git a/src/cube.c b/src/cube.c
index dfb0198..6b1f386 100644
--- a/src/cube.c
+++ b/src/cube.c
@@ -18,8 +18,8 @@
 #define DEFAULT_N_CUBE 64
 
 struct exdata_new_args {
-    const struct field *fields;
-    size_t n_tags;
+    const struct field *cell_dimensions;
+    size_t n_dimensions;
 };
 
 struct cube_manager {
@@ -34,7 +34,7 @@ struct cell {
     struct metric **metrics;
     size_t metrics_len;
     size_t max_n_metric;
-    struct field_list fields; // cell identifier
+    struct field_list cell_dimensions;
 };
 
 struct cube {
@@ -45,41 +45,40 @@ struct cube {
     };
     size_t max_n_cell;
 
-    // the key of cube is the combination of shared fields
-    struct field *cube_identifier;
-    size_t n_shared_tags;
+    struct field *cube_dimensions;
+    size_t n_dimensions;
 
     int primary_metric_id;
-    char *key;
+    char *key;     // the key of cube is the combination of cube_dimensions
     size_t key_len;
     int id;
     UT_hash_handle hh;
 };
 
-static struct field *tag_array_duplicate(const struct field *tags_src, size_t n_field)
+static struct field *field_array_duplicate(const struct field *fields_src, size_t n_field)
 {
-    struct field *tags_dst = malloc(sizeof(struct field) * n_field);
+    struct field *ret = malloc(sizeof(struct field) * 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)
+        ret[i].key = strdup(fields_src[i].key);
+        ret[i].type = fields_src[i].type;
+        switch (fields_src[i].type)
         {
         case TAG_INTEGER:
-            tags_dst[i].value_longlong = tags_src[i].value_longlong;
+            ret[i].value_longlong = fields_src[i].value_longlong;
             break;
         case TAG_CSTRING:
-            tags_dst[i].value_str = strdup(tags_src[i].value_str);
+            ret[i].value_str = strdup(fields_src[i].value_str);
             break;
         case TAG_DOUBLE:
-            tags_dst[i].value_double = tags_src[i].value_double;
+            ret[i].value_double = fields_src[i].value_double;
             break;
         default:
             break;
         }
     }
 
-    return tags_dst;
+    return ret;
 }
 
 static void fieldstat_free_tag_array(struct field *fields, size_t n_tags)
@@ -134,7 +133,7 @@ struct cube_manager *cube_manager_new() {
     return pthis;
 }
 
-static int tags2key_safe(const struct field fields[], size_t n_tags, char *out_key, size_t out_key_size)
+static int field_array_to_key_safe(const struct field fields[], size_t n_tags, char *out_key, size_t out_key_size)
 {
     if (n_tags == 0) {
         const char dummy[] = "no fields";
@@ -191,7 +190,7 @@ static int tags2key_safe(const struct field fields[], size_t n_tags, char *out_k
     return out_key_size - remain_key_size;
 }
 
-static void tags2key_endeavor(const struct field fields[], size_t n_tags, char **out_key, size_t *out_key_size)
+static void field_array_to_key_endeavor(const struct field fields[], size_t n_tags, char **out_key, size_t *out_key_size)
 {
     if (n_tags == 0) {
         // use a default dummy key
@@ -297,16 +296,16 @@ void cube_manager_delete(struct cube_manager *pthis, struct cube *cube)
     }
 }
 
-int cube_manager_find(const struct cube_manager *pthis, const struct field *identifier, size_t n_field)
+int cube_manager_find(const struct cube_manager *pthis, const struct field *cube_dimensions, size_t n_dimension)
 {
     char key_stack[4096];
     char *key = key_stack;
-    int key_len = tags2key_safe(identifier, n_field, key, sizeof(key));
+    int key_len = field_array_to_key_safe(cube_dimensions, n_dimension, key, sizeof(key));
     bool free_key = false;
     if (key_len < 0) {  // very unlikely to happen
         char *key_heap;
         size_t key_len_tmp;
-        tags2key_endeavor(identifier, n_field, &key_heap, &key_len_tmp);
+        field_array_to_key_endeavor(cube_dimensions, n_dimension, &key_heap, &key_len_tmp);
         key = key_heap;
         key_len = key_len_tmp;
         free_key = true;
@@ -452,8 +451,8 @@ struct cell *cell_new(const struct exdata_new_args *args) {
     pthis->max_n_metric = DEFAULT_N_METRIC;
     pthis->metrics_len = 0;
 
-    pthis->fields.n_field = args->n_tags;
-    pthis->fields.field = tag_array_duplicate(args->fields, args->n_tags);
+    pthis->cell_dimensions.n_field = args->n_dimensions;
+    pthis->cell_dimensions.field = field_array_duplicate(args->cell_dimensions, args->n_dimensions);
     return pthis;
 }
 
@@ -462,13 +461,13 @@ void cell_free(struct cell *pthis) {
         metric_free(pthis->metrics[i]);
     }
     free(pthis->metrics);
-    for (size_t i = 0; i < pthis->fields.n_field; i++) {
-        free((char *)pthis->fields.field[i].key);
-        if (pthis->fields.field[i].type == TAG_CSTRING) {
-            free((char *)pthis->fields.field[i].value_str);
+    for (size_t i = 0; i < pthis->cell_dimensions.n_field; i++) {
+        free((char *)pthis->cell_dimensions.field[i].key);
+        if (pthis->cell_dimensions.field[i].type == TAG_CSTRING) {
+            free((char *)pthis->cell_dimensions.field[i].value_str);
         }
     }
-    free(pthis->fields.field);
+    free(pthis->cell_dimensions.field);
     free(pthis);
 }
 
@@ -485,8 +484,8 @@ struct cell *cell_copy(const struct cell *src) {
         pthis->metrics[i] = metric_copy(src->metrics[i]);
     }
     
-    pthis->fields.n_field = src->fields.n_field;
-    pthis->fields.field = tag_array_duplicate(src->fields.field, src->fields.n_field);
+    pthis->cell_dimensions.n_field = src->cell_dimensions.n_field;
+    pthis->cell_dimensions.field = field_array_duplicate(src->cell_dimensions.field, src->cell_dimensions.n_field);
 
     return pthis;
 }
@@ -537,29 +536,29 @@ void *exdata_copy_i(void *exdata) {
     return cell_copy((struct cell *)exdata);
 }
 
-struct cube *cube_info_new(const struct field *shared_tags, size_t n_field, enum sampling_mode mode, size_t max_n_cell)
+struct cube *cube_info_new(const struct field *dimensions, size_t n_dimensions, enum sampling_mode mode, size_t max_n_cell)
 {
     struct cube *cube = calloc(1, sizeof(struct cube));
     cube->sampling_mode = mode;
 
-    if (n_field == 0) {
-        cube->cube_identifier = NULL;
+    if (n_dimensions == 0) {
+        cube->cube_dimensions = NULL;
     } else {
-        cube->cube_identifier = tag_array_duplicate(shared_tags, n_field);
+        cube->cube_dimensions = field_array_duplicate(dimensions, n_dimensions);
     }
 
-    cube->n_shared_tags = n_field;
+    cube->n_dimensions = n_dimensions;
     cube->max_n_cell = max_n_cell;
-    tags2key_endeavor(shared_tags, n_field, &cube->key, &cube->key_len);
+    field_array_to_key_endeavor(dimensions, n_dimensions, &cube->key, &cube->key_len);
 
     cube->id = -1;
 
     return cube;
 }
 
-struct cube *cube_new(const struct field *shared_tags, size_t n_field, enum sampling_mode mode, size_t max_n_cell)
+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(shared_tags, n_field, mode, max_n_cell);
+    struct cube *cube = cube_info_new(dimensions, n_dimensions, mode, max_n_cell);
 
     switch (mode)
     {
@@ -593,7 +592,7 @@ void cube_free(struct cube *cube) {
         break;
     }
 
-    fieldstat_free_tag_array(cube->cube_identifier, cube->n_shared_tags);
+    fieldstat_free_tag_array(cube->cube_dimensions, cube->n_dimensions);
     free(cube->key);
 
     free(cube);
@@ -611,23 +610,23 @@ void cube_set_primary_metric(struct cube *cube, int metric_id) {
     cube->primary_metric_id = metric_id;
 }
 
-struct cell *get_cell(struct cube *cube, const struct field *fields, size_t n_field,long long increment, int metric_id) {
+struct cell *get_cell(struct cube *cube, const struct field *dimensions, size_t n_dimension, long long increment, int metric_id) {
     char key_stack[4096];
     char *key = key_stack;
-    int key_len = tags2key_safe(fields, n_field, key, sizeof(key));
+    int key_len = field_array_to_key_safe(dimensions, n_dimension, key, sizeof(key));
     bool free_key = false;
     if (key_len < 0) {  // very unlikely to happen
         char *key_heap;
         size_t key_len_tmp;
-        tags2key_endeavor(fields, n_field, &key_heap, &key_len_tmp);
+        field_array_to_key_endeavor(dimensions, n_dimension, &key_heap, &key_len_tmp);
         key = key_heap;
         key_len = key_len_tmp;
         free_key = true;
     }
 
     struct exdata_new_args args;
-    args.fields = fields;
-    args.n_tags = n_field;
+    args.cell_dimensions = dimensions;
+    args.n_dimensions = n_dimension;
 
     struct cell *cell_data = NULL;
     switch (cube->sampling_mode) {
@@ -665,11 +664,11 @@ struct cell *get_cell(struct cube *cube, const struct field *fields, size_t n_fi
     return cell_data;
 }
 
-int cube_histogram_record(struct cube *cube, const struct metric_manifest *manifest, const struct field *fields, size_t n_field, long long value) {
+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));
 
-    struct cell *cell_data = get_cell(cube, fields, n_field, 0, manifest->id);
+    struct cell *cell_data = get_cell(cube, dimensions, n_dimensions, 0, manifest->id);
     if (cell_data == NULL) {
         return FS_ERR_TOO_MANY_CELLS;
     }
@@ -682,11 +681,11 @@ 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 *fields, size_t n_field, const char *key, size_t key_len) {
+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_COMPREHENSIVE || (cube->primary_metric_id != manifest->id));
 
-    struct cell *cell_data = get_cell(cube, fields, n_field, 0, manifest->id);
+    struct cell *cell_data = get_cell(cube, dimensions, n_dimensions, 0, manifest->id);
     if (cell_data == NULL) {
         return FS_ERR_TOO_MANY_CELLS;
     }
@@ -696,11 +695,11 @@ int cube_hll_add(struct cube *cube, const struct metric_manifest *manifest, cons
     return FS_OK;
 }
 
-uint64_t tags2hash(const struct field *field, size_t n_field) {
+uint64_t tags2hash(const struct field *field, size_t n_dimensions) {
     XXH3_state_t state = {0};
     XXH3_64bits_reset(&state);
 
-    for (int i = 0; i < n_field; i++) {
+    for (int i = 0; i < n_dimensions; i++) {
         XXH3_64bits_update(&state, field[i].key, strlen(field[i].key));
         if (field[i].type != TAG_CSTRING) {
             XXH3_64bits_update(&state, &field[i].value_longlong, sizeof(long long));
@@ -712,12 +711,12 @@ uint64_t tags2hash(const struct field *field, size_t n_field) {
     return XXH3_64bits_digest(&state);
 }
 
-int cube_hll_add_tag(struct cube *cube, const struct metric_manifest *manifest, const struct field *fields, size_t n_field, const struct field *tags_key, size_t n_tag_key) 
+int cube_hll_add_tag(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) 
 {
     assert(manifest->type == METRIC_TYPE_HLL);
     assert(cube->sampling_mode != SAMPLING_MODE_TOPK || (cube->primary_metric_id != manifest->id));
 
-    struct cell *cell_data = get_cell(cube, fields, n_field, 0, manifest->id);
+    struct cell *cell_data = get_cell(cube, dimensions, n_dimensions, 0, manifest->id);
     if (cell_data == NULL) {
         return FS_ERR_TOO_MANY_CELLS;
     }
@@ -728,11 +727,11 @@ int cube_hll_add_tag(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 *fields, size_t n_field, long long increment) {
+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);
     assert(cube->sampling_mode == SAMPLING_MODE_COMPREHENSIVE || (cube->primary_metric_id != manifest->id || increment >= 0));
 
-    struct cell *cell_data = get_cell(cube, fields, n_field, increment, manifest->id);
+    struct cell *cell_data = get_cell(cube, dimensions, n_dimensions, increment, manifest->id);
     if (cell_data == NULL) {
         return FS_ERR_TOO_MANY_CELLS;
     }
@@ -743,11 +742,11 @@ 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 *fields, size_t n_field, long long value) {
+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));
 
-    struct cell *cell_data = get_cell(cube, fields, n_field, 0, manifest->id);
+    struct cell *cell_data = get_cell(cube, dimensions, n_dimensions, 0, manifest->id);
     if (cell_data == NULL) {
         return FS_ERR_TOO_MANY_CELLS;
     }
@@ -759,7 +758,7 @@ int cube_counter_set(struct cube *cube, const struct metric_manifest *manifest,
 
 struct cube *cube_copy(const struct cube *cube)
 {
-    struct cube *cube_dup = cube_info_new(cube->cube_identifier, cube->n_shared_tags, cube->sampling_mode, cube->max_n_cell);
+    struct cube *cube_dup = cube_info_new(cube->cube_dimensions, cube->n_dimensions, cube->sampling_mode, cube->max_n_cell);
     cube_dup->primary_metric_id = cube->primary_metric_id;
 
     switch (cube->sampling_mode)
@@ -797,13 +796,13 @@ void cube_merge(struct cube *dest, const struct cube *src)
 }
 
 struct cube *cube_fork(const struct cube *cube) {
-    struct cube *ret = cube_new(cube->cube_identifier, cube->n_shared_tags, cube->sampling_mode, cube->max_n_cell);
+    struct cube *ret = cube_new(cube->cube_dimensions, cube->n_dimensions, cube->sampling_mode, cube->max_n_cell);
     ret->primary_metric_id = cube->primary_metric_id;
 
     return ret;
 }
 
-void cube_get_cells(const struct cube *cube, struct field_list **tag_list, size_t *n_cell)
+void cube_get_cells(const struct cube *cube, struct field_list **cell_dimensions, size_t *n_cell)
 {
     size_t n_cell_tmp = 0;
     switch (cube->sampling_mode) {
@@ -818,7 +817,7 @@ void cube_get_cells(const struct cube *cube, struct field_list **tag_list, size_
     }
 
     if (n_cell_tmp == 0) {
-        *tag_list = NULL;
+        *cell_dimensions = NULL;
         *n_cell = 0;
         return;
     }
@@ -836,18 +835,18 @@ void cube_get_cells(const struct cube *cube, struct field_list **tag_list, size_
     }
 
     struct field_list *tag_list_ret = (struct field_list *)malloc(sizeof(struct field_list) * n_cell_tmp);
-    *tag_list = tag_list_ret;
+    *cell_dimensions = tag_list_ret;
     *n_cell = n_cell_tmp;
 
     for (int i = 0; i < n_cell_tmp; i++) {
         struct cell *cell_data = cell_datas[i];
         struct field_list *tag_list_tmp = &tag_list_ret[i];
-        tag_list_tmp->n_field = cell_data->fields.n_field;
+        tag_list_tmp->n_field = cell_data->cell_dimensions.n_field;
         if (tag_list_tmp->n_field == 0) {
             tag_list_tmp->field = NULL;
             continue;
         }
-        tag_list_tmp->field = tag_array_duplicate(cell_data->fields.field, tag_list_tmp->n_field);
+        tag_list_tmp->field = field_array_duplicate(cell_data->cell_dimensions.field, tag_list_tmp->n_field);
     }
 
     free(cell_datas);
@@ -858,7 +857,7 @@ const struct cell *get_cell_by_tag_list(const struct cube *cube, const struct fi
     const struct cell *ret = NULL;
     char *tag_in_string;
     size_t tag_len;
-    tags2key_endeavor(fields->field, fields->n_field, &tag_in_string, &tag_len);
+    field_array_to_key_endeavor(fields->field, fields->n_field, &tag_in_string, &tag_len);
 
     switch (cube->sampling_mode)
     {
@@ -1001,14 +1000,14 @@ void cube_get_cells_used_by_metric(const struct cube *cube, const struct field_l
 struct field_list *cube_get_identifier(const struct cube *cube) {
     struct field_list *tag_list = (struct field_list *)malloc(sizeof(struct field_list));
 
-    if (cube->n_shared_tags == 0) {
+    if (cube->n_dimensions == 0) {
         tag_list->field = NULL;
         tag_list->n_field = 0;
         return tag_list;
     }
 
-    tag_list->field = tag_array_duplicate(cube->cube_identifier, cube->n_shared_tags);
-    tag_list->n_field = cube->n_shared_tags;
+    tag_list->field = field_array_duplicate(cube->cube_dimensions, cube->n_dimensions);
+    tag_list->n_field = cube->n_dimensions;
     
 
     return tag_list;
diff --git a/src/cube.h b/src/cube.h
index 1ac4b4d..2b08530 100644
--- a/src/cube.h
+++ b/src/cube.h
@@ -7,34 +7,34 @@ extern "C"
 
 #include <stddef.h>
 #include <stdbool.h>
-#include "fieldstat.h" // for fields
+#include "fieldstat.h" // for dimensions
 #include "metric_manifest.h"
 
 struct cube;
 struct cube_manager;
 
-struct cube *cube_new(const struct field *shared_tags, size_t n_field, enum sampling_mode mode, size_t max_n_cell);
+struct cube *cube_new(const struct field *dimensions, size_t n_dimensions, enum sampling_mode mode, size_t max_n_cell);
 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);
 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 *fields, size_t n_field, long long value);
-int cube_hll_add(struct cube *cube, const struct metric_manifest *manifest, const struct field *fields, size_t n_field, const char *key, size_t key_len);
-int cube_hll_add_tag(struct cube *cube, const struct metric_manifest *manifest, const struct field *fields, size_t n_field, 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 *fields, size_t n_field, long long increment);
-int cube_counter_set(struct cube *cube, const struct metric_manifest *manifest, const struct field *fields, size_t n_field, long long value);
+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_tag(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_counter_get(const struct cube *cube, int metric_id, const struct field_list *fields, long long *value);
-int cube_hll_get(const struct cube *cube, int metric_id, const struct field_list *fields, double *value);
-int cube_histogram_value_at_percentile(const struct cube *cube, int metric_id, const struct field_list *fields, double percentile, long long *value);
-int cube_histogram_count_le_value(const struct cube *cube, int metric_id, const struct field_list *fields, long long value, long long *count);
-int cube_get_serialization(const struct cube *cube, int metric_id, const struct field_list *fields, char **blob, size_t *blob_size);
+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);
+int cube_histogram_count_le_value(const struct cube *cube, int metric_id, const struct field_list *dimensions, long long value, long long *count);
+int cube_get_serialization(const struct cube *cube, int metric_id, const struct field_list *dimensions, char **blob, size_t *blob_size);
 
 int cube_get_cell_count(const struct cube *cube);
 void cube_get_cells(const struct cube *cube, struct field_list **tag_list, size_t *n_cell);
-void cube_get_cells_used_by_metric(const struct cube *cube, const struct field_list *fields, int **metric_id_out, size_t *n_metric_out);
+void cube_get_cells_used_by_metric(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);
 struct field_list *cube_get_identifier(const struct cube *cube);
 
@@ -43,7 +43,7 @@ struct cube *cube_manager_get_cube_by_id(const struct cube_manager *manager, int
 // the cube will be taken over by the manager, user do not free it.
 int cube_manager_add(struct cube_manager *pthis, struct cube *cube);
 void cube_manager_delete(struct cube_manager *pthis, struct cube *cube); // the cube will be freed by the manager
-int cube_manager_find(const struct cube_manager *pthis, const struct field *identifier, size_t n_field);
+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);
diff --git a/src/fieldstat.c b/src/fieldstat.c
index 4e3a103..abf3e91 100644
--- a/src/fieldstat.c
+++ b/src/fieldstat.c
@@ -162,15 +162,15 @@ void fieldstat_free_tag_array(struct field *fields, size_t n_tags)
     free(fields);
 }
 
-int fieldstat_create_cube(struct fieldstat *instance, const struct field *cube_identifier, size_t cube_identifier_len, enum sampling_mode mode, size_t max_n_cell)
+int fieldstat_create_cube(struct fieldstat *instance, const struct field *cube_dimensions, size_t n_dimension, enum sampling_mode mode, size_t max_n_cell)
 {
     if (instance == NULL) {
         return  FS_ERR_NULL_HANDLER;
     }
 
-    if (cube_identifier_len == 0 || cube_identifier == NULL) {
-        cube_identifier = NULL;
-        cube_identifier_len = 0;
+    if (n_dimension == 0 || cube_dimensions == NULL) {
+        cube_dimensions = NULL;
+        n_dimension = 0;
     }
     if (mode == SAMPLING_MODE_TOPK && max_n_cell == 0) {
         return FS_ERR_INVALID_PARAM;
@@ -179,7 +179,7 @@ int fieldstat_create_cube(struct fieldstat *instance, const struct field *cube_i
         max_n_cell = INT32_MAX;
     }
     
-    struct cube *cube = cube_new(cube_identifier, cube_identifier_len, mode, max_n_cell);
+    struct cube *cube = cube_new(cube_dimensions, n_dimension, mode, max_n_cell);
     int ret = cube_manager_add(instance->cube_manager, cube);
     if (ret < 0) {
         cube_free(cube);
@@ -295,7 +295,7 @@ int fieldstat_register_hist(struct fieldstat *instance, const char *metric_name,
 /* -------------------------------------------------------------------------- */
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
-int fieldstat_counter_incrby(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, long long increment)
+int fieldstat_counter_incrby(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, long long increment)
 {
     struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -306,11 +306,11 @@ int fieldstat_counter_incrby(struct fieldstat *instance, int cube_id, int metric
         return FS_ERR_INVALID_METRIC_ID;
     }
     
-    return cube_counter_incrby(cube, manifest, fields, n_fields, increment);
+    return cube_counter_incrby(cube, manifest, cell_dimensions, n_dimensions, increment);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
-int fieldstat_counter_set(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, long long value)
+int fieldstat_counter_set(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, long long value)
 {
     struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -321,11 +321,11 @@ int fieldstat_counter_set(struct fieldstat *instance, int cube_id, int metric_id
         return FS_ERR_INVALID_METRIC_ID;
     }
 
-    return cube_counter_set(cube, manifest, fields, n_fields, value);
+    return cube_counter_set(cube, manifest, cell_dimensions, n_dimensions, value);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
-int fieldstat_hll_add(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, const char *key, size_t key_len)
+int fieldstat_hll_add(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, const char *key, size_t key_len)
 {
     struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -336,11 +336,11 @@ int fieldstat_hll_add(struct fieldstat *instance, int cube_id, int metric_id, co
         return FS_ERR_INVALID_METRIC_ID;
     }
 
-    return cube_hll_add(cube, manifest, fields, n_fields, key, key_len);
+    return cube_hll_add(cube, manifest, cell_dimensions, n_dimensions, key, key_len);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
-int fieldstat_hll_add_field(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, const struct field *item, size_t item_len)
+int fieldstat_hll_add_field(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, const struct field *item, size_t item_len)
 {
     struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -351,11 +351,11 @@ int fieldstat_hll_add_field(struct fieldstat *instance, int cube_id, int metric_
         return FS_ERR_INVALID_METRIC_ID;
     }
 
-    return cube_hll_add_tag(cube, manifest, fields, n_fields, item, item_len);
+    return cube_hll_add_tag(cube, manifest, cell_dimensions, n_dimensions, item, item_len);
 }
 
 // cppcheck-suppress [constParameterPointer, unmatchedSuppression]
-int fieldstat_hist_record(struct fieldstat *instance, int cube_id, int metric_id, const struct field *fields, size_t n_fields, long long value)
+int fieldstat_hist_record(struct fieldstat *instance, int cube_id, int metric_id, const struct field *cell_dimensions, size_t n_dimensions, long long value)
 {
     struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -366,7 +366,7 @@ int fieldstat_hist_record(struct fieldstat *instance, int cube_id, int metric_id
         return FS_ERR_INVALID_METRIC_ID;
     }
 
-    return cube_histogram_record(cube, manifest, fields, n_fields, value);
+    return cube_histogram_record(cube, manifest, cell_dimensions, n_dimensions, value);
 }
 
 int fieldstat_merge(struct fieldstat *instance, const struct fieldstat *src)
@@ -454,36 +454,36 @@ struct field_list *fieldstat_cube_get_tags(const struct fieldstat *instance, int
     return cube_get_identifier(cube);
 }
 
-int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, long long *value)
+int fieldstat_counter_get(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, long long *value)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
     
-    return cube_counter_get(cube, metric_id, fields, value);
+    return cube_counter_get(cube, metric_id, cell_dimensions, value);
 }
 
-int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, double *value)
+int fieldstat_hll_get(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, double *value)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
     
-    int ret = cube_hll_get(cube, metric_id, fields, value);
+    int ret = cube_hll_get(cube, metric_id, cell_dimensions, value);
 
     return ret;
 }
 
-long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, double percentile)
+long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, double percentile)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
     long long value;
-    int ret = cube_histogram_value_at_percentile(cube, metric_id, fields, percentile, &value);
+    int ret = cube_histogram_value_at_percentile(cube, metric_id, cell_dimensions, percentile, &value);
     if (ret < 0) {
         return ret;
     }
@@ -491,21 +491,21 @@ long long fieldstat_hist_value_at_percentile(const struct fieldstat *instance, i
     return value;
 }
 
-long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int metric_id, long long value)
+long long fieldstat_hist_count_le_value(const struct fieldstat *instance, int cube_id, const struct field_list *cell_dimensions, int metric_id, long long value)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
         return FS_ERR_INVALID_CUBE_ID;
     }
     long long count;
-    int ret = cube_histogram_count_le_value(cube, metric_id, fields, value, &count);
+    int ret = cube_histogram_count_le_value(cube, metric_id, cell_dimensions, value, &count);
     if (ret < 0) {
         return ret;
     }
     return count;
 }
 
-void fieldstat_get_serialized_blob(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *fields, char **blob, size_t *blob_size)
+void fieldstat_get_serialized_blob(const struct fieldstat *instance, int cube_id, int metric_id, const struct field_list *cell_dimensions, char **blob, size_t *blob_size)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
@@ -514,7 +514,7 @@ void fieldstat_get_serialized_blob(const struct fieldstat *instance, int cube_id
         return;
     }
 
-    cube_get_serialization(cube, metric_id, fields, blob, blob_size);
+    cube_get_serialization(cube, metric_id, cell_dimensions, blob, blob_size);
 }
 
 void fieldstat_tag_list_arr_free(struct field_list *tag_list, size_t n_cell)
@@ -548,14 +548,14 @@ enum metric_type fieldstat_get_metric_type(const struct fieldstat *instance, int
     return metric->type;
 }
 
-void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, struct field_list **tag_list, size_t *n_cell)
+void fieldstat_cube_get_cells(const struct fieldstat *instance, int cube_id, struct field_list **cell_dimensions, size_t *n_cell)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
     if (cube == NULL) {
         return;
     }
     
-    cube_get_cells(cube, tag_list, n_cell);
+    cube_get_cells(cube, cell_dimensions, n_cell);
 }
 
 int fieldstat_get_used_sampling(const struct fieldstat *instance, int cube_id)
@@ -572,13 +572,13 @@ int fieldstat_get_used_sampling(const struct fieldstat *instance, int cube_id)
     return cube_get_cell_count(cube);
 }
 
-int fieldstat_find_cube(const struct fieldstat *instance, const struct field *shared_tags, size_t n_shared_tags)
+int fieldstat_find_cube(const struct fieldstat *instance, const struct field *cube_dimensions, size_t n_dimensions)
 {
     if (instance == NULL) {
         return FS_ERR_NULL_HANDLER;
     }
 
-    int cube_id = cube_manager_find(instance->cube_manager, shared_tags, n_shared_tags);
+    int cube_id = cube_manager_find(instance->cube_manager, cube_dimensions, n_dimensions);
     if (cube_id == -1) {
         return FS_ERR_INVALID_KEY;
     }
@@ -586,8 +586,8 @@ int fieldstat_find_cube(const struct fieldstat *instance, const struct field *sh
     return cube_id;
 }
 
-void fieldstat_get_metric_in_cell(const struct fieldstat *instance, int cube_id, const struct field_list *fields, int **metric_id_out, size_t *n_metric_out)
+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)
 {
     const struct cube *cube = cube_manager_get_cube_by_id(instance->cube_manager, cube_id);
-    return cube_get_cells_used_by_metric(cube, fields, metric_id_out, n_metric_out);
+    return cube_get_cells_used_by_metric(cube, cell_dimensions, metric_id_out, n_metric_out);
 }
\ No newline at end of file
diff --git a/src/fieldstat_easy.c b/src/fieldstat_easy.c
index 0e70a1c..b5f811c 100644
--- a/src/fieldstat_easy.c
+++ b/src/fieldstat_easy.c
@@ -114,7 +114,7 @@ void *fs_easy_output_thread(void *arg) // return void * for pthread_create check
     return NULL; // return void * for pthread_create check only
 }
 
-struct fieldstat_easy *fieldstat_easy_new(int max_thread_num, const char *name, const struct field *fields, size_t n_field) {
+struct fieldstat_easy *fieldstat_easy_new(int max_thread_num, const char *name, const struct field *global_dimensions, size_t n_dimension) {
     if (max_thread_num <= 0) {
         return NULL;
     }
@@ -126,8 +126,8 @@ struct fieldstat_easy *fieldstat_easy_new(int max_thread_num, const char *name,
 
     fse->accumulate = fieldstat_fork(fse->delta);
     fse->exporter = fieldstat_json_exporter_new();
-    if (fields != NULL && n_field > 0) {
-        fieldstat_json_exporter_set_global_tag(fse->exporter, fields, n_field);
+    if (global_dimensions != NULL && n_dimension > 0) {
+        fieldstat_json_exporter_set_global_tag(fse->exporter, global_dimensions, n_dimension);
     }
     if (name != NULL) {
         fieldstat_json_exporter_set_name(fse->exporter, name);
@@ -312,7 +312,7 @@ int fieldstat_easy_output_array_and_reset(struct fieldstat_easy *fse, char ***js
     return 0;
 }
 
-int fieldstat_easy_counter_incrby(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *fields, size_t n_field, long long increment)
+int fieldstat_easy_counter_incrby(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *dimensions, size_t n_dimensions, long long increment)
 {
     if (thread_id < 0) {
         return -1;
@@ -322,13 +322,13 @@ int fieldstat_easy_counter_incrby(struct fieldstat_easy *fse, int thread_id, int
     }
 
     pthread_spin_lock(&fse->fsu[thread_id].lock);
-    int ret = fieldstat_counter_incrby(fse->fsu[thread_id].active, 0, metric_id, fields, n_field, increment);
+    int ret = fieldstat_counter_incrby(fse->fsu[thread_id].active, 0, metric_id, dimensions, n_dimensions, increment);
     pthread_spin_unlock(&fse->fsu[thread_id].lock);
 
     return ret;
 }
 
-int fieldstat_easy_counter_set(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *fields, size_t n_field, long long value)
+int fieldstat_easy_counter_set(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value)
 {
     if (thread_id < 0) {
         return -1;
@@ -338,13 +338,13 @@ int fieldstat_easy_counter_set(struct fieldstat_easy *fse, int thread_id, int me
     }
 
     pthread_spin_lock(&fse->fsu[thread_id].lock);
-    int ret = fieldstat_counter_set(fse->fsu[thread_id].active, 0, metric_id, fields, n_field, value);
+    int ret = fieldstat_counter_set(fse->fsu[thread_id].active, 0, metric_id, dimensions, n_dimensions, value);
     pthread_spin_unlock(&fse->fsu[thread_id].lock);
 
     return ret;
 }
 
-int fieldstat_easy_histogram_record(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *fields, size_t n_field, long long value)
+int fieldstat_easy_histogram_record(struct fieldstat_easy *fse, int thread_id, int metric_id, const struct field *dimensions, size_t n_dimensions, long long value)
 {
     if (thread_id < 0) {
         return -1;
@@ -354,7 +354,7 @@ int fieldstat_easy_histogram_record(struct fieldstat_easy *fse, int thread_id, i
     }
 
     pthread_spin_lock(&fse->fsu[thread_id].lock);
-    int ret = fieldstat_hist_record(fse->fsu[thread_id].active, 0, metric_id, fields, n_field, value);
+    int ret = fieldstat_hist_record(fse->fsu[thread_id].active, 0, metric_id, dimensions, n_dimensions, value);
     pthread_spin_unlock(&fse->fsu[thread_id].lock);
 
     return ret;
diff --git a/src/tags/heavy_keeper.h b/src/tags/heavy_keeper.h
index 0ed2709..5bc8376 100644
--- a/src/tags/heavy_keeper.h
+++ b/src/tags/heavy_keeper.h
@@ -34,7 +34,6 @@ void *heavy_keeper_get0_exdata(const struct heavy_keeper *hk, const char *key, s
 int heavy_keeper_get_count(const struct heavy_keeper *hk);
 
 size_t heavy_keeper_list(const struct heavy_keeper *hk, void **exdatas, size_t n_exdatas);
-// void heavy_keeper_list(const struct heavy_keeper *hk, void ***exdatas, size_t *n_exdatas); 
 
 void heavy_keeper_merge(struct heavy_keeper *dest, const struct heavy_keeper *src);