fix ci

8 files changed, 112 insertions, 34 deletions

diff --git a/src/fieldstat.c b/src/fieldstat.c
index ed0b9ee..d1405f1 100644
--- a/src/fieldstat.c
+++ b/src/fieldstat.c
@@ -820,6 +820,7 @@ void fieldstat_cube_merge_comprehensive(struct fs_cube *dest, const struct fs_cu
 
 void fieldstat_cube_merge_topk(struct fs_cube *dest, const struct fs_cube *src, const int *metric_id_src_dest_map)
 {
+    printf("merge topk enter\n");
     const struct cell_manager *cell_manager_src = src->cell_manager;
     struct cell_manager *cell_manager_dest = dest->cell_manager;
     int *cell_id_added = NULL;
@@ -843,6 +844,7 @@ void fieldstat_cube_merge_topk(struct fs_cube *dest, const struct fs_cube *src,
     // Since all cells are counter, which is easy to merge, we just delete these cells after merging them.
     for (int i = 0; i < n_cell_id_popped;i++) {
         int id = cell_id_popped[i];
+        printf("delete metric for cell %d\n", id);
 
         for (int j = 0; j < dest->n_metric; j++) {
             metric_delete_cell(dest->metrics[j], id);
diff --git a/src/tags/heavy_keeper.c b/src/tags/heavy_keeper.c
index 4429da6..4760f6e 100644
--- a/src/tags/heavy_keeper.c
+++ b/src/tags/heavy_keeper.c
@@ -396,12 +396,16 @@ void heavy_keeper_merge_sorted_set_recording_id_details(struct heavy_keeper *des
     int cell_id_in_src_before_merge_len = 0;
     int cell_id_in_dest_corresponding[dest->K]; // length == cell_id_in_src_before_merge_len
 
+    printf("size dest: %d, size src: %d\n", size_dest, size_src);
     /* ------------------------------ merge dest ------------------------------ */
     for (int i = 0; i < size_dest; i++) {
         unsigned maxv = find_maxv_in_sketch(dest, tag_arr[i]);
+        printf("merge dest tag: %s, maxv: %u\n", tag_hash_key_get_compound_key(tag_arr[i]), maxv);
         sorted_set_insert(new_rec, tag_arr[i], maxv, cell_id_arr_dst[i]);
     }
 
+    printf("merged dest, the min count: %u\n", sorted_set_get_min_count(new_rec));
+
     qsort(cell_id_arr_dst, size_dest, sizeof(int), cmp_int);
 
     /* ------------------------------ merge source ------------------------------ */
@@ -412,6 +416,8 @@ void heavy_keeper_merge_sorted_set_recording_id_details(struct heavy_keeper *des
 
     for (int i = 0; i < size_src; i++) {
         const struct tag_hash_key *tag_src = tag_arr[i];
+        printf("merge src tag: %s\n", tag_hash_key_get_compound_key(tag_src));
+
         int cell_id_dest = sorted_set_get_cell_id(ss_dest, tag_src);
         int cell_id_src = cell_id_arr_src[i];
     
@@ -419,6 +425,7 @@ void heavy_keeper_merge_sorted_set_recording_id_details(struct heavy_keeper *des
             cell_id_in_src_before_merge[cell_id_in_src_before_merge_len] = cell_id_src;
             cell_id_in_dest_corresponding[cell_id_in_src_before_merge_len] = cell_id_dest;
             cell_id_in_src_before_merge_len++;
+            printf("the this one is merged by dest, id dest: %d, id src: %d\n", cell_id_dest, cell_id_src);
 
             continue;
         }
@@ -428,8 +435,9 @@ void heavy_keeper_merge_sorted_set_recording_id_details(struct heavy_keeper *des
         int now_idx = next_idx;
         int find_id = find_next_unused_cell_id(cell_id_arr_dst, size_dest, last_find_id, &now_idx);
         int tmp_ret = sorted_set_insert_and_record_popped_back(new_rec, tag_src, maxv, find_id, &popped_id);
+        printf("insert tag(src): %s, maxv: %u, ret %d, min count: %u \n", tag_hash_key_get_compound_key(tag_src), maxv, tmp_ret, sorted_set_get_min_count(new_rec));
         if (tmp_ret == 2) { // insert success and popped one. the previous tag_final is already freed by sorted_set
-            assert(popped_id != -1);
+            printf("popped_id: %d\n", popped_id);
             cell_id_popped_from_dest_when_merge_src[cell_id_popped_from_dest_when_merge_src_len++] = popped_id;
         } 
         if (tmp_ret != 0) { // insert success
@@ -439,6 +447,11 @@ void heavy_keeper_merge_sorted_set_recording_id_details(struct heavy_keeper *des
             cell_id_in_src_before_merge[cell_id_in_src_before_merge_len] = cell_id_src;
             cell_id_in_dest_corresponding[cell_id_in_src_before_merge_len] = last_find_id;
             cell_id_in_src_before_merge_len++;
+
+            printf("insert success: cell_id_src %d, last_find_id %d\n", cell_id_src, last_find_id);
+        }
+        if (tmp_ret == 0) { // insert failed
+            printf("insert failed, so will not change metrics\n");
         }
     }
 
@@ -483,7 +496,19 @@ int heavy_keeper_merge_recording_id_details(struct heavy_keeper *dest, const str
         return -1;
     }
 
+    unsigned *count_arr = (unsigned *)malloc(2 * sizeof(unsigned));
+    struct tag_hash_key **tag_arr = (struct tag_hash_key **)malloc(2 * sizeof(struct tag_hash_key *));
+    int *cell_id_arr = (int *)malloc(2 * sizeof(int));
+    sorted_set_dump(dest->top_K_heap, count_arr, tag_arr, cell_id_arr);
+    for (int i = 0; i < 1; i++) {
+        unsigned maxv = find_maxv_in_sketch(dest, tag_arr[i]);
+        printf("merge dest tag: %s, count: %u, cell_id: %d, maxv: %u\n", tag_hash_key_get_compound_key(tag_arr[i]), count_arr[i], cell_id_arr[i], maxv);
+    }
+
+    
     heavy_keeper_merge_sketch(dest, src);
+    printf("after merge sketch, maxv:%u\n", find_maxv_in_sketch(dest, tag_arr[0]));
+
     heavy_keeper_merge_sorted_set_recording_id_details(dest, src,
         cell_id_popped_from_dest_when_merge_src_out, cell_id_popped_from_dest_when_merge_src_len_out,
         cell_id_in_src_before_merge_out, cell_id_in_dest_corresponding_out, cell_id_in_src_before_merge_len_out);
diff --git a/src/tags/sorted_set.c b/src/tags/sorted_set.c
index 7c45634..726d5d4 100644
--- a/src/tags/sorted_set.c
+++ b/src/tags/sorted_set.c
@@ -244,6 +244,7 @@ int sorted_set_insert_and_record_popped_back(struct sorted_set *ss, const struct
     // if there is a dying record, reborn it to use.

     heap_entry *entry = sorted_set_find_entry(ss, tag);

     if (entry != NULL) {

+        printf("sorted_set_insert_and_record_popped_back reborn\n");

         if (!sorted_set_entry_dying(entry)) {

             return -1;

         }

@@ -256,10 +257,12 @@ int sorted_set_insert_and_record_popped_back(struct sorted_set *ss, const struct
     bool popped = false;

     if (sorted_set_check_is_full(ss)) {

         if (cnt <= sorted_set_get_min_count(ss)) {

+            printf("sorted_set_insert_and_record_popped_back not insert, mincount: %u, my count: %u\n", sorted_set_get_min_count(ss), cnt);

             return 0;

         }

         sorted_set_pop_and_record_popped_back(ss, popped_user_data);

         if (*popped_user_data == -1) { // popped a dying entry, not a real entry.

+            printf("sorted_set_insert_and_record_popped_back dying one\n");

             popped = false;

         } else {

             popped = true;

@@ -277,8 +280,11 @@ unsigned sorted_set_get_min_count(const struct sorted_set *ss)
     }

     const heap_entry *ret = (heap_entry *)(heap->nodes[0]);

 

-    const unsigned* key = ret->key;

-    return *key;

+    unsigned int count = *(unsigned int *)ret->key;

+    if (count == 0) {

+        return 0;

+    }

+    return count - 1; // sorted set will let the count start from 1, 0 for dying entry.

 }

 

 unsigned sorted_set_get_count(const struct sorted_set *ss, const struct tag_hash_key *tag)

diff --git a/test/test_metric_counter.cpp b/test/test_metric_counter.cpp
index 23e02e7..cf19727 100644
--- a/test/test_metric_counter.cpp
+++ b/test/test_metric_counter.cpp
@@ -285,9 +285,9 @@ TEST(metric_test_counter, add_or_set_with_wrong_cell_id_expecting_fail)
     fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_SUM);
 
     int ret = fieldstat_counter_incrby(instance, 0, 0, 1, 1);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
     ret = fieldstat_counter_incrby(instance, 0, 0, -1, 1);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
 
     fieldstat_free(instance);
 }
@@ -298,9 +298,9 @@ TEST(metric_test_counter, add_with_wrong_cube_id_expecting_fail)
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
 
     int ret = fieldstat_counter_incrby(instance, cube_id + 1, 0, 1, 1);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
     ret = fieldstat_counter_incrby(instance, -1, 0, 1, 1);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
 
     fieldstat_free(instance);
 }
@@ -312,9 +312,9 @@ TEST(metric_test_counter, add_with_wrong_metric_id_expecting_fail)
     int metric_id = fieldstat_register_counter(instance, cube_id, "test", COUNTER_MERGE_BY_SUM);
 
     int ret = fieldstat_counter_incrby(instance, cube_id, metric_id + 1, 1, 1);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
     ret = fieldstat_counter_incrby(instance, cube_id, -1, 1, 1);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
 
     fieldstat_free(instance);
 }
@@ -326,9 +326,9 @@ TEST(metric_test_counter, set_with_wrong_cell_id_expecting_fail)
     fieldstat_register_counter(instance, 0, "test", COUNTER_MERGE_BY_MAX);
 
     int ret = fieldstat_counter_set(instance, 0, 0, 1, 1);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
     ret = fieldstat_counter_set(instance, 0, 0, -1, 1);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
 
     fieldstat_free(instance);
 }
@@ -339,9 +339,9 @@ TEST(metric_test_counter, set_with_wrong_cube_id_expecting_fail)
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_TOPK, 10);
 
     int ret = fieldstat_counter_set(instance, cube_id + 1, 0, 1, 1);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
     ret = fieldstat_counter_set(instance, -1, 0, 1, 1);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
 
     fieldstat_free(instance);
 }
@@ -353,9 +353,9 @@ TEST(metric_test_counter, set_with_wrong_metric_id_expecting_fail)
     int metric_id = fieldstat_register_counter(instance, cube_id, "test", COUNTER_MERGE_BY_MAX);
 
     int ret = fieldstat_counter_set(instance, cube_id, metric_id + 1, 1, 1);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
     ret = fieldstat_counter_set(instance, cube_id, -1, 1, 1);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
 
     fieldstat_free(instance);
 }
diff --git a/test/test_metric_histogram.cpp b/test/test_metric_histogram.cpp
index 73d78b9..c7b8baf 100644
--- a/test/test_metric_histogram.cpp
+++ b/test/test_metric_histogram.cpp
@@ -130,9 +130,9 @@ TEST(metric_test_histogram, add_or_set_with_wrong_cell_id_expecting_fail)
     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, 1234);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
     ret = fieldstat_hist_record(instance, cube_id, metric_id, -1, 1234);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
 
     fieldstat_free(instance);
 }
@@ -143,9 +143,9 @@ TEST(metric_test_histogram, add_with_wrong_cube_id_expecting_fail)
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
 
     int ret = fieldstat_hist_record(instance, cube_id + 1, 0, 1, 1);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
     ret = fieldstat_hist_record(instance, -1, 0, 1, 1);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
 
     fieldstat_free(instance);
 }
@@ -157,9 +157,9 @@ TEST(metric_test_histogram, add_with_wrong_metric_id_expecting_fail)
     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, 1, 1);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
     ret = fieldstat_hist_record(instance, cube_id, -1, 1, 1);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
 
     fieldstat_free(instance);
 }
