add bloom fs4 statistics, add gtest user args.

4 files changed, 230 insertions, 56 deletions

diff --git a/src/support/ap_bloom/src/ap_bloom.c b/src/support/ap_bloom/src/ap_bloom.c
index a0f82a1..9cd1f9f 100644
--- a/src/support/ap_bloom/src/ap_bloom.c
+++ b/src/support/ap_bloom/src/ap_bloom.c
@@ -25,6 +25,39 @@
 #define MODE_READ 0
 #define MODE_WRITE 1
 
+struct AP_bloom_stat{
+    size_t slice_new_num_acc;
+    size_t slice_free_num_acc;
+    size_t expand_num_acc;
+    size_t expand_max_multiple_rt;
+    size_t slice_num_rt;
+};
+struct AP_configuration
+{
+    double error;
+    long long capacity;
+    long long time_window_ms;
+    long long time_slice_num;
+    struct timeval last_cfg;
+};
+struct AP_bloom
+{
+    //high level variables determined by caller
+    struct AP_configuration cfg;
+
+    //low level variables caculated by the call configure
+    int hash_num;    //k
+    int chain_num;  //hash_num+time_slice_num
+    int default_slice_size; // in bytes
+    
+    //runtime variables
+    int cursor;
+    struct timeval last_slide;
+    struct ap_slice **heads; //hash_num+timeframe_num
+
+    struct AP_bloom_stat stat;
+};
+
 //return 1 if the bit is already set, 0 if it was not set
 inline static int test_bit_set_bit(unsigned char *buf, uint64_t x, int mode) {
     uint64_t byte = x >> 3;
@@ -51,22 +84,29 @@ struct ap_slice
     unsigned char * data;
     struct ap_slice * next;
 };
-static struct ap_slice *ap_slice_new(int slice_size, int hash_index)
+static struct ap_slice *ap_slice_new(struct AP_bloom *bloom, int slice_size, int hash_index)
 {
     struct ap_slice *slice = ALLOC(struct ap_slice, 1);
     slice->slice_size = slice_size;
     assert(slice_size % sizeof(unsigned long long) == 0);
     //ap_slice_chain_deserialize may alloc slice_size=0
-    if(slice_size > 0) slice->data = ALLOC(unsigned char, slice_size);
+    if(slice_size > 0){ 
+        slice->data = ALLOC(unsigned char, slice_size);
+    }
     slice->hash_index = hash_index;
     slice->popcount = 0;
+
+    bloom->stat.slice_new_num_acc++;
+    bloom->stat.slice_num_rt++;
     return slice;
 }
-static void ap_slice_free(struct ap_slice *slice)
+static void ap_slice_free(struct AP_bloom *bloom, struct ap_slice *slice)
 {
     free(slice->data);
     slice->data = NULL;
     free(slice);
+    bloom->stat.slice_free_num_acc++;
+    bloom->stat.slice_num_rt--;
 }
 void ap_slice_chain_info(const struct ap_slice *head, double *fill_ratio, int *slice_num)
 {
@@ -105,9 +145,9 @@ static int ap_slice_cmp(const struct ap_slice *a, const struct ap_slice *b)
     //bigger size first
     return b->slice_size - a->slice_size;
 }
