larger ut hash table to fasten hash

2 files changed, 799 insertions, 3 deletions

diff --git a/test/perfs.cpp b/test/perfs.cpp
new file mode 100644
index 0000000..908713b
--- /dev/null
+++ b/test/perfs.cpp
@@ -0,0 +1,796 @@
+#include <gtest/gtest.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "utils.hpp"
+
+#include "fieldstat_easy.h"
+#include "fieldstat.h"
+
+
+void fill_with_elephant_flows(Fieldstat_tag_list_wrapper *fields[], int tag_list_num)
+{
+    for (int i = 0; i < tag_list_num; i++)
+    {
+        Fieldstat_tag_list_wrapper *tmp;
+        int rand_ret = rand() % 10;
+        if (rand_ret < 5) {
+            tmp = new Fieldstat_tag_list_wrapper("elephant", rand() % 50); // most hit
+        } else if (rand_ret == 6 || rand_ret == 7) {
+            tmp = new Fieldstat_tag_list_wrapper("mid", rand() % 200);
+        } else {
+            tmp = new Fieldstat_tag_list_wrapper("mouse", rand() % 10000);
+        }
+        fields[i] = tmp;
+    }
+}
+
+
+TEST(perf, simple_one_for_perf_topk)
+{
+    const int CUBE_NUM = 5;
+    const int FLOW_NUM = 50000;
+    const int CELL_MAX = 50;
+    const int TEST_ROUND = 500000;
+    struct fieldstat *master = fieldstat_new();
+    
+    Fieldstat_tag_list_wrapper *shared_tags[CUBE_NUM];
+
+    // init cube
+    for (int i = 0; i < CUBE_NUM; i++) {
+        shared_tags[i] = new Fieldstat_tag_list_wrapper("shared_tag", i);
+        int cube_id = fieldstat_cube_create(master, shared_tags[i]->get_tag(), shared_tags[i]->get_tag_count());
+        EXPECT_EQ(cube_id, i);
+        fieldstat_register_counter(master, cube_id, "topk");
+        fieldstat_cube_set_sampling(master, cube_id, SAMPLING_MODE_TOPK, CELL_MAX, 0);
+    }
+    // init metric
+    
+    // all the possible fields
+    Fieldstat_tag_list_wrapper *tag_list_wrapper[FLOW_NUM];
+    fill_with_elephant_flows(tag_list_wrapper, FLOW_NUM);
+    //all the possible operations
+    long long *rand_nums = new long long[TEST_ROUND];
+    for (int i = 0; i < TEST_ROUND; i++) {
+        rand_nums[i] = rand() % 1000;
+    }
+
+    struct fieldstat *instance = master;
+
+    clock_t start = clock();
+    printf("press any key to start v46\n");
+    getchar();
+
+    for (int i = 0; i < TEST_ROUND; i++) {
+        
+        const Fieldstat_tag_list_wrapper * field = tag_list_wrapper[rand() % FLOW_NUM];
+        int cube_id = rand() % CUBE_NUM;
+
+        (void)fieldstat_counter_incrby(instance, cube_id, 0, field->get_tag(), field->get_tag_count(), rand_nums[i]);
+    }
+
+    clock_t end = clock();
+    printf("time: %lf\n", (double)(end - start) / CLOCKS_PER_SEC);
+
+    for (int i = 0; i < FLOW_NUM; i++) {
+        delete tag_list_wrapper[i];
+    }
+    for (int i = 0; i < CUBE_NUM; i++) {
+        delete shared_tags[i];
+    }
+    delete[] rand_nums;
+    fieldstat_free(master);
+}
+
+TEST(perf, simple_one_for_perf_spreadsketch)
+{
+    const int CELL_MAX = 100;
+    const int TEST_ROUND = 500000;
+    struct fieldstat *instance = fieldstat_new();
+    
+    int cube_id = fieldstat_cube_create(instance, &TEST_FIELD_STRING, 1);
+    fieldstat_register_hll(instance, cube_id, "hll", 6);
+    fieldstat_cube_set_sampling(instance, cube_id, SAMPLING_MODE_TOP_CARDINALITY, CELL_MAX, 0);
+
+    SpreadSketchZipfGenerator generator(1.0, CELL_MAX * 10);
+    Fieldstat_tag_list_wrapper *cell_dimension[TEST_ROUND];
+    Fieldstat_tag_list_wrapper *items[TEST_ROUND];
+    for (int i = 0; i < TEST_ROUND; i++) {
+        Flow flow = generator.next();
+        cell_dimension[i] = new Fieldstat_tag_list_wrapper("src_ip", flow.src_ip.c_str());
+        items[i] = new Fieldstat_tag_list_wrapper("dst_ip", flow.dst_ip.c_str());
+    }
+
+    clock_t start = clock();
+    printf("press any key to start \n");
+    getchar();
+
+    for (int i = 0; i < TEST_ROUND; i++) {
+        fieldstat_hll_add_fields(instance, cube_id, 0, cell_dimension[i]->get_tag(), cell_dimension[i]->get_tag_count(), items[i]->get_field_ptr_array(), items[i]->get_tag_count());
+    }
+
+    clock_t end = clock();
+    printf("time: %lf second\n", (double)(end - start) / CLOCKS_PER_SEC);
+
+    fieldstat_free(instance);
+}
+
+void generate_random_string(char *str, size_t length) {
+    static const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    for (size_t i = 0; i < length - 1; i++) {
+        int key = rand() % (int)(sizeof(charset) - 1);
+        str[i] = charset[key];
+    }
+    str[length - 1] = '\0';
+}
+
+long long generate_random_integer() {
+    return rand();
+}
+
+struct field *generate_random_dimensions(enum field_type type, int n_dimensions) {
+    struct field *dimensions = (struct field *)malloc(sizeof(struct field) * n_dimensions);
+    char key[16];
+    int max_length = 16;
+
+    for (int i = 0; i < n_dimensions; i++) {
+        
+        if (type == FIELD_VALUE_CSTRING) {
+            snprintf(key, sizeof(key), "str_%d", i + 1);
+            dimensions[i].type = FIELD_VALUE_CSTRING;
+            char *random_str = (char *)malloc(max_length);
+
+            generate_random_string(random_str, max_length);
+            dimensions[i].value_str = random_str;
+        } else if (type == FIELD_VALUE_INTEGER) {
+            snprintf(key, sizeof(key), "int_%d", i + 1);
+            dimensions[i].type = FIELD_VALUE_INTEGER;
+            dimensions[i].value_longlong = rand() % 100; // 随机整数
+        }
+        dimensions[i].key = strdup(key);
+    }
+
+    return dimensions;
+}
+
+void free_dimensions(struct field *dimensions, int n_dimensions) {
+    for (int i = 0; i < n_dimensions; i++) {
+        if (dimensions[i].type == FIELD_VALUE_CSTRING) {
+            free((void *)dimensions[i].value_str);
+        }
+        free((void *)dimensions[i].key);
+    }
+    free(dimensions);
+}
+
+// 初始化fieldstat_easy实例
+struct fieldstat_easy *initialize_fieldstat_easy(const char *name, const struct field *global_dimensions, size_t n_global_dimensions, int num_counters, int *counter_ids) {
+    struct fieldstat_easy *fse = fieldstat_easy_new(1, name, global_dimensions, n_global_dimensions);
+
+    // 注册计数器
+    for (int i = 0; i < num_counters; i++) {
+        char metric_name[64];
+        snprintf(metric_name, sizeof(metric_name), "counter_%d", i);
+        int counter_id = fieldstat_easy_register_counter(fse, metric_name);
+        if (counter_id < 0) {
+            fprintf(stderr, "Failed to register counter %s\n", metric_name);
+            exit(EXIT_FAILURE);
+        }
+        counter_ids[i] = counter_id;
+    }
+    return fse;
+}
+
+struct fs_instance {
+    struct fieldstat *instance;
+    struct fieldstat_easy *instance_easy;
+};
+
+clock_t g_run_time = 0;
+void tested_function(struct fs_instance *instance, int cube_id, int metric_id, const struct field *dimensions, int n_dimensions, long long count) {
+    clock_t start = clock();
+
+    if (instance->instance != NULL) {
+        fieldstat_counter_incrby(instance->instance, cube_id, metric_id, dimensions, n_dimensions, count);
+    } else {
+        fieldstat_easy_counter_incrby(instance->instance_easy, 0, metric_id, dimensions, n_dimensions, count);
+    }
+
+    clock_t end = clock();
+    g_run_time += end - start;
+}
+
+void tested_function_batch(struct fs_instance *instance, int cube_id, int metric_ids[], const struct field *dimensions, int n_dimensions, long long counts[], size_t n_metrics) {
+    clock_t start = clock();
+
+    if (instance->instance != NULL) {
+        fieldstat_counter_incrby_batch(instance->instance, cube_id,  dimensions, n_dimensions, metric_ids, counts, n_metrics);
+    } else {
+        fieldstat_easy_counter_incrby_batch(instance->instance_easy, 0, metric_ids, dimensions, n_dimensions, counts, n_metrics);
+    }
+
+    clock_t end = clock();
+    g_run_time += end - start;
+}
+
+TEST(perf, complex_instance_group_for_real_case) {
+    const int N_LOOP = 50000;
+
+    printf("press any key to start\n");
+    getchar();
+
+
+    // traffic_general_stat
+    {
+        struct field *global_int_dimension = generate_random_dimensions(FIELD_VALUE_INTEGER, 1);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+        struct field global_dimensions[4];
+        memcpy(&global_dimensions[0], &global_int_dimension[0], sizeof(struct field));
+        memcpy(&global_dimensions[1], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        int num_counters = 13;
+        int counter_ids[13];
+        struct fieldstat_easy *fse_traffic_general = initialize_fieldstat_easy("traffic_general_stat", global_dimensions, 4, num_counters, counter_ids);
+        struct fs_instance instance;
+        instance.instance_easy = fse_traffic_general;
+        instance.instance = NULL;
+
+        // 在循环中调用counter_incrby
+        long long count = rand() % 10000 + 1;
+        for (int counter_index = 0; counter_index < num_counters; counter_index++) {
+            int metric_id = counter_ids[counter_index];
+            for (int iter = 0; iter < N_LOOP; iter++) {
+                tested_function(&instance, 0, metric_id, NULL, 0, count);
+            }
+        }
+
+        fieldstat_easy_free(fse_traffic_general);
+        free_dimensions(global_int_dimension, 1);
+        free_dimensions(global_str_dimensions, 3);
+    }
+
+    // traffic_application_protocol_stat
+    {
+        struct field *global_int_dimension = generate_random_dimensions(FIELD_VALUE_INTEGER, 1);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+
+        // 合并global_dimensions
+        struct field global_dimensions[4];
+        memcpy(&global_dimensions[0], &global_int_dimension[0], sizeof(struct field));
+        memcpy(&global_dimensions[1], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        int num_counters = 19;
+        int counter_ids[19];
+        struct fieldstat_easy *fse_traffic_app = initialize_fieldstat_easy("traffic_application_protocol_stat", global_dimensions, 4, num_counters, counter_ids);
+        struct fs_instance instance;
+        instance.instance_easy = fse_traffic_app;
+        instance.instance = NULL;
+
+        // dimensions: string :2
+        int n_dimensions = 2;
+        struct field *dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, n_dimensions);
+
+        long long count = rand() % 10000 + 1;
+        for (int counter_index = 0; counter_index < num_counters; counter_index++) {
+            int metric_id = counter_ids[counter_index];
+            for (int iter = 0; iter < N_LOOP; iter++) {
+                // 随机产生count
+                tested_function(&instance, 0, metric_id, dimensions, n_dimensions, count);
+            }
+        }
+        free_dimensions(dimensions, n_dimensions);
+
+        fieldstat_easy_free(fse_traffic_app);
+        free_dimensions(global_int_dimension, 1);
+        free_dimensions(global_str_dimensions, 3);
+    }
+
+    // TRAFFIC-SKETCH-METRIC
+    {
+        struct field *global_int_dimensions = generate_random_dimensions(FIELD_VALUE_INTEGER, 2);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+
+        // 合并global_dimensions
+        struct field global_dimensions[5];
+        memcpy(&global_dimensions[0], &global_int_dimensions[0], sizeof(struct field) * 2);
+        memcpy(&global_dimensions[2], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        int num_counters = 19;
+        int counter_ids[19];
+        struct fieldstat_easy *fse_traffic_sketch = initialize_fieldstat_easy("TRAFFIC-SKETCH-METRIC", global_dimensions, 5, num_counters, counter_ids);
+        struct fs_instance instance;
+        instance.instance_easy = fse_traffic_sketch;
+        instance.instance = NULL;
+
+        // dimension: string: [6,16]
+        int n_dimensions = 16;
+
+        // 在循环中调用counter_incrby
+        long long count = rand() % 10000 + 1;
+        int N_ITER_PER_COUNTER = N_LOOP / num_counters;
+        for (int counter_index = 0; counter_index < num_counters; counter_index++) {
+            int metric_id = counter_ids[counter_index];
+            for (int iter = 0; iter < N_ITER_PER_COUNTER; iter++) {
+                // 随机生成dimensions的值
+                struct field *dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, n_dimensions);
+
+                // 调用counter_incrby
+                tested_function(&instance, 0, metric_id, dimensions, n_dimensions, count);
+
+                // 释放dimensions
+                free_dimensions(dimensions, n_dimensions);
+            }
+        }
+
+        free_dimensions(global_int_dimensions, 2);
+        free_dimensions(global_str_dimensions, 3);
+        fieldstat_easy_free(fse_traffic_sketch);
+    }
+
+    // TOPK-METRIC
+    {
+        struct fieldstat *fs_topk = fieldstat_new();
+        struct fs_instance instance;
+        instance.instance_easy = NULL;
+        instance.instance = fs_topk;
+
+        // global_dimensions: integer :1, string:3
+        struct field *global_int_dimension = generate_random_dimensions(FIELD_VALUE_INTEGER, 1);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+        struct field global_dimensions[4];
+        memcpy(&global_dimensions[0], &global_int_dimension[0], sizeof(struct field));
+        memcpy(&global_dimensions[1], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        // 注册cube
+        int cube_ids[24];
+        int num_cubes = 24;
+        for (int i = 0; i < num_cubes; i++) {
+            struct field cube_dimension;
+            char cube_key[16];
+            snprintf(cube_key, sizeof(cube_key), "cube_%d", i + 1);
+            cube_dimension.key = cube_key;
+            cube_dimension.type = FIELD_VALUE_INTEGER;
+            cube_dimension.value_longlong = i + 1;
+
+            int cube_id = fieldstat_cube_create(fs_topk, &cube_dimension, 1);
+            if (cube_id < 0) {
+                fprintf(stderr, "Failed to create cube %d\n", i);
+                exit(EXIT_FAILURE);
+            }
+            cube_ids[i] = cube_id;
+        }
+
+        // 注册metrics
+        int metric_ids[7];
+        int num_metrics = 7;
+        for (int j = 0; j < num_metrics; j++) {
+            char metric_name[64];
+            snprintf(metric_name, sizeof(metric_name), "counter_%d", j);
+
+            for (int i = 0; i < num_cubes; i++) {
+                int cube_id = cube_ids[i];
+                int metric_id = fieldstat_register_counter(fs_topk, cube_id, metric_name);
+                metric_ids[j] = metric_id;
+            }
+        }
+
+        // 设置sampling
+        for (int i = 0; i < num_cubes; i++) {
+            fieldstat_cube_set_sampling(fs_topk, cube_ids[i], SAMPLING_MODE_TOPK, 1000, rand() % num_metrics);
+        }
+
+        // 在循环中调用counter_incrby
+        long long count = rand() % 10000 + 1;
+        for (int iter = 0; iter < N_LOOP; iter++) {
+            struct field *cell_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 2); // dimensions: string:2
+            for (int cube_index = 0; cube_index < num_cubes; cube_index++) {
+                int cube_id = cube_ids[cube_index];
+                for (int metric_index = 0; metric_index < num_metrics; metric_index++) {
+                    int metric_id = metric_ids[metric_index];
+                    
+                    tested_function(&instance, cube_id, metric_id, cell_dimensions, 2, count);
+                    
+                }
+            }
+            free_dimensions(cell_dimensions, 2);
+        }
+
+        fieldstat_free(fs_topk);
+        free_dimensions(global_int_dimension, 1);
+        free_dimensions(global_str_dimensions, 3);
+    }
+
+    // DOS-SKETCH-METRIC
+    {
+        struct fieldstat *fs_dos = fieldstat_new();
+        struct fs_instance instance;
+        instance.instance_easy = NULL;
+        instance.instance = fs_dos;
+
+        // global_dimensions: integer:2, string:3
+        struct field *global_int_dimensions = generate_random_dimensions(FIELD_VALUE_INTEGER, 2);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+
+        // 合并global_dimensions
+        struct field global_dimensions[5];
+        memcpy(&global_dimensions[0], &global_int_dimensions[0], sizeof(struct field) * 2);
+        memcpy(&global_dimensions[2], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        // 创建cube
+        int cube_ids[2];
+        int num_cubes = 2;
+        for (int i = 0; i < num_cubes; i++) {
+            struct field cube_dimension;
+            char cube_key[16];
+            snprintf(cube_key, sizeof(cube_key), "cube_%d", i + 1);
+            cube_dimension.key = cube_key;
+            cube_dimension.type = FIELD_VALUE_INTEGER;
+            cube_dimension.value_longlong = i + 1;
+
+            int cube_id = fieldstat_cube_create(fs_dos, &cube_dimension, 1);
+            if (cube_id < 0) {
+                fprintf(stderr, "Failed to create cube %d\n", i);
+                exit(EXIT_FAILURE);
+            }
+            cube_ids[i] = cube_id;
+        }
+
+        // 注册metrics
+        int num_metrics = 3;
+        for (int i = 0; i < num_cubes; i++) {
+            int cube_id = cube_ids[i];
+            for (int j = 0; j < num_metrics; j++) {
+                char metric_name[64];
+                snprintf(metric_name, sizeof(metric_name), "counter_%d", j);
+                int metric_id = fieldstat_register_counter(fs_dos, cube_id, metric_name);
+                if (metric_id < 0) {
+                    fprintf(stderr, "Failed to register metric %s for cube %d\n", metric_name, cube_id);
+                    exit(EXIT_FAILURE);
+                }
+            }
+        }
+
+        // 设置sampling
+        for (int i = 0; i < num_cubes; i++) {
+            fieldstat_cube_set_sampling(fs_dos, cube_ids[i], SAMPLING_MODE_TOPK, 1000, rand() % num_metrics);
+        }
+
+        // 在循环中调用counter_incrby
+        int n_dimensions = 5; // dimension: string:  [2,5]
+
+        for (int iter = 0; iter < N_LOOP; iter++) {
+            struct field *cell_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, n_dimensions);
+            for (int cube_index = 0; cube_index < num_cubes; cube_index++) {
+                int cube_id = cube_ids[cube_index];
+                for (int metric_index = 0; metric_index < num_metrics; metric_index++) {
+                    int metric_id = metric_index;
+    
+                    long long count = rand() % 10000 + 1;
+
+                    tested_function(&instance, cube_id, metric_id, cell_dimensions, n_dimensions, count);
+                }
+            }
+            free_dimensions(cell_dimensions, n_dimensions);
+        }
+        free_dimensions(global_int_dimensions, 2);
+        free_dimensions(global_str_dimensions, 3);
+        fieldstat_free(fs_dos);
+    }
+
+    printf("run (%d) loops in %lf seconds\n", N_LOOP, (double)(g_run_time) / CLOCKS_PER_SEC);
+}
+
+
+TEST(perf, complex_instance_group_for_real_case_use_batch) {
+    const int N_LOOP = 50000;
+
+    printf("press any key to start\n");
+    getchar();
+
+    // traffic_general_stat
+    {
+        struct field *global_int_dimension = generate_random_dimensions(FIELD_VALUE_INTEGER, 1);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+        struct field global_dimensions[4];
+        memcpy(&global_dimensions[0], &global_int_dimension[0], sizeof(struct field));
+        memcpy(&global_dimensions[1], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        int num_counters = 13;
+        int counter_ids[13];
+        struct fieldstat_easy *fse_traffic_general = initialize_fieldstat_easy("traffic_general_stat", global_dimensions, 4, num_counters, counter_ids);
+        struct fs_instance instance;
+        instance.instance_easy = fse_traffic_general;
+        instance.instance = NULL;
+
+        long long counts[13];
+        for (int i = 0; i < 13; i++) {
+            counts[i] = rand() % 10000 + 1;
+        }
+        for (int iter = 0; iter < N_LOOP; iter++) {
+            tested_function_batch(&instance, 0, counter_ids, NULL, 0, counts, 13);
+        }
+
+        fieldstat_easy_free(fse_traffic_general);
+        free_dimensions(global_int_dimension, 1);
+        free_dimensions(global_str_dimensions, 3);
+    }
+
+    // traffic_application_protocol_stat
+    {
+        struct field *global_int_dimension = generate_random_dimensions(FIELD_VALUE_INTEGER, 1);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+
+        // 合并global_dimensions
+        struct field global_dimensions[4];
+        memcpy(&global_dimensions[0], &global_int_dimension[0], sizeof(struct field));
+        memcpy(&global_dimensions[1], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        int num_counters = 19;
+        int counter_ids[19];
+        struct fieldstat_easy *fse_traffic_app = initialize_fieldstat_easy("traffic_application_protocol_stat", global_dimensions, 4, num_counters, counter_ids);
+        struct fs_instance instance;
+        instance.instance_easy = fse_traffic_app;
+        instance.instance = NULL;
+
+        // dimensions: string :2
+        int n_dimensions = 2;
+        struct field *dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, n_dimensions);
+
+        long long counts[19];
+        for (int i = 0; i < 19; i++) {
+            counts[i] = rand() % 10000 + 1;
+        }
+        for (int iter = 0; iter < N_LOOP; iter++) {
+            tested_function_batch(&instance, 0, counter_ids, dimensions, n_dimensions, counts, 19);
+        }
+        free_dimensions(dimensions, n_dimensions);
+
+        fieldstat_easy_free(fse_traffic_app);
+        free_dimensions(global_int_dimension, 1);
+        free_dimensions(global_str_dimensions, 3);
+    }
+
+    // TRAFFIC-SKETCH-METRIC
+    {
+        struct field *global_int_dimensions = generate_random_dimensions(FIELD_VALUE_INTEGER, 2);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+
+        // 合并global_dimensions
+        struct field global_dimensions[5];
+        memcpy(&global_dimensions[0], &global_int_dimensions[0], sizeof(struct field) * 2);
+        memcpy(&global_dimensions[2], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        int num_counters = 19;
+        int counter_ids[19];
+        struct fieldstat_easy *fse_traffic_sketch = initialize_fieldstat_easy("TRAFFIC-SKETCH-METRIC", global_dimensions, 5, num_counters, counter_ids);
+        struct fs_instance instance;
+        instance.instance_easy = fse_traffic_sketch;
+        instance.instance = NULL;
+
+        long long counts[num_counters];
+        for (int i = 0; i < num_counters; i++) {
+            counts[i] = rand() % 10000 + 1;
+        }
+        for (int iter = 0; iter < N_LOOP; iter++) {
+            struct field *cell_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 16); // dimensions: string:16
+            tested_function_batch(&instance, 0, counter_ids, cell_dimensions, 16, counts, num_counters);
+            free_dimensions(cell_dimensions, 16);
+        }
+
+        free_dimensions(global_int_dimensions, 2);
+        free_dimensions(global_str_dimensions, 3);
+        fieldstat_easy_free(fse_traffic_sketch);
+    }
+
+    // TOPK-METRIC
+    {
+        struct fieldstat *fs_topk = fieldstat_new();
+        struct fs_instance instance;
+        instance.instance_easy = NULL;
+        instance.instance = fs_topk;
+
+        // global_dimensions: integer :1, string:3
+        struct field *global_int_dimension = generate_random_dimensions(FIELD_VALUE_INTEGER, 1);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+        struct field global_dimensions[4];
+        memcpy(&global_dimensions[0], &global_int_dimension[0], sizeof(struct field));
+        memcpy(&global_dimensions[1], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        // 注册cube
+        int cube_ids[24];
+        int num_cubes = 24;
+        for (int i = 0; i < num_cubes; i++) {
+            struct field cube_dimension;
+            char cube_key[16];
+            snprintf(cube_key, sizeof(cube_key), "cube_%d", i + 1);
+            cube_dimension.key = cube_key;
+            cube_dimension.type = FIELD_VALUE_INTEGER;
+            cube_dimension.value_longlong = i + 1;
+
+            int cube_id = fieldstat_cube_create(fs_topk, &cube_dimension, 1);
+            if (cube_id < 0) {
+                fprintf(stderr, "Failed to create cube %d\n", i);
+                exit(EXIT_FAILURE);
+            }
+            cube_ids[i] = cube_id;
+        }
+
+        // 注册metrics
+        int metric_ids[7];
+        int num_metrics = 7;
+        for (int j = 0; j < num_metrics; j++) {
+            char metric_name[64];
+            snprintf(metric_name, sizeof(metric_name), "counter_%d", j);
+
+            for (int i = 0; i < num_cubes; i++) {
+                int cube_id = cube_ids[i];
+                int metric_id = fieldstat_register_counter(fs_topk, cube_id, metric_name);
+                metric_ids[j] = metric_id;
+            }
+        }
+
+        // 设置sampling
+        for (int i = 0; i < num_cubes; i++) {
+            fieldstat_cube_set_sampling(fs_topk, cube_ids[i], SAMPLING_MODE_TOPK, 1000, rand() % num_metrics);
+        }
+
+        // 在循环中调用counter_incrby
+        long long counts[7];
+        for (int i = 0; i < 7; i++) {
+            counts[i] = rand() % 10000 + 1;
+        }
+        for (int iter = 0; iter < N_LOOP; iter++) {
+            struct field *cell_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 2); // dimensions: string:2
+            for (int cube_index = 0; cube_index < num_cubes; cube_index++) {
+                int cube_id = cube_ids[cube_index];
+                
+                tested_function_batch(&instance, cube_id, metric_ids, cell_dimensions, 2, counts, 7);
+            }
+            free_dimensions(cell_dimensions, 2);
+        }
+
+        fieldstat_free(fs_topk);
+        free_dimensions(global_int_dimension, 1);
+        free_dimensions(global_str_dimensions, 3);
+    }
+
+    // DOS-SKETCH-METRIC
+    {
+        struct fieldstat *fs_dos = fieldstat_new();
+        struct fs_instance instance;
+        instance.instance_easy = NULL;
+        instance.instance = fs_dos;
+
+        // global_dimensions: integer:2, string:3
+        struct field *global_int_dimensions = generate_random_dimensions(FIELD_VALUE_INTEGER, 2);
+        struct field *global_str_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, 3);
+
+        // 合并global_dimensions
+        struct field global_dimensions[5];
+        memcpy(&global_dimensions[0], &global_int_dimensions[0], sizeof(struct field) * 2);
+        memcpy(&global_dimensions[2], &global_str_dimensions[0], sizeof(struct field) * 3);
+
+        // 创建cube
+        int cube_ids[2];
+        int num_cubes = 2;
+        for (int i = 0; i < num_cubes; i++) {
+            struct field cube_dimension;
+            char cube_key[16];
+            snprintf(cube_key, sizeof(cube_key), "cube_%d", i + 1);
+            cube_dimension.key = cube_key;
+            cube_dimension.type = FIELD_VALUE_INTEGER;
+            cube_dimension.value_longlong = i + 1;
+
+            int cube_id = fieldstat_cube_create(fs_dos, &cube_dimension, 1);
+            if (cube_id < 0) {
+                fprintf(stderr, "Failed to create cube %d\n", i);
+                exit(EXIT_FAILURE);
+            }
+            cube_ids[i] = cube_id;
+        }
+
+        // 注册metrics
+        int num_metrics = 3;
+        int metric_ids[3];  
+        for (int i = 0; i < num_cubes; i++) {
+            int cube_id = cube_ids[i];
+            for (int j = 0; j < num_metrics; j++) {
+                char metric_name[64];
+                snprintf(metric_name, sizeof(metric_name), "counter_%d", j);
+                int metric_id = fieldstat_register_counter(fs_dos, cube_id, metric_name);
+                if (metric_id < 0) {
+                    fprintf(stderr, "Failed to register metric %s for cube %d\n", metric_name, cube_id);
+                    exit(EXIT_FAILURE);
+                }
+                metric_ids[j] = metric_id;
+            }
+        }
+
+        // 设置sampling
+        for (int i = 0; i < num_cubes; i++) {
+            fieldstat_cube_set_sampling(fs_dos, cube_ids[i], SAMPLING_MODE_TOPK, 1000, rand() % num_metrics);
+        }
+
+        // 在循环中调用counter_incrby
+        int n_dimensions = 5; // dimension: string:  [2,5]
+        long long counts[3];
+        for (int i = 0; i < 3; i++) {
+            counts[i] = rand() % 10000 + 1;
+        }
+
+        for (int iter = 0; iter < N_LOOP; iter++) {
+            struct field *cell_dimensions = generate_random_dimensions(FIELD_VALUE_CSTRING, n_dimensions);
+            for (int cube_index = 0; cube_index < num_cubes; cube_index++) {
+                int cube_id = cube_ids[cube_index];
+                tested_function_batch(&instance, cube_id, metric_ids, cell_dimensions, n_dimensions, counts, 3);
+            }
+            free_dimensions(cell_dimensions, n_dimensions);
+        }
+        free_dimensions(global_int_dimensions, 2);
+        free_dimensions(global_str_dimensions, 3);
+        fieldstat_free(fs_dos);
+    }
+
+    printf("run (%d) loops in %lf seconds\n", N_LOOP, (double)(g_run_time) / CLOCKS_PER_SEC);
+}
+
+#include "uthash.h" 
+struct my_struct {
+    int id;                    /* we'll use this field as the key */
+    UT_hash_handle hh;         /* makes this structure hashable */
+};
+TEST(perf, what_will_uthash_do) {
+    int loop = 1000;
+    struct my_struct *users = NULL;
+    struct my_struct *s;
+    for (int i = 0; i < loop; i++) {
+        s = (struct my_struct*)malloc(sizeof(struct my_struct));
+        s->id = i;
+        HASH_ADD_INT( users, id, s );
+    }
+
+    // 得到内部每个bucket 里的链长度。
+    std::vector<int> item_in_bucket;
+    
+    for (unsigned i = 0; i < users->hh.tbl->num_buckets; i++) {
+        int count = 0;
+
+        struct UT_hash_table *tbl = users->hh.tbl;
+        struct UT_hash_handle *hh = tbl->buckets[i].hh_head;
+        while (hh != NULL) {
+            count++;
+            hh = hh->hh_next;
+        }
+
+        item_in_bucket.push_back(count);
+    }
+
+    for (int i = 0; i < item_in_bucket.size(); i++) {
+        printf("bucket %d has %d items\n", i, item_in_bucket[i]);
+    }
+    printf("mean of items in bucket: %lf\n", (double)loop / item_in_bucket.size());
+    double std_dev = 0;
+    for (int i = 0; i < item_in_bucket.size(); i++) {
+        std_dev += (item_in_bucket[i] - loop / item_in_bucket.size()) * (item_in_bucket[i] - loop / item_in_bucket.size());
+    }
+    std_dev = sqrt(std_dev / item_in_bucket.size());
+    printf("std_dev of items in bucket: %lf\n", std_dev);
+    int number_of_empty_bucket = 0;
+    for (int i = 0; i < item_in_bucket.size(); i++) {
+        if (item_in_bucket[i] == 0) {
+            number_of_empty_bucket++;
+        }
+    }
+    printf("number of empty bucket: %d\n", number_of_empty_bucket);
+}
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    testing::GTEST_FLAG(filter) = "*complex_instance_group_for_real_case";
+    // testing::GTEST_FLAG(filter) = "*what_will_uthash_do";
+
+    return RUN_ALL_TESTS();
+}
\ No newline at end of file
diff --git a/vendors/uthash.h b/vendors/uthash.h
index 2c00932..fe3ce88 100644
--- a/vendors/uthash.h
+++ b/vendors/uthash.h
@@ -134,9 +134,9 @@ do {
 #endif
 
 /* initial number of buckets */
-#define HASH_INITIAL_NUM_BUCKETS 32U     /* initial number of buckets        */
-#define HASH_INITIAL_NUM_BUCKETS_LOG2 5U /* lg2 of initial number of buckets */
-#define HASH_BKT_CAPACITY_THRESH 10U     /* expand when bucket count reaches */
+#define HASH_INITIAL_NUM_BUCKETS 256U     /* initial number of buckets        */
+#define HASH_INITIAL_NUM_BUCKETS_LOG2 8U /* lg2 of initial number of buckets */
+#define HASH_BKT_CAPACITY_THRESH 5U     /* expand when bucket count reaches */
 
 /* calculate the element whose hash handle address is hhp */
 #define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))