diff --git a/test/test_metric_hll.cpp b/test/test_metric_hll.cpp
index f09052a..1507093 100644
--- a/test/test_metric_hll.cpp
+++ b/test/test_metric_hll.cpp
@@ -198,9 +198,9 @@ TEST(metric_test_hll, add_or_set_with_wrong_cell_id_expecting_fail)
     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, "hello", 5);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
     ret = fieldstat_hll_add(instance, cube_id, metric_id, -1, "hello", 5);
-    EXPECT_EQ(ret, -3);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CELL_ID);
 
     fieldstat_free(instance);
 }
@@ -211,9 +211,9 @@ TEST(metric_test_hll, add_with_wrong_cube_id_expecting_fail)
     int cube_id = fieldstat_register_cube(instance, &TEST_TAG_INT_collided, 1, SAMPLING_MODE_COMPREHENSIVE, 10);
 
     int ret = fieldstat_hll_add(instance, cube_id + 1, 0, 0, "hello", 5);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
     ret = fieldstat_hll_add(instance, -1, 0, 0, "hello", 5);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
 
     fieldstat_free(instance);
 }
@@ -225,9 +225,9 @@ TEST(metric_test_hll, add_with_wrong_metric_id_expecting_fail)
     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, 0, "hello", 5);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
     ret = fieldstat_hll_add(instance, cube_id, -1, 0, "hello", 5);