-static struct ap_slice * ap_slice_duplicate(const struct ap_slice *slice)
+static struct ap_slice * ap_slice_duplicate(struct AP_bloom *bloom, const struct ap_slice *slice)
 {
-    struct ap_slice *new_slice = ap_slice_new(slice->slice_size, slice->hash_index);
+    struct ap_slice *new_slice = ap_slice_new(bloom, slice->slice_size, slice->hash_index);
     memcpy(new_slice, slice, offsetof(struct ap_slice, data));
     memcpy(new_slice->data, slice->data, slice->slice_size);
     return new_slice;
@@ -242,13 +282,17 @@ static void ap_slice_chain_check_hash(const struct ap_slice *head, const struct
  *     0 - element was not present and was added
  *     1 - element (or a collision) had already been added previously
  */
-static void ap_slice_chain_add_hash(struct ap_slice **head, const struct double_hash *hash, struct timeval now)
+static void ap_slice_chain_add_hash(struct AP_bloom *bloom, struct ap_slice **head, const struct double_hash *hash, struct timeval now)
 {
     //add new slice if the current slice is full
     if(unlikely( (double) (*head)->popcount / ((*head)->slice_size<<3) > FILL_RATIO_THRESHOLD))
     {
-        struct ap_slice *new_slice = ap_slice_new((*head)->slice_size * SLICE_EXPANSION, (*head)->hash_index);
+        struct ap_slice *new_slice = ap_slice_new(bloom, (*head)->slice_size * SLICE_EXPANSION, (*head)->hash_index);
         LL_PREPEND((*head), new_slice);
+        bloom->stat.expand_num_acc++;
+        if(new_slice->slice_size/bloom->default_slice_size > bloom->stat.expand_max_multiple_rt){
+            bloom->stat.expand_max_multiple_rt = new_slice->slice_size/bloom->default_slice_size;
+        }
     }
     //Add it to the current (head) slice.
     ap_slice_add_hash(*head, hash, now);
@@ -267,22 +311,22 @@ void ap_slice_chain_first_insert_time(const struct ap_slice *head, struct timeva
     }
     return;
 }
-static void ap_slice_chain_free(struct ap_slice *head)
+static void ap_slice_chain_free(struct AP_bloom *bloom, struct ap_slice *head)
 {
     struct ap_slice *slice=NULL, *tmp=NULL;
     LL_FOREACH_SAFE(head, slice, tmp)
     {
         LL_DELETE(head, slice);
-        ap_slice_free(slice);
+        ap_slice_free(bloom, slice);
     }
 }
-static struct ap_slice *ap_slice_chain_duplicate(const struct ap_slice *src)
+static struct ap_slice *ap_slice_chain_duplicate(struct AP_bloom *bloom, const struct ap_slice *src)
 {
     struct ap_slice *new_head=NULL;
     const struct ap_slice *slice=NULL;
     LL_FOREACH(src, slice)
     {
-        struct ap_slice * new_slice=ap_slice_duplicate(slice);
+        struct ap_slice * new_slice=ap_slice_duplicate(bloom, slice);
         LL_APPEND(new_head, new_slice);
     }
     return new_head;
@@ -298,6 +342,16 @@ static size_t ap_slice_chain_mem_size(const struct ap_slice *head)
     }
     return sz;
 }
+static size_t ap_slice_chain_mem_blocks(const struct ap_slice *head)
+{
+    size_t blocks=0;
+    const struct ap_slice *slice=NULL;
+    LL_FOREACH(head, slice)
+    {
+        blocks += 2;
+    }
+    return blocks;
+}
 struct slice_chain_header
 {
     int chain_sequence;
@@ -343,14 +397,14 @@ static size_t ap_slice_chain_serialize(const struct ap_slice *head, int chain_se
     assert(offset<=buffer_sz);
     return offset;
 }
-static struct ap_slice *ap_slice_chain_deserialize(const char *buffer, size_t buffer_sz)
+static struct ap_slice *ap_slice_chain_deserialize(struct AP_bloom *bloom, const char *buffer, size_t buffer_sz)
 {
     struct slice_chain_header *header=(struct slice_chain_header*)buffer;
     size_t offset=sizeof(struct slice_chain_header);
     struct ap_slice *head=NULL;
     for(size_t i=0; i<header->slice_number; i++)
     {
-        struct ap_slice *slice = ap_slice_new(0, 0);
+        struct ap_slice *slice = ap_slice_new(bloom, 0, 0);
         memcpy(slice, buffer+offset, offsetof(struct ap_slice, data));
         offset += offsetof(struct ap_slice, data);
         slice->data = (unsigned char*) malloc(slice->slice_size);
@@ -364,7 +418,7 @@ static struct ap_slice *ap_slice_chain_deserialize(const char *buffer, size_t bu
     }
     return head;
 }
-static void ap_slice_merge(struct ap_slice *dst, const struct ap_slice *src)
+static void ap_slice_merge(struct AP_bloom *bloom, struct ap_slice *dst, const struct ap_slice *src)
 {
     assert(dst->hash_index == src->hash_index);
     assert(dst->slice_size == src->slice_size);
@@ -395,7 +449,7 @@ static void ap_slice_merge(struct ap_slice *dst, const struct ap_slice *src)
     }
     return;
 }
-static void ap_slice_chain_merge(struct ap_slice **dst_head, const struct ap_slice *src_head)
+static void ap_slice_chain_merge(struct AP_bloom *bloom, struct ap_slice **dst_head, const struct ap_slice *src_head)
 {
     const struct ap_slice *src_slice=NULL;
     int merged=0;
@@ -411,43 +465,20 @@ static void ap_slice_chain_merge(struct ap_slice **dst_head, const struct ap_sli
         {
             if(src_slice->slice_size == dst_slice->slice_size)
             {
-                ap_slice_merge(dst_slice, src_slice);
+                ap_slice_merge(bloom, dst_slice, src_slice);
                 merged=1;
                 break;
             }
         }
         if(!merged)
         {
-            struct ap_slice *new_slice = ap_slice_duplicate(src_slice);
+            struct ap_slice *new_slice = ap_slice_duplicate(bloom, src_slice);
             LL_APPEND(*dst_head, new_slice);
         }
     }
     LL_SORT(*dst_head, ap_slice_cmp);
     ap_slice_sanity(*dst_head);
 }
-struct AP_configuration
-{
-    double error;
-    long long capacity;
-    long long time_window_ms;
-    long long time_slice_num;
-    struct timeval last_cfg;
-};
-struct AP_bloom
-{
-    //high level variables determined by caller
-    struct AP_configuration cfg;
-
-    //low level variables caculated by the call configure
-    int hash_num;    //k
-    int chain_num;  //hash_num+time_slice_num
-    int default_slice_size; // in bytes
-    
-    //runtime variables
-    int cursor;
-    struct timeval last_slide;
-    struct ap_slice **heads; //hash_num+timeframe_num
-};
 #define DBL_EPSILON 2.2204460492503131e-16
 bool definitelyLessThan(float a, float b)
 {
@@ -481,8 +512,10 @@ struct AP_bloom *AP_bloom_new(struct timeval now, double error_rate, long long c
     bloom->heads = ALLOC(struct ap_slice*, bloom->chain_num);
     for(int i=0; i<bloom->chain_num; i++)
     {
-        bloom->heads[i] = ap_slice_new(bloom->default_slice_size, i % bloom->chain_num);
+        bloom->heads[i] = ap_slice_new(bloom, bloom->default_slice_size, i % bloom->chain_num);
     }
+    bloom->stat.expand_max_multiple_rt = 1;
+    bloom->stat.slice_num_rt = bloom->chain_num;
 
     return bloom;
 }
@@ -507,8 +540,8 @@ static void slide_time(struct AP_bloom *bloom, struct timeval now)
         for(int i=0; i<n_slide; i++)
         {
             int reset_idx = (bloom->cursor + bloom->hash_num) % chain_num;
-            struct ap_slice *slice = ap_slice_new(bloom->default_slice_size, bloom->heads[reset_idx]->hash_index);
-            ap_slice_chain_free(bloom->heads[reset_idx]);
+            struct ap_slice *slice = ap_slice_new(bloom, bloom->default_slice_size, bloom->heads[reset_idx]->hash_index);
+            ap_slice_chain_free(bloom, bloom->heads[reset_idx]);
             bloom->heads[reset_idx] = slice;
             bloom->cursor = (bloom->cursor + 1) % chain_num;
         }
@@ -517,8 +550,8 @@ static void slide_time(struct AP_bloom *bloom, struct timeval now)
     {
         for(int i=0; i<chain_num; i++)
         {
-            struct ap_slice *new_slice=ap_slice_new(bloom->default_slice_size, bloom->heads[i]->hash_index);
-            ap_slice_chain_free(bloom->heads[i]);
+            struct ap_slice *new_slice=ap_slice_new(bloom, bloom->default_slice_size, bloom->heads[i]->hash_index);
+            ap_slice_chain_free(bloom, bloom->heads[i]);
             bloom->heads[i] = new_slice;
         }
         bloom->cursor = (bloom->cursor + n_slide) % chain_num;
@@ -543,7 +576,7 @@ void AP_bloom_add(struct AP_bloom *bloom, struct timeval now, const char *buffer
     for(int i=0; i<bloom->hash_num; i++)
     {
         int idx=(bloom->cursor+i) % (bloom->chain_num);
-        ap_slice_chain_add_hash(&(bloom->heads[idx]), &hash, now);
+        ap_slice_chain_add_hash(bloom,&(bloom->heads[idx]), &hash, now);
     }
     return;
 }
@@ -560,8 +593,8 @@ int AP_bloom_check(const struct AP_bloom *bloom, struct timeval now, const char
 
     struct ap_state state;
     ap_state_init(&state, bloom->hash_num);
-    int max_num = bloom->hash_num+chain_num;
-    for(int i = 0; i < max_num; i++)
+    // int max_num = bloom->hash_num+chain_num;
+    for(int i = 0; i < chain_num; i++)
     {
         long long delta_us = timeval_delta_us(bloom->heads[i%chain_num]->last_insert, now);
         if(unlikely((delta_us > bloom->cfg.time_window_ms*1000) && bloom->cfg.time_window_ms))
@@ -583,7 +616,7 @@ void AP_bloom_free(struct AP_bloom *bloom)
 {
     for(int i=0; i<bloom->chain_num; i++)
     {
-        ap_slice_chain_free(bloom->heads[i]);
+        ap_slice_chain_free(bloom, bloom->heads[i]);
         bloom->heads[i]=NULL;
     }
     free(bloom->heads);
@@ -601,6 +634,17 @@ size_t AP_bloom_mem_size(const struct AP_bloom *bloom)
     }
     return sz;
 }
+size_t AP_bloom_mem_blocks(const struct AP_bloom *bloom)
+{
+    size_t blocks=0;
+    blocks++;
+    blocks += bloom->chain_num;
+    for(int i=0; i<bloom->chain_num; i++)
+    {
+        blocks += ap_slice_chain_mem_blocks(bloom->heads[i]);
+    }
+    return blocks;
+}
 size_t AP_bloom_serialize_size(const struct AP_bloom *bloom)
 {
     size_t sz=0;
@@ -635,7 +679,7 @@ struct AP_bloom * AP_bloom_deserialize(const char *blob, size_t blob_sz)
     bloom->heads=ALLOC(struct ap_slice*, bloom->chain_num);
     for(int i=0; i<bloom->chain_num; i++)
     {
-        bloom->heads[i]=ap_slice_chain_deserialize(blob+offset, blob_sz-offset);
+        bloom->heads[i]=ap_slice_chain_deserialize(bloom, blob+offset, blob_sz-offset);
         offset += ap_slice_chain_serialize_size(bloom->heads[i]);
     }
     assert(offset==blob_sz);
@@ -654,7 +698,7 @@ void AP_bloom_merge(struct AP_bloom *dst, const struct AP_bloom *src)
         {
             for(int i=0; i<dst->chain_num; i++)
             {
-                ap_slice_chain_free(dst->heads[i]);
+                ap_slice_chain_free(dst, dst->heads[i]);
             }
             
             memcpy(dst, src, offsetof(struct AP_bloom, heads));
@@ -662,7 +706,7 @@ void AP_bloom_merge(struct AP_bloom *dst, const struct AP_bloom *src)
             dst->heads = ALLOC(struct ap_slice*, dst->chain_num);
             for(int i=0; i<dst->chain_num; i++)
             {
-                dst->heads[i] = ap_slice_chain_duplicate(src->heads[i]);
+                dst->heads[i] = ap_slice_chain_duplicate(dst, src->heads[i]);
             }
         }
         return;
@@ -683,7 +727,7 @@ void AP_bloom_merge(struct AP_bloom *dst, const struct AP_bloom *src)
         {
             continue;
         }
-        ap_slice_chain_merge(&(dst->heads[i]), src->heads[i]);
+        ap_slice_chain_merge(dst,&(dst->heads[i]), src->heads[i]);
     }
     return;
 }
@@ -769,4 +813,29 @@ void AP_bloom_info(const struct AP_bloom *bloom, struct AP_bloom_info *info)
     info->approximate_item_num = approximate_item_num(bloom);
     info->oldest_item_time = oldest_item;
     return;
+}
+
+size_t AP_bloom_stat_get_hash_num(const struct AP_bloom *bloom)
+{
+    return bloom->hash_num;
+}
+size_t AP_bloom_stat_get_new_num(const struct AP_bloom *bloom)
+{
+    return bloom->stat.slice_new_num_acc;
+}
+size_t AP_bloom_stat_get_free_num(const struct AP_bloom *bloom)
+{
+    return bloom->stat.slice_free_num_acc;
+}
+size_t AP_bloom_stat_get_expand_num(const struct AP_bloom *bloom)
+{
+    return bloom->stat.expand_num_acc;
+}
+size_t AP_bloom_stat_get_cur_slice_num(const struct AP_bloom *bloom)
+{
+    return bloom->stat.slice_num_rt;
+}
+size_t AP_bloom_stat_get_expand_max_multiple(const struct AP_bloom *bloom)
+{
+    return bloom->stat.expand_max_multiple_rt;
 }
\ No newline at end of file
diff --git a/src/support/ap_bloom/src/ap_bloom.h b/src/support/ap_bloom/src/ap_bloom.h
index c40b5b9..672a75b 100644
--- a/src/support/ap_bloom/src/ap_bloom.h
+++ b/src/support/ap_bloom/src/ap_bloom.h
@@ -72,6 +72,13 @@ void AP_bloom_merge_blob(struct AP_bloom *dst, const char *blob, size_t blob_sz)
 struct AP_bloom *AP_bloom_replicate(uuid_t uuid, const char *blob, size_t blob_sz);
 size_t AP_bloom_serialized_size(const struct AP_bloom *bloom);
 size_t AP_bloom_mem_size(const struct AP_bloom *bloom);
+size_t AP_bloom_stat_get_hash_num(const struct AP_bloom *bloom);
+size_t AP_bloom_mem_blocks(const struct AP_bloom *bloom);
+size_t AP_bloom_stat_get_new_num(const struct AP_bloom *bloom);
+size_t AP_bloom_stat_get_free_num(const struct AP_bloom *bloom);
+size_t AP_bloom_stat_get_expand_num(const struct AP_bloom *bloom);
+size_t AP_bloom_stat_get_cur_slice_num(const struct AP_bloom *bloom);
+size_t AP_bloom_stat_get_expand_max_multiple(const struct AP_bloom *bloom);
 
 #ifdef __cplusplus
 }
diff --git a/src/support/dablooms/src/dablooms.c b/src/support/dablooms/src/dablooms.c
index 2c563da..7ecbe4d 100755
--- a/src/support/dablooms/src/dablooms.c
+++ b/src/support/dablooms/src/dablooms.c
@@ -337,12 +337,18 @@ counting_bloom_t *new_counting_bloom_from_scale(scaling_bloom_t *bloom, struct d
     bloom->blooms[bloom->num_blooms] = cur_bloom;
     
     bloom->bitmap = bitmap_resize(bloom->bitmap, bloom->num_bytes, bloom->num_bytes + cur_bloom->num_bytes, mstat);
+
+    if(bloom->num_bytes > sizeof(scaling_bloom_header_t)){
+        bloom->stat.expand_num_acc++;
+        bloom->stat.expand_size_ratio_rt *= (double)(bloom->num_bytes + cur_bloom->num_bytes) / bloom->num_bytes;
+    }
     
     /* reset header pointer, as mmap may have moved */
     bloom->header = (scaling_bloom_header_t *) bloom->bitmap->array;
     
     /* Set the pointers for these header structs to the right location since mmap may have moved */
     bloom->num_blooms++;
+    bloom->stat.slice_num_rt = bloom->num_blooms;
     for (unsigned int i = 0; i < bloom->num_blooms; i++) {
         offset = bloom->blooms[i]->offset - sizeof(counting_bloom_header_t);
         bloom->blooms[i]->header = (counting_bloom_header_t *) (bloom->bitmap->array + offset);
@@ -479,7 +485,6 @@ scaling_bloom_t *scaling_bloom_init(unsigned int capacity, double error_rate,str
 
 static scaling_bloom_t *new_scaling_bloom(unsigned int capacity, double error_rate, struct dabm_mem_stat *mstat)
 {
-
     scaling_bloom_t *bloom;
     counting_bloom_t *cur_bloom;
     
@@ -495,6 +500,7 @@ static scaling_bloom_t *new_scaling_bloom(unsigned int capacity, double error_ra
     cur_bloom->header->id = 0;
     
     bloom->header->mem_seqnum = 1;
+    bloom->stat.expand_size_ratio_rt = 1.0;
     return bloom;
 }
 
@@ -512,6 +518,8 @@ struct expiry_dablooms_handle_entity{
     long transition_time_ms;
     double error_rate;
     struct dabm_mem_stat mstat;
+    size_t bloom_new_num;
+    size_t bloom_free_num;
 };
 
 /* 24.05, split bloomfilter into multiple partition to avoid blocking caused by memset large memory */
@@ -566,6 +574,7 @@ static struct expiry_dablooms_handle_entity* expiry_dablooms_init_entity(unsigne
     handle->expiry_time_ms = expiry_time_ms;
     handle->cur_time_ms = cur_time_ms;
     handle->transition_time_ms = transition_time_ms; 
+    handle->bloom_new_num++;
     return handle;
     
 error_out:
@@ -633,6 +642,7 @@ static int bloom_expired_check(struct expiry_dablooms_handle_entity *handle, lon
     handle->cur_time_ms=cur_time_ms;
     if(unlikely(delta_time_ms >= handle->expiry_time_ms)){
         free_scaling_bloom(handle->cur_bloom, mstat);
+        handle->bloom_free_num++;
         if(handle->next_bloom != NULL){
             handle->cur_bloom = handle->next_bloom;
             handle->cur_bloom_start_ms = handle->next_bloom_start_ms;
@@ -645,10 +655,11 @@ static int bloom_expired_check(struct expiry_dablooms_handle_entity *handle, lon
             if(unlikely(cur_bloom == NULL)){
                 return EXPIRY_DABLOOMS_ERRNO_NEW_BLOOM_FAIL;
             }
+            handle->bloom_new_num++;
             handle->cur_bloom = cur_bloom;
             handle->cur_bloom_inc_id = 0;
             handle->cur_bloom_start_ms=cur_time_ms;
-             handle->last_bloom_check_ms=0;
+            handle->last_bloom_check_ms=0;
         }
     }
     else 
@@ -678,6 +689,7 @@ static int expiry_dablooms_add_entity(struct expiry_dablooms_handle_entity *hand
             if(next_bloom == NULL){
                 return EXPIRY_DABLOOMS_ERRNO_NEW_BLOOM_FAIL;
             }
+            handle->bloom_new_num++;
             handle->next_bloom = next_bloom;
             handle->next_bloom_inc_id = 0;
             handle->next_bloom_start_ms=cur_time_ms;
@@ -752,4 +764,79 @@ int expiry_dablooms_get_mem_stat(struct expiry_dablooms_handle *handle, long lon
     *blocks = tot_blocks;
     *bytes = tot_bytes;
     return 0;
+}
+
+size_t DA_bloom_stat_get_slice_new_num(const struct expiry_dablooms_handle *bloom)
+{
+    size_t tot_num = 0;
+    for(int i = 0; i < bloom->bm_partition_num; i++){
+        const struct expiry_dablooms_handle_entity *bm_entity = bloom->bm_handle[i];
+        tot_num += bm_entity->bloom_new_num;
+    }
+    return tot_num;
+}
+
+size_t DA_bloom_stat_get_slice_free_num(const struct expiry_dablooms_handle *bloom)
+{
+    size_t tot_num = 0;
+    for(int i = 0; i < bloom->bm_partition_num; i++){
+        const struct expiry_dablooms_handle_entity *bm_entity = bloom->bm_handle[i];
+        tot_num += bm_entity->bloom_free_num;
+    }
+    return tot_num;
+}
+
+size_t DA_bloom_stat_get_hash_num(const struct expiry_dablooms_handle *bloom)
+{
+    if(bloom->bm_handle != NULL && bloom->bm_handle[0] != NULL){
+        const struct expiry_dablooms_handle_entity *bm_entity = bloom->bm_handle[0];
+        return ceil(log(1 / bm_entity->error_rate ) / log(2));
+    }
+    return 0;
+}
+size_t DA_bloom_stat_get_expand_num(const struct expiry_dablooms_handle *bloom)
+{
+    size_t tot_num = 0;
+    for(int i = 0; i < bloom->bm_partition_num; i++){
+        const struct expiry_dablooms_handle_entity *bm_entity = bloom->bm_handle[i];
+        if(bm_entity->cur_bloom){
+            tot_num += bm_entity->cur_bloom->stat.expand_num_acc;
+        }
+        if(bm_entity->next_bloom){
+            tot_num += bm_entity->next_bloom->stat.expand_num_acc;
+        }
+    }
+    return tot_num;
+}
+size_t DA_bloom_stat_get_cur_slice_num(const struct expiry_dablooms_handle *bloom)
+{
+    size_t tot_num = 0;
+    for(int i = 0; i < bloom->bm_partition_num; i++){
+        const struct expiry_dablooms_handle_entity *bm_entity = bloom->bm_handle[i];
+        if(bm_entity->cur_bloom){
+            tot_num += bm_entity->cur_bloom->stat.slice_num_rt;
+        }
+        if(bm_entity->next_bloom){
+            tot_num += bm_entity->next_bloom->stat.slice_num_rt;
+        }
+    }
+    return tot_num;
+}
+size_t DA_bloom_stat_get_resize_ratio(const struct expiry_dablooms_handle *bloom)
+{
+    double max_ratio = 1.000;
+    for(int i = 0; i < bloom->bm_partition_num; i++){
+        const struct expiry_dablooms_handle_entity *bm_entity = bloom->bm_handle[i];
+        if(bm_entity->cur_bloom){
+            if(bm_entity->cur_bloom->stat.expand_size_ratio_rt > max_ratio){
+                max_ratio = bm_entity->cur_bloom->stat.expand_size_ratio_rt;
+            }
+        }
+        if(bm_entity->next_bloom){
+            if(bm_entity->next_bloom->stat.expand_size_ratio_rt > max_ratio){
+                max_ratio = bm_entity->next_bloom->stat.expand_size_ratio_rt;
+            }
+        }
+    }
+    return (size_t)(max_ratio * 100.0);
 }
\ No newline at end of file
diff --git a/src/support/dablooms/src/dablooms.h b/src/support/dablooms/src/dablooms.h
index 85886b4..1c5a342 100755
--- a/src/support/dablooms/src/dablooms.h
+++ b/src/support/dablooms/src/dablooms.h
@@ -41,7 +41,11 @@ typedef struct {
     uint32_t _pad;
 } counting_bloom_header_t;
 
-
+struct DA_bloom_stat{
+    size_t expand_num_acc;
+    double expand_size_ratio_rt; //current bitmap size / defalut bitmap size  * 100
+    size_t slice_num_rt;
+};
 typedef struct {
     counting_bloom_header_t *header;
     unsigned int capacity;
@@ -75,6 +79,7 @@ typedef struct {
     double error_rate;
     counting_bloom_t **blooms;
     bitmap_t *bitmap;
+    struct DA_bloom_stat stat;
 } scaling_bloom_t;
 
 // scaling_bloom_t *new_scaling_bloom(unsigned int capacity, double error_rate);
@@ -98,6 +103,12 @@ int expiry_dablooms_element_count_get(struct expiry_dablooms_handle *handle, uin
 int expiry_dablooms_add(struct expiry_dablooms_handle *handle, const char *key, size_t len,  time_t cur_time);
 int expiry_dablooms_search(struct expiry_dablooms_handle *handle, const char *key, size_t len,  time_t cur_time);
 int expiry_dablooms_get_mem_stat(struct expiry_dablooms_handle *handle, long long *blocks, long long *bytes);
+size_t DA_bloom_stat_get_slice_new_num(const struct expiry_dablooms_handle *bloom);
+size_t DA_bloom_stat_get_slice_free_num(const struct expiry_dablooms_handle *bloom);
+size_t DA_bloom_stat_get_hash_num(const struct expiry_dablooms_handle *bloom);
+size_t DA_bloom_stat_get_expand_num(const struct expiry_dablooms_handle *bloom);
+size_t DA_bloom_stat_get_cur_slice_num(const struct expiry_dablooms_handle *bloom);
+size_t DA_bloom_stat_get_resize_ratio(const struct expiry_dablooms_handle *bloom);
 #ifdef __cplusplus 
 }
 #endif