-    EXPECT_EQ(ret, -2);
+    EXPECT_EQ(ret, FS_ERR_INVALID_METRIC_ID);
 
     fieldstat_free(instance);
 }
diff --git a/test/test_register_and_reset.cpp b/test/test_register_and_reset.cpp
index 82c0668..4637e14 100644
--- a/test/test_register_and_reset.cpp
+++ b/test/test_register_and_reset.cpp
@@ -26,7 +26,7 @@ TEST(test_register, delete_cube_and_version_increase)
     EXPECT_EQ(ret, 0);
     EXPECT_EQ(fieldstat_get_cube_version(instance, cube_id), 1);
     ret = fieldstat_unregister_cube(instance, cube_id);
-    EXPECT_EQ(ret, -1);
+    EXPECT_EQ(ret, FS_ERR_INVALID_CUBE_ID);
     EXPECT_EQ(fieldstat_get_cube_version(instance, cube_id), 1);
 
     fieldstat_free(instance);
@@ -34,10 +34,10 @@ TEST(test_register, delete_cube_and_version_increase)
 
 TEST(test_register, query_on_wrong_version)
 {
-    EXPECT_EQ(fieldstat_get_cube_version(NULL, 1), -1);
+    EXPECT_EQ(fieldstat_get_cube_version(NULL, 1), FS_ERR_NULL_HANDLER);
     struct fieldstat *instance = fieldstat_new();
-    EXPECT_EQ(fieldstat_get_cube_version(instance, 1), -3);
-    EXPECT_EQ(fieldstat_get_cube_version(instance, -1), -2);
+    EXPECT_EQ(fieldstat_get_cube_version(instance, 1), FS_ERR_INVALID_CUBE_ID);
+    EXPECT_EQ(fieldstat_get_cube_version(instance, -1), FS_ERR_INVALID_CUBE_ID);
     fieldstat_free(instance);
 }
 
@@ -318,7 +318,7 @@ TEST(test_register, register_cube_twice) {
     struct fieldstat *instance = fieldstat_new();
     fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
     int cube_id2 = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
-    EXPECT_EQ(cube_id2, -2);
+    EXPECT_EQ(cube_id2, FS_ERR_INVALID_KEY);
     fieldstat_free(instance);
 }
 
@@ -329,7 +329,7 @@ TEST(test_register, find_cube) {
     int find_cube_id = fieldstat_find_cube(instance, &TEST_SHARED_TAG, 1);
     EXPECT_EQ(cube_id, find_cube_id);
     int find_cube_id2 = fieldstat_find_cube(instance, &TEST_TAG_DOUBLE, 1);
-    EXPECT_EQ(find_cube_id2, -1);
+    EXPECT_EQ(find_cube_id2, FS_ERR_INVALID_KEY);
     
     fieldstat_free(instance);
 }
@@ -339,7 +339,7 @@ TEST(test_register, register_metric_twice) {
     int cube_id = fieldstat_register_cube(instance, &TEST_SHARED_TAG, 1, SAMPLING_MODE_TOPK, 10);
     fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
     int metric_id2 = fieldstat_register_counter(instance, cube_id, "counter", COUNTER_MERGE_BY_SUM);
-    EXPECT_EQ(metric_id2, -3);
+    EXPECT_EQ(metric_id2, FS_ERR_INVALID_KEY);
     fieldstat_free(instance);
 }
 
diff --git a/test/unit_test_cell_manager.cpp b/test/unit_test_cell_manager.cpp
index 375d36d..bffd440 100644
--- a/test/unit_test_cell_manager.cpp
+++ b/test/unit_test_cell_manager.cpp
@@ -683,6 +683,51 @@ TEST(unit_test_cell_manager, add_after_reset_and_ensure_performance_improvement)
     }
 }
 
+TEST(unit_test_cell_manager, reset_once_and_query_topk)
+{
+    const int TEST_ROUND = 10;
+    struct cell_manager *cm = cell_manager_new(SAMPLING_MODE_TOPK, TEST_ROUND);
+
+    vector<struct tag_hash_key *> keys;
+    for (int i = 0; i < TEST_ROUND; i++)
+    {
+        struct tag_hash_key *key = test_gen_tag_key("key", i);
+        keys.push_back(key);
+    }
+    for (int i = 0; i < TEST_ROUND; i++) {
+        int cell_id = cell_manager_add_cell(cm, keys[i]);
+        EXPECT_EQ(cell_id, i);
+    }
+
+    cell_manager_reset(cm);
+    for (int i = 0; i < TEST_ROUND; i++) {
+        EXPECT_EQ(cell_manager_find(cm, keys[i]), -1);
+        EXPECT_TRUE(cell_manager_get_tag_by_cell_id(cm, i) == NULL);
+    }
+    int array_len = 0;
+    cell_manager_dump(cm, &array_len);
+    EXPECT_EQ(array_len, 0);
+
+    // do it again, to see the effect of reset on a recovered cell_manager(instead of which just newed)
+    for (int i = 0; i < TEST_ROUND; i++) {
+        int cell_id = cell_manager_add_cell(cm, keys[i]);
+        EXPECT_EQ(cell_id, i);
+    }
+    cell_manager_reset(cm);
+    for (int i = 0; i < TEST_ROUND; i++) {
+        EXPECT_EQ(cell_manager_find(cm, keys[i]), -1);
+        EXPECT_TRUE(cell_manager_get_tag_by_cell_id(cm, i) == NULL);
+        EXPECT_EQ(cell_manager_get_count_by_tag(cm, keys[i]), 0);
+    }
+    cell_manager_dump(cm, &array_len);
+    EXPECT_EQ(array_len, 0);
+
+    cell_manager_free(cm);
+    for (int i = 0; i < TEST_ROUND; i++) {
+        tag_hash_key_free(keys[i]);
+    }
+}
+
 int main(int argc, char *argv[]) 
 {
 	testing::InitGoogleTest(&argc, argv);