diff --git a/src/entry/Maat_api.cpp b/src/entry/Maat_api.cpp
index f2dcc17..088ffa2 100644
--- a/src/entry/Maat_api.cpp
+++ b/src/entry/Maat_api.cpp
@@ -188,7 +188,7 @@ int exprid2region_id(struct _Maat_group_inner_t* group_rule,int expr_id,int* dis
 	int i=0,region_id=-1;
 	struct _Maat_region_inner_t* region_rule=NULL;
 	assert(group_rule->group_id>=0);
-	pthread_mutex_lock(&(group_rule->mutex));
+	pthread_rwlock_rdlock(&(group_rule->rwlock));
 	for(i=0;i<group_rule->region_boundary;i++)
 	{
 		region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group_rule->regions, i);
@@ -203,7 +203,7 @@ int exprid2region_id(struct _Maat_group_inner_t* group_rule,int expr_id,int* dis
 			break;
 		}
 	}
-	pthread_mutex_unlock(&(group_rule->mutex));
+	pthread_rwlock_unlock(&(group_rule->rwlock));
 	return region_id;
 }
 int match_district(struct _OUTER_scan_status_t *_mid,scan_result_t *region_hit,int region_hit_num)
diff --git a/src/entry/Maat_rule.cpp b/src/entry/Maat_rule.cpp
index 2fb4bc2..bc25c15 100644
--- a/src/entry/Maat_rule.cpp
+++ b/src/entry/Maat_rule.cpp
@@ -25,8 +25,8 @@
 #include "map_str2int.h"
 #include "rulescan.h"
 #include "UniversalBoolMatch.h"
-#include "stream_fuzzy_hash.h"
-#include "gram_index_engine.h"
+#include "mesa_fuzzy.h"
+#include "great_index_engine.h"
 
 int MAAT_FRAME_VERSION_2_0_20170807=1;
 const char *maat_module="MAAT Frame";
@@ -61,18 +61,6 @@ int  hex2bin(char *hex,int hex_len,char *binary,int size)
 	binary[resultlen]='\0';
 	return resultlen;
 }
-//functioned as strdup, for dictator compatible.
-char* _maat_strdup(const char* s)
-{
-	char*d=NULL;
-	if(s==NULL)
-	{
-		return NULL;
-	}
-	d=(char*)malloc(strlen(s)+1);
-	memcpy(d,s,strlen(s)+1);
-	return d;
-}
 int is_valid_expr_type(enum MAAT_EXPR_TYPE expr_type)
 {
 	switch(expr_type)
@@ -93,7 +81,7 @@ int is_valid_match_method(enum MAAT_MATCH_METHOD match_method)
 		case MATCH_METHOD_SUB:
 		case MATCH_METHOD_RIGHT:
 		case MATCH_METHOD_LEFT:
-		case MATCH_METHOD_COMPLETE:
+		case MATCH_METHOD_FULL:
 			return 1;
 		default:
 			return 0;
@@ -414,39 +402,6 @@ char* str_unescape(char* s)
 	s[j]='\0';
 	return s;
 }
-char* Maat_str_escape(char* dst,int size,const char*src)
-{
-	int i=0,j=0;
-	int len=strlen(src);
-	for(i=0,j=0;i<len&&j<size;i++)
-	{
-		switch(src[i])
-		{
-			case '&':
-				dst[j]='\\';
-				dst[j+1]='&';
-				j+=2;
-				break;
-			case ' ':
-				dst[j]='\\';
-				dst[j+1]='b';//space,0x20;
-				j+=2;
-				break;
-			case '\\':
-				dst[j]='\\';
-				dst[j+1]='\\';
-				j+=2;
-				break;
-			default:
-				dst[j]=src[i];
-				j++;	//undo the followed i++
-				break;
-
-		}
-	}
-	dst[j]='\0';
-	return dst;
-}
 int cnt_maskbits(struct in6_addr mask)
 {
 	unsigned int i=0;
@@ -507,77 +462,17 @@ void destroy_table_info(struct _Maat_table_info_t*p)
 	aligment_int64_array_free(p->input_bytes);
 	aligment_int64_array_free(p->stream_num);
 	aligment_int64_array_free(p->hit_cnt);
-	if(p->cb_info!=NULL)
-	{
-		dynamic_array_destroy(p->cb_info->cache_lines, free);
-		p->cb_info->cache_lines=NULL;
-		free(p->cb_info);
-		p->cb_info=NULL;
-	}
 	free(p);
 	return;
 }
-int read_expr_table_info(const char* line,int line_num,struct _Maat_table_info_t* p,MESA_htable_handle string2int_map)
-{
-	int j=0,ret[4]={0};
-	char table_type[16],src_charset[256],dst_charset[256],merge[4],quick_str_scan[32]={0};
-	char *token=NULL,*sub_token=NULL,*saveptr;
-
-	sscanf(line,"%hu\t%s\t%s\t%s\t%s\t%s\t%d\t%s",&(p->table_id)
-											,p->table_name[0]
-											,table_type
-											,src_charset
-											,dst_charset
-											,merge
-											,&(p->cross_cache_size)
-											,quick_str_scan);
-	memset(ret,0,sizeof(ret));
-	ret[0]=map_str2int(string2int_map,strlwr(table_type),(int*)&(p->table_type));
-	ret[1]=map_str2int(string2int_map,strlwr(src_charset),(int*)&(p->src_charset));
-	ret[2]=map_str2int(string2int_map,strlwr(merge),&(p->do_charset_merge));
-	if(strlen(quick_str_scan)>0)
-	{
-		ret[3]=map_str2int(string2int_map,strlwr(quick_str_scan),&(p->quick_expr_switch));
-	}
-	memset(quick_str_scan,0,sizeof(quick_str_scan));
-
-	for(j=0;j<4;j++)
-	{
-		if(ret[j]<0)
-		{
-			return -1;
-		}
-	}
-	j=0;
-	for (token = dst_charset; ; token= NULL)
-	{
-		sub_token= strtok_r(token,"/", &saveptr);
-		if (sub_token == NULL)
-			break;
-		ret[3]=map_str2int(string2int_map,strlwr(sub_token),(int*)&(p->dst_charset[j]));
-		if(ret[3]>0)
-		{
-			if(p->dst_charset[j]==p->src_charset)
-			{
-				p->src_charset_in_dst=TRUE;
-			}
-			j++;
-		}
-		else
-		{
-			return -1;
-		}
-		
-	}
-	return 0;
-}
 int read_table_info(struct _Maat_table_info_t** p_table_info,int num,const char* table_info_path,int max_thread_num,void* logger)
 {
 	FILE*fp=NULL;
 	char line[MAX_TABLE_LINE_SIZE];
-	int i=0,ret=0,table_cnt=0;
-	char table_type_str[16],not_care[256];
+	int i=0,j=0,ret[4]={0},table_cnt=0;
+	char table_type[16],src_charset[256],dst_charset[256],merge[4],quick_str_scan[32]={0};
 	MESA_htable_handle string2int_map=map_create();
+	char *token=NULL,*sub_token=NULL,*saveptr;
 	struct _Maat_table_info_t*p=NULL;
 	struct _Maat_table_info_t*conj_table=NULL;
 	
@@ -585,11 +480,10 @@ int read_table_info(struct _Maat_table_info_t** p_table_info,int num,const char*
 	map_register(string2int_map,"ip", TABLE_TYPE_IP);
 	map_register(string2int_map,"compile", TABLE_TYPE_COMPILE);
 	map_register(string2int_map,"plugin", TABLE_TYPE_PLUGIN);
-	map_register(string2int_map,"intval", TABLE_TYPE_INTERVAL);
+	map_register(string2int_map,"intval", TABLE_TYPE_INTVAL);
 	map_register(string2int_map,"digest", TABLE_TYPE_DIGEST);
 	map_register(string2int_map,"expr_plus", TABLE_TYPE_EXPR_PLUS);
 	map_register(string2int_map,"group", TABLE_TYPE_GROUP);
-	map_register(string2int_map,"similar", TABLE_TYPE_SIMILARITY);
 	map_register(string2int_map,"quickoff",0);
 	map_register(string2int_map,"quickon",1);
 	for(i=0;i<MAX_CHARSET_NUM;i++)
@@ -604,6 +498,14 @@ int read_table_info(struct _Maat_table_info_t** p_table_info,int num,const char*
 		}
 	}
 
+/*
+	map_register(string2int_map,"gbk", CHARSET_GBK);
+	map_register(string2int_map,"big5", CHARSET_BIG5);
+	map_register(string2int_map,"unicode", CHARSET_UNICODE);
+	map_register(string2int_map,"utf8", CHARSET_UTF8);
+	map_register(string2int_map,"unicode_hex", CHARSET_UNICODE_ASCII_ESC);
+	map_register(string2int_map,"unicode_hex", CHARSET_UNICODE_ASCII_ESC);
+*/
 	map_register(string2int_map,"yes", 1);
 	map_register(string2int_map,"no", 0);
 	
@@ -625,43 +527,57 @@ int read_table_info(struct _Maat_table_info_t** p_table_info,int num,const char*
 		}
 		p=create_table_info(max_thread_num);
 
-		sscanf(line,"%hu\t%s\t%s\t%s",&(p->table_id)
+		sscanf(line,"%hu\t%s\t%s\t%s\t%s\t%s\t%d\t%s",&(p->table_id)
 											,p->table_name[0]
-											,table_type_str
-											,not_care);
-		ret=map_str2int(string2int_map,strlwr(table_type_str),(int*)&(p->table_type));
-		if(ret<0)
+											,table_type
+											,src_charset
+											,dst_charset
+											,merge
+											,&(p->cross_cache_size)
+											,quick_str_scan);
+		ret[0]=map_str2int(string2int_map,strlwr(table_type),(int*)&(p->table_type));
+		ret[1]=map_str2int(string2int_map,strlwr(src_charset),(int*)&(p->src_charset));
+		ret[2]=map_str2int(string2int_map,strlwr(merge),&(p->do_charset_merge));
+		if(strlen(quick_str_scan)>0)
 		{
-			MESA_handle_runtime_log(logger, RLOG_LV_FATAL,maat_module,
-						"Maat read table info %s line %d error:invalid table type.",table_info_path,i);
-			goto error_jump;
-		}
-		switch(p->table_type)
-		{
-			case TABLE_TYPE_EXPR:
-			case TABLE_TYPE_EXPR_PLUS:
-				ret=read_expr_table_info(line, i, p, string2int_map);
-				if(ret<0)
-				{
-					fprintf(stderr,"Maat read table info %s line %d error:unknown column.\n",table_info_path,i);
-					MESA_handle_runtime_log(logger, RLOG_LV_FATAL,maat_module,
-									"Maat read table info %s line %d error:unknown column.",table_info_path,i);
-					goto error_jump;
-				}
-				break;
-			case TABLE_TYPE_PLUGIN:
-				p->cb_info=(struct _plugin_table_info*)calloc(sizeof(struct _plugin_table_info),1);
-				p->cb_info->cache_lines=dynamic_array_create(1024,1024);
-				ret=sscanf(not_care,"%d",&(p->valid_flag_column));
-				if(ret==0||ret==EOF)
-				{
-					p->valid_flag_column=-1;
-				}
-				break;
-			default:
-				break;
+			ret[3]=map_str2int(string2int_map,strlwr(quick_str_scan),&(p->quick_expr_switch));
 		}
+		memset(quick_str_scan,0,sizeof(quick_str_scan));
 
+		for(j=0;j<4;j++)
+		{
+			if(ret[j]<0)
+			{
+				fprintf(stderr,"Maat read table info %s line %d error:unknown column.\n",table_info_path,i);
+				MESA_handle_runtime_log(logger, RLOG_LV_FATAL,maat_module,
+								"Maat read table info %s line %d error:unknown column.",table_info_path,i);
+				goto error_jump;
+			}
+		}
+		j=0;
+		for (token = dst_charset; ; token= NULL)
+		{
+			sub_token= strtok_r(token,"/", &saveptr);
+			if (sub_token == NULL)
+				break;
+			ret[3]=map_str2int(string2int_map,strlwr(sub_token),(int*)&(p->dst_charset[j]));
+			if(ret[3]>0)
+			{
+				if(p->dst_charset[j]==p->src_charset)
+				{
+					p->src_charset_in_dst=TRUE;
+				}
+				j++;
+			}
+			else
+			{
+				fprintf(stderr,"Maat read table info %s line %d error:unknown dest charset %s.\n",table_info_path,i,sub_token);
+				MESA_handle_runtime_log(logger, RLOG_LV_FATAL,maat_module,
+								"Maat read table info %s line %d error: unknown dest charset %s.",table_info_path,i,sub_token);
+				goto error_jump;
+			}
+			
+		}
 		if(p->table_id>=num)
 		{
 			fprintf(stderr,"Maat read table info %s:%d error: table id %uh > %d.\n",table_info_path,i,p->table_id,num);
@@ -689,7 +605,11 @@ int read_table_info(struct _Maat_table_info_t** p_table_info,int num,const char*
 			//use goto to free the conjunctioned table_info
 			goto error_jump;
 		}
-
+		if(p->table_type==TABLE_TYPE_PLUGIN)
+		{
+			p->cb_info=(struct _plugin_table_info*)calloc(sizeof(struct _plugin_table_info),1);
+			p->cb_info->cache_lines=dynamic_array_create(1024,1024);
+		}
 		p_table_info[p->table_id]=p;
 		table_cnt++;
 		continue;
@@ -701,21 +621,19 @@ error_jump:
 	map_destroy(string2int_map);
 	return table_cnt;
 }
-struct _Maat_group_inner_t* create_group_rule(int group_id)
+struct _Maat_group_rule_t* create_group_rule(int group_id)
 {
-	struct _Maat_group_inner_t* group=(struct _Maat_group_inner_t*)malloc(sizeof(struct _Maat_group_inner_t));
+	struct _Maat_group_rule_t* group=(struct _Maat_group_rule_t*)malloc(sizeof(struct _Maat_group_rule_t));
 	group->group_id=group_id;
 	group->region_cnt=0;
 	group->region_boundary=0;
 	group->ref_cnt=0;
-	group->regions=dynamic_array_create(1,8);
+	group->region_rules=dynamic_array_create(1,8);
 	group->compile_shortcut=NULL;
-	group->table_id=0;
-	group->group_name=NULL;
-	pthread_mutex_init(&(group->mutex), NULL);
+	pthread_rwlock_init(&(group->rwlock), NULL);
 	return group;
 }
-void destroy_group_rule(struct _Maat_group_inner_t* group)
+void destroy_group_rule(struct _Maat_group_rule_t* group)
 {
 
 	if(group->ref_cnt>0||group->region_cnt>0)
@@ -723,28 +641,25 @@ void destroy_group_rule(struct _Maat_group_inner_t* group)
 		return;
 	}
 
-	dynamic_array_destroy(group->regions,free);
+	dynamic_array_destroy(group->region_rules,free);
 	group->region_cnt=0;
 	group->region_boundary=0;
-	group->regions=NULL;
+	group->region_rules=NULL;
 	group->ref_cnt=0;
 	group->group_id=-1;
-	group->table_id=-1;
-	free(group->group_name);
-	group->group_name=NULL;
-	pthread_mutex_destroy(&(group->mutex));
+	pthread_rwlock_destroy(&(group->rwlock));
 	free(group);
 
 }
-void make_group_set(const struct _Maat_compile_inner_t* compile_rule,universal_bool_expr_t* a_set)
+void make_group_set(const struct _Maat_compile_rule_t* compile_rule,universal_bool_expr_t* a_set)
 {
 	int i=0,j=0;
 	a_set->bool_expr_id=(void*)compile_rule;
-	struct _Maat_group_inner_t*group=NULL;
-	assert(compile_rule->group_cnt<=MAX_ITEMS_PER_BOOL_EXPR);
-	for(i=0,j=0;i<compile_rule->group_boundary&&j<MAX_ITEMS_PER_BOOL_EXPR;i++)
+	struct _Maat_group_rule_t*group=NULL;
+	assert(MAAT_MAX_EXPR_ITEM_NUM<=MAX_ITEMS_PER_BOOL_EXPR);
+	for(i=0,j=0;i<MAAT_MAX_EXPR_ITEM_NUM&&j<MAX_ITEMS_PER_BOOL_EXPR;i++)
 	{
-		group=(struct _Maat_group_inner_t*)dynamic_array_read(compile_rule->groups,i);
+		group=(struct _Maat_group_rule_t*)dynamic_array_read(compile_rule->groups,i);
 		if(group==NULL)
 		{
 			continue;
@@ -758,7 +673,7 @@ void make_group_set(const struct _Maat_compile_inner_t* compile_rule,universal_b
 void walk_compile_hash(const uchar * key, uint size, void * data, void * user)
 {
 	universal_bool_expr_t* one_set=NULL;
-	struct _Maat_compile_inner_t* compile_rule=(struct _Maat_compile_inner_t*)data;
+	struct _Maat_compile_rule_t* compile_rule=(struct _Maat_compile_rule_t*)data;
 	MESA_lqueue_head update_q=(MESA_lqueue_head)user;
 	if(compile_rule->db_c_rule==NULL)
 	{
@@ -830,26 +745,24 @@ void EMPTY_FREE(void*p)
 {
 	return;
 }
-struct _Maat_compile_inner_t * create_compile_rule(int compile_id)
+struct _Maat_compile_rule_t * create_compile_rule(int compile_id)
 {
-	struct _Maat_compile_inner_t* p=NULL;
-	p=(struct _Maat_compile_inner_t*)calloc(sizeof(struct _Maat_compile_inner_t),1);
+	struct _Maat_compile_rule_t* p=NULL;
+	p=(struct _Maat_compile_rule_t*)calloc(sizeof(struct _Maat_compile_rule_t),1);
 	p->compile_id=compile_id;
 	p->group_cnt=0;
-	p->table_id=0;
-	p->group_boundary=1;
 	p->groups=dynamic_array_create(1, 1);
 	pthread_rwlock_init(&(p->rwlock), NULL);
 	return p;
 }
-void destroy_compile_rule(struct _Maat_compile_inner_t * p)
+void destroy_compile_rule(struct _Maat_compile_rule_t * p)
 {
 	int i=0;
-	struct _Maat_compile_inner_t* p_group=NULL;
+	struct _Maat_compile_rule_t* p_group=NULL;
 	assert(p->group_cnt==0);
-	for(i=0;i<p->group_boundary;i++)
+	for(i=0;i<MAAT_MAX_EXPR_ITEM_NUM;i++)
 	{
-		p_group=(struct _Maat_compile_inner_t*)dynamic_array_read(p->groups,i);
+		p_group=(struct _Maat_compile_rule_t*)dynamic_array_read(p->groups,i);
 		assert(p_group==NULL);
 	}
 	p->compile_id=-1;
@@ -873,7 +786,7 @@ scan_rule_t* create_rs_str_rule(unsigned int sub_type,enum MAAT_MATCH_METHOD mat
 	p_rule->string_rule.r_offset=-1;
 	switch(match_method)
 	{
-		case MATCH_METHOD_COMPLETE:
+		case MATCH_METHOD_FULL:
 			p_rule->string_rule.match_mode=1;
 			break;
 		case MATCH_METHOD_LEFT:
@@ -986,18 +899,18 @@ void op_expr_add_rule(struct op_expr_t* op_expr,scan_rule_t* p_rule)
 	op_expr->rule_type=p_rule->rule_type;
 	return;
 }
-GIE_digest_t* create_digest_rule(int id,short op,const char* digest,
-						short cfds_lvl,struct _Maat_group_inner_t* tag)
+GIE_digest_t* create_digest_rule(int id,short op,unsigned long long origin_len,const char* digest,
+						short cfds_lvl,struct _Maat_group_rule_t* tag)
 {
 	GIE_digest_t* rule=(GIE_digest_t*)calloc(sizeof(GIE_digest_t),1);
 	int digest_len=strlen(digest);
 	rule->id=id;
 	rule->operation=op;
-	rule->sfh_length=digest_len;
+	rule->origin_len=origin_len;
 	if(digest!=NULL)
 	{
-		rule->sfh=(char*)calloc(sizeof(char),digest_len+1);
-		memcpy(rule->sfh,digest,digest_len);
+		rule->fuzzy_hash=(char*)calloc(sizeof(char),digest_len+1);
+		memcpy(rule->fuzzy_hash,digest,digest_len);
 
 	}
 	rule->cfds_lvl=cfds_lvl;
@@ -1006,10 +919,10 @@ GIE_digest_t* create_digest_rule(int id,short op,const char* digest,
 }
 void destroy_digest_rule(GIE_digest_t*rule)
 {
-	if(rule->sfh!=NULL)
+	if(rule->fuzzy_hash!=NULL)
 	{
-		free(rule->sfh);
-		rule->sfh=NULL;
+		free(rule->fuzzy_hash);
+		rule->fuzzy_hash=NULL;
 	}
 	free(rule);
 	rule=NULL;
@@ -1044,17 +957,15 @@ struct _Maat_scanner_t* create_maat_scanner(unsigned int version,_Maat_feather_t
 	struct _Maat_scanner_t* scanner=NULL;
 	scanner=(struct _Maat_scanner_t*)calloc(sizeof(struct _Maat_scanner_t),1);
 
-	//Function Maat_cmd_append will access compile_hash in user thread.
-	hargs.thread_safe=1;
 	scanner->compile_hash=MESA_htable_create(&hargs, sizeof(hargs));
 	MESA_htable_print_crtl(scanner->compile_hash,0);
 
-	hargs.thread_safe=1;
+
 	hargs.data_free=EMPTY_FREE;
 	scanner->group_hash=MESA_htable_create(&hargs, sizeof(hargs));
 	MESA_htable_print_crtl(scanner->group_hash,0);
 
-	hargs.thread_safe=0;
+
 	scanner->region_hash=MESA_htable_create(&hargs, sizeof(hargs));
 	MESA_htable_print_crtl(scanner->region_hash,0);
 
@@ -1093,9 +1004,8 @@ struct _Maat_scanner_t* create_maat_scanner(unsigned int version,_Maat_feather_t
 		switch(pp_table[i]->table_type)
 		{
 			case TABLE_TYPE_DIGEST:
-			case TABLE_TYPE_SIMILARITY:
-				scanner->gie_aux[i].table_type=pp_table[i]->table_type;
-				scanner->gie_aux[i].update_q=MESA_lqueue_create(0,0);
+				scanner->digest_update_q[i]=MESA_lqueue_create(0,0);
+				pthread_rwlock_init(&(scanner->digest_rwlock[i]),NULL);
 				break;
 			case TABLE_TYPE_EXPR:
 			case TABLE_TYPE_EXPR_PLUS:
@@ -1161,23 +1071,24 @@ void destroy_maat_scanner(struct _Maat_scanner_t*scanner)
 	}
 	for(i=0;i<MAX_TABLE_NUM;i++)
 	{
-		if(scanner->gie_aux[i].gie_handle!=NULL)
+		if(scanner->digest_handle[i]!=NULL)
 		{
-			GIE_destory(scanner->gie_aux[i].gie_handle);
+			GIE_destory(scanner->digest_handle[i]);
 		}
-		if(scanner->gie_aux[i].update_q==NULL)
+		if(scanner->digest_update_q[i]==NULL)
 		{
 			continue;
 		}
-		q_cnt=MESA_lqueue_get_count(scanner->gie_aux[i].update_q);
+		q_cnt=MESA_lqueue_get_count(scanner->digest_update_q[i]);
 		for(j=0;j<q_cnt;j++)
 		{
 			data_size=sizeof(GIE_digest_t*);
-			q_ret=(MESA_queue_errno_t)MESA_lqueue_get_head(scanner->gie_aux[i].update_q,&digest_rule,&data_size);
+			q_ret=(MESA_queue_errno_t)MESA_lqueue_get_head(scanner->digest_update_q[i],&digest_rule,&data_size);
 			assert(data_size==sizeof(void*)&&q_ret==MESA_QUEUE_RET_OK);
 			destroy_digest_rule(digest_rule);
 		}
-		MESA_lqueue_destroy(scanner->gie_aux[i].update_q, lqueue_destroy_cb, NULL);
+		MESA_lqueue_destroy(scanner->digest_update_q[i], lqueue_destroy_cb, NULL);
+		pthread_rwlock_destroy(&(scanner->digest_rwlock[i]));
 	}
 	free(scanner);
 	return;
@@ -1381,176 +1292,133 @@ void digest_batch_update(GIE_handle_t* handle,MESA_lqueue_head update_q,void*log
 	update_array=NULL;
 	return;
 }
-struct _Maat_group_inner_t* add_region_to_group(struct _Maat_group_inner_t* group,int table_id,int region_id,int district_id,int expr_id,enum MAAT_TABLE_TYPE region_type)
+struct _Maat_group_rule_t* add_region_to_group(struct _Maat_group_rule_t* group,int region_id,int district_id,int expr_id,enum MAAT_TABLE_TYPE region_type)
 {
-	int i=0;
-	struct _Maat_region_inner_t* region_rule=NULL;
-	for(i=0;i<group->region_boundary;i++)
-	{
-		region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group->regions, i);
-		if(region_rule==NULL)
-		{
-			continue;
-		}
-		if(region_rule->region_id==region_id)
-		{
-			break;
-		}
-	}
-	if(i==group->region_boundary)//new region
-	{
-		region_rule=(struct _Maat_region_inner_t*)malloc(sizeof(struct _Maat_region_inner_t));
-		region_rule->region_id=region_id;
-		region_rule->expr_id_cnt=1;
-		region_rule->expr_id_ub=region_rule->expr_id_lb=expr_id;
-		region_rule->district_id=district_id;
-		region_rule->table_type=region_type;
-		region_rule->table_id=table_id;
-		pthread_mutex_lock(&(group->mutex));
-		dynamic_array_write(group->regions,group->region_boundary,region_rule);
-		group->region_cnt++;
-		group->region_boundary++;
-		pthread_mutex_unlock(&(group->mutex));
-	}
-	else
-	{
-		assert(expr_id==region_rule->expr_id_ub+1);
-		region_rule->expr_id_ub=expr_id;
-		region_rule->expr_id_cnt++;
-	}
+	struct _Maat_region_rule_t* region_rule=(struct _Maat_region_rule_t*)malloc(sizeof(struct _Maat_region_rule_t));
+	region_rule->region_id=region_id;
+	region_rule->expr_id=expr_id;
+	region_rule->district_id=district_id;
+	region_rule->region_type=region_type;
+	pthread_rwlock_wrlock(&(group->rwlock));
+	dynamic_array_write(group->region_rules,group->region_boundary,region_rule);
+	group->region_cnt++;
+	group->region_boundary++;
+	pthread_rwlock_unlock(&(group->rwlock));
 	return group;
 }
-void cancel_last_region_from_group(struct _Maat_group_inner_t* group,int region_id,int expr_id)
+void cancel_last_region_from_group(struct _Maat_group_rule_t* group,int region_id,int expr_id)
 {
-	struct _Maat_region_inner_t* region_rule=NULL;
-	pthread_mutex_lock(&(group->mutex));
-	region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group->regions,group->region_boundary-1);
-	assert(region_rule->expr_id_ub==expr_id&&region_rule->region_id==region_id);
-	if(region_rule->expr_id_cnt==1)
-	{
-		free(region_rule);
-		dynamic_array_write(group->regions,group->region_boundary,NULL);
-		group->region_cnt--;
-		group->region_boundary--;
-	}
-	else
-	{
-		region_rule->expr_id_ub--;
-		region_rule->expr_id_cnt--;
-	}
-	pthread_mutex_unlock(&(group->mutex));
+	struct _Maat_region_rule_t* region_rule=NULL;
+	pthread_rwlock_wrlock(&(group->rwlock));
+	group->region_boundary--;
+	region_rule=(struct _Maat_region_rule_t*)dynamic_array_read(group->region_rules,group->region_boundary);
+	assert(region_rule->expr_id==expr_id&&region_rule->region_id==region_id);
+	free(region_rule);
+	dynamic_array_write(group->region_rules,group->region_boundary,NULL);
+	group->region_cnt--;
+	pthread_rwlock_unlock(&(group->rwlock));
 	return;
 }
-unsigned int del_region_from_group(struct _Maat_group_inner_t* group,int region_id,unsigned int *output_expr_id,int output_size)
+unsigned int del_region_from_group(struct _Maat_group_rule_t* group,int region_id,unsigned int *output_expr_id,int output_size)
 {
 	int i=0,j=0;
-	struct _Maat_region_inner_t* region_rule=NULL;
-	pthread_mutex_lock(&(group->mutex));
+	struct _Maat_region_rule_t* region_rule=NULL;
+	pthread_rwlock_wrlock(&(group->rwlock));
 	for(i=0;i<group->region_boundary;i++)
 	{
-		region_rule=(struct _Maat_region_inner_t*)dynamic_array_read(group->regions, i);
+		region_rule=(struct _Maat_region_rule_t*)dynamic_array_read(group->region_rules, i);
 		if(region_rule==NULL)
 		{
 			continue;
 		}
 		if(region_rule->region_id==region_id)
 		{
-			dynamic_array_write(group->regions, i, NULL);
-			for(j=0;j<region_rule->expr_id_cnt;j++)
-			{
-				output_expr_id[j]=region_rule->expr_id_lb+j;
-			}
-			assert(j<=output_size);	
-			region_rule->region_id=0;
+			dynamic_array_write(group->region_rules, i, NULL);
+			output_expr_id[j]=region_rule->expr_id;
+			j++;
+			assert(j<=output_size);
+			
 			free(region_rule);
 			region_rule=NULL;
+			
 			group->region_cnt--;
-			break;
 		}
 	}
-	pthread_mutex_unlock(&(group->mutex));
+	pthread_rwlock_unlock(&(group->rwlock));
 	return j;
 }
 
-int add_group_to_compile(struct _Maat_compile_inner_t*a_compile_rule,struct _Maat_group_inner_t* a_rule_group)
+int add_group_to_compile(struct _Maat_compile_rule_t*a_compile_rule,struct _Maat_group_rule_t* a_rule_group)
 {
 	int i=0,ret=-1;
-	int write_pos=-1;
-	struct _Maat_group_inner_t* p=NULL;
+	struct _Maat_group_rule_t* p=NULL;
 	pthread_rwlock_wrlock(&(a_compile_rule->rwlock));
 	if(a_compile_rule->db_c_rule!=NULL
 		&&a_compile_rule->group_cnt>=a_compile_rule->db_c_rule->declare_grp_num
 		&&a_compile_rule->db_c_rule->declare_grp_num!=0)
 	{
 		ret=-1;
-		goto error_out;
-	}
-
-	for(i=0;i<a_compile_rule->group_boundary;i++)
-	{
-		p=(struct _Maat_group_inner_t*)dynamic_array_read(a_compile_rule->groups,i);
-		if(p==NULL)
-		{
-			write_pos=i;
-		}
-		else
-		{
-			if(p->group_id==a_rule_group->group_id)//duplicate group
-			{
-				ret=-1;
-				goto error_out;
-			}
-		}
-	}
-	if(write_pos<0&&a_compile_rule->group_boundary==MAX_EXPR_ITEM_NUM)
-	{
-		ret=-1;
-		goto error_out;
-	}
-	if(write_pos<0)
-	{
-		write_pos=a_compile_rule->group_boundary;
-		a_compile_rule->group_boundary++;
-	}
-	dynamic_array_write(a_compile_rule->groups,write_pos, a_rule_group);
-	a_compile_rule->group_cnt++;
-	a_rule_group->ref_cnt++;
-	//member group->compile_shortcut may set to NULL and compile rule pointer repeatly,until rule build finish.
-	if(a_rule_group->ref_cnt==1&&a_compile_rule->group_cnt==1)
-	{
-		a_rule_group->compile_shortcut=a_compile_rule;
 	}
 	else
 	{
-		a_rule_group->compile_shortcut=NULL;
-	}
-		
-	//update group's shortcut when compile has more than one group.
-	if(a_compile_rule->group_cnt!=1)
-	{
-		for(i=0;i<a_compile_rule->group_boundary;i++)
+		for(i=0;i<MAAT_MAX_EXPR_ITEM_NUM;i++)
 		{
-			p=(struct _Maat_group_inner_t*)dynamic_array_read(a_compile_rule->groups,i);
-			if(p!=NULL)
+			p=(struct _Maat_group_rule_t*)dynamic_array_read(a_compile_rule->groups,i);
+			if(p==NULL)
 			{
-				p->compile_shortcut=NULL;
+				dynamic_array_write(a_compile_rule->groups,i, a_rule_group);
+				a_compile_rule->group_cnt++;
+				a_rule_group->ref_cnt++;
+				//variable compile_shortcut may set to NULL and compile rule pointer repeatly,until rule build finish.
+				if(a_rule_group->ref_cnt==1&&a_compile_rule->group_cnt==1)
+				{
+					a_rule_group->compile_shortcut=a_compile_rule;
+				}
+				else
+				{
+					a_rule_group->compile_shortcut=NULL;
+				}
+				ret=1;
+				break;
+			}
+			else
+			{
+				if(p->group_id==a_rule_group->group_id)//duplicate group
+				{
+					ret=-1;
+					
+				}
+			}
+		}
+		if(i==MAAT_MAX_EXPR_ITEM_NUM)
+		{
+			ret=-1;
+		}
+		//update group's shortcut when compile has more than one group.
+		if(a_compile_rule->group_cnt!=1)
+		{
+			for(i=0;i<MAAT_MAX_EXPR_ITEM_NUM;i++)
+			{
+				p=(struct _Maat_group_rule_t*)dynamic_array_read(a_compile_rule->groups,i);
+				if(p!=NULL)
+				{
+					p->compile_shortcut=NULL;
+				}
 			}
 		}
 	}
-	ret=1;
-error_out:
 	pthread_rwlock_unlock(&(a_compile_rule->rwlock));
 
 	return ret;
 }
-struct _Maat_group_inner_t* del_group_from_compile(struct _Maat_compile_inner_t*a_compile_rule,int group_id)
+struct _Maat_group_rule_t* del_group_from_compile(struct _Maat_compile_rule_t*a_compile_rule,int group_id)
 {
 	int i=0;
-	struct _Maat_group_inner_t* group_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
 	pthread_rwlock_wrlock(&(a_compile_rule->rwlock));
 	for(i=0;i<MAAT_MAX_EXPR_ITEM_NUM;i++)
 	{
-		group_rule=(struct _Maat_group_inner_t*)dynamic_array_read(a_compile_rule->groups,i);
+		group_rule=(struct _Maat_group_rule_t*)dynamic_array_read(a_compile_rule->groups,i);
 		if(group_rule==NULL)
 		{
 			continue;
@@ -1624,7 +1492,7 @@ int add_expr_rule(struct _Maat_table_info_t* table,struct db_str_rule_t* db_rule
 	int expr_id=0,district_id=-1;
 	
 	scan_rule_t*p_rule=NULL;
-	struct _Maat_group_inner_t* group_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
 	enum MAAT_CHARSET dst_charset=CHARSET_NONE;
 	char *sub_key_array[MAAT_MAX_EXPR_ITEM_NUM];
 	int key_left_offset[MAAT_MAX_EXPR_ITEM_NUM]={-1},key_right_offset[MAAT_MAX_EXPR_ITEM_NUM]={-1};
@@ -1635,14 +1503,14 @@ int add_expr_rule(struct _Maat_table_info_t* table,struct db_str_rule_t* db_rule
 	}
 	int sub_expr_cnt=0;
 	struct op_expr_t *op_expr=NULL;
-	struct _Maat_group_inner_t* u_para=NULL;
+	struct _Maat_group_rule_t* u_para=NULL;
 
 	if(table->table_type==TABLE_TYPE_EXPR_PLUS)
 	{
 		assert(strlen(db_rule->district)>0);
 		district_id=get_district_id(scanner, db_rule->district);
 	}
-	group_rule=(struct _Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_rule->group_id);
+	group_rule=(struct _Maat_group_rule_t*)HASH_fetch_by_id(scanner->group_hash, db_rule->group_id);
 	if(group_rule==NULL)
 	{
 		group_rule=create_group_rule(db_rule->group_id);
@@ -1705,7 +1573,7 @@ int add_expr_rule(struct _Maat_table_info_t* table,struct db_str_rule_t* db_rule
 			break;
 		case EXPR_TYPE_REGEX://it's easy,no need to charset convert
 			expr_id=scanner->exprid_generator++;
-			u_para=add_region_to_group(group_rule,table->table_id,db_rule->region_id,district_id,expr_id,TABLE_TYPE_EXPR);
+			u_para=add_region_to_group(group_rule,db_rule->region_id,district_id,expr_id,TABLE_TYPE_EXPR);
 			if(u_para==NULL)
 			{
 				return -1;
@@ -1772,7 +1640,7 @@ int add_expr_rule(struct _Maat_table_info_t* table,struct db_str_rule_t* db_rule
 				break;
 			}
 			expr_id=scanner->exprid_generator++;
-			u_para=add_region_to_group(group_rule,table->table_id, db_rule->region_id,district_id,expr_id, table->table_type);
+			u_para=add_region_to_group(group_rule, db_rule->region_id,district_id,expr_id, table->table_type);
 			if(u_para==NULL)//duplicate
 			{
 				return -1;
@@ -1838,8 +1706,6 @@ int add_expr_rule(struct _Maat_table_info_t* table,struct db_str_rule_t* db_rule
 				scanner->dedup_expr_num++;
 				cancel_last_region_from_group(group_rule,db_rule->region_id,op_expr->p_expr->expr_id);
 				destroy_op_expr(op_expr);
-				//redeem expr_id
-				scanner->exprid_generator--;
 				op_expr=NULL;
 			}
 			else
@@ -1852,7 +1718,7 @@ int add_expr_rule(struct _Maat_table_info_t* table,struct db_str_rule_t* db_rule
 	else
 	{
 		expr_id=scanner->exprid_generator++;
-		u_para=add_region_to_group(group_rule, table->table_id, db_rule->region_id,district_id,expr_id, table->table_type);
+		u_para=add_region_to_group(group_rule, db_rule->region_id,district_id,expr_id, table->table_type);
 		if(u_para==NULL)
 		{
 			return -1;
@@ -1885,13 +1751,13 @@ int add_expr_rule(struct _Maat_table_info_t* table,struct db_str_rule_t* db_rule
 }
 int add_ip_rule(struct _Maat_table_info_t* table,struct db_ip_rule_t* db_ip_rule,struct _Maat_scanner_t *scanner,void* logger)
 {
-	struct _Maat_group_inner_t* group_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
 	scan_rule_t* p_rule=NULL;
 	struct op_expr_t* op_expr=NULL;
-	struct _Maat_group_inner_t* u_para=NULL;
+	struct _Maat_group_rule_t* u_para=NULL;
 	int expr_id=0,district_id=-1;
 
-	group_rule=(struct _Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_ip_rule->group_id);
+	group_rule=(struct _Maat_group_rule_t*)HASH_fetch_by_id(scanner->group_hash, db_ip_rule->group_id);
 	if(group_rule==NULL)
 	{
 		group_rule=create_group_rule(db_ip_rule->group_id);
@@ -1899,7 +1765,7 @@ int add_ip_rule(struct _Maat_table_info_t* table,struct db_ip_rule_t* db_ip_rule
 	}
 
 	expr_id=scanner->exprid_generator++;
-	u_para=add_region_to_group(group_rule, table->table_id,db_ip_rule->region_id,district_id,expr_id,TABLE_TYPE_IP);
+	u_para=add_region_to_group(group_rule,db_ip_rule->region_id,district_id,expr_id,TABLE_TYPE_IP);
 	if(u_para==NULL)
 	{
 		return -1;
@@ -1917,20 +1783,20 @@ int add_ip_rule(struct _Maat_table_info_t* table,struct db_ip_rule_t* db_ip_rule
 }
 int add_intval_rule(struct _Maat_table_info_t* table,struct db_intval_rule_t* intval_rule,struct _Maat_scanner_t *scanner,void* logger)
 {
-	struct _Maat_group_inner_t* group_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
 	scan_rule_t* p_rule=NULL;
 	struct op_expr_t* op_expr=NULL;
-	struct _Maat_group_inner_t* u_para=NULL;
+	struct _Maat_group_rule_t* u_para=NULL;
 	int expr_id=0,district_id=-1;
 	
-	group_rule=(struct _Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, intval_rule->group_id);
+	group_rule=(struct _Maat_group_rule_t*)HASH_fetch_by_id(scanner->group_hash, intval_rule->group_id);
 	if(group_rule==NULL)
 	{
 		group_rule=create_group_rule(intval_rule->group_id);
 		HASH_add_by_id(scanner->group_hash, intval_rule->group_id, group_rule);
 	}
 	expr_id=scanner->exprid_generator++;
-	u_para=add_region_to_group(group_rule, table->table_id,intval_rule->region_id,district_id,expr_id,TABLE_TYPE_INTERVAL);
+	u_para=add_region_to_group(group_rule,intval_rule->region_id,district_id,expr_id,TABLE_TYPE_INTVAL);
 	if(u_para==NULL)
 	{
 		return -1;
@@ -1948,32 +1814,29 @@ int add_intval_rule(struct _Maat_table_info_t* table,struct db_intval_rule_t* in
 }
 int add_digest_rule(struct _Maat_table_info_t* table,struct db_digest_rule_t* db_digest_rule,struct _Maat_scanner_t *scanner,void* logger)
 {
-	struct _Maat_group_inner_t* group_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
 	GIE_digest_t* digest_rule=NULL;
-	struct _Maat_group_inner_t* u_para=NULL;
+	struct _Maat_group_rule_t* u_para=NULL;
 	int expr_id=0,district_id=-1;
 
-	group_rule=(struct _Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_digest_rule->group_id);
+	group_rule=(struct _Maat_group_rule_t*)HASH_fetch_by_id(scanner->group_hash, db_digest_rule->group_id);
 	if(group_rule==NULL)
 	{
 		group_rule=create_group_rule(db_digest_rule->group_id);
 		HASH_add_by_id(scanner->group_hash, db_digest_rule->group_id, group_rule);
 	}
 	expr_id=scanner->exprid_generator++;
-	u_para=add_region_to_group(group_rule,table->table_id,db_digest_rule->region_id,expr_id,district_id,TABLE_TYPE_DIGEST);
+	u_para=add_region_to_group(group_rule,db_digest_rule->region_id,expr_id,district_id,TABLE_TYPE_DIGEST);
 	if(u_para==NULL)
 	{
 		return -1;
 	}
-	if(table->table_type==TABLE_TYPE_SIMILARITY)
-	{
-		db_digest_rule->digest_string=str_unescape(db_digest_rule->digest_string);
-	}
-	digest_rule=create_digest_rule(expr_id, GIE_INSERT_OPT
+	digest_rule=create_digest_rule(expr_id, 0
+								,db_digest_rule->orgin_len
 								,db_digest_rule->digest_string
 								,db_digest_rule->confidence_degree
 								,group_rule);
-	MESA_lqueue_join_tail(scanner->gie_aux[table->table_id].update_q, &digest_rule, sizeof(void*));
+	MESA_lqueue_join_tail(scanner->digest_update_q[table->table_id], &digest_rule, sizeof(void*));
 	return 0;
 }
 int del_region_rule(struct _Maat_table_info_t* table,int region_id,int group_id,int rule_type,struct _Maat_scanner_t *maat_scanner,void* logger)
@@ -1981,10 +1844,10 @@ int del_region_rule(struct _Maat_table_info_t* table,int region_id,int group_id,
 	int i=0;
 	unsigned int expr_id[MAAT_MAX_EXPR_ITEM_NUM*MAX_CHARSET_NUM]={0};
 	int expr_num=0;
-	struct _Maat_group_inner_t* group_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
 	struct op_expr_t* op_expr=NULL;
 	GIE_digest_t* digest_rule=NULL;
-	group_rule=(struct _Maat_group_inner_t*)HASH_fetch_by_id(maat_scanner->group_hash, group_id);
+	group_rule=(struct _Maat_group_rule_t*)HASH_fetch_by_id(maat_scanner->group_hash, group_id);
 	if(group_rule==NULL)
 	{
 		MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module ,
@@ -2010,7 +1873,7 @@ int del_region_rule(struct _Maat_table_info_t* table,int region_id,int group_id,
 		case	TABLE_TYPE_IP:
 		case	TABLE_TYPE_EXPR:
 		case	TABLE_TYPE_EXPR_PLUS:
-		case	TABLE_TYPE_INTERVAL:
+		case	TABLE_TYPE_INTVAL:
 			for(i=0;i<expr_num;i++)
 			{
 				op_expr=create_op_expr(expr_id[i],1,NULL,table->table_id);//del expr
@@ -2018,14 +1881,14 @@ int del_region_rule(struct _Maat_table_info_t* table,int region_id,int group_id,
 				MESA_lqueue_join_tail(maat_scanner->region_update_q,&op_expr, sizeof(void*));
 			}
 			break;
-		case	TABLE_TYPE_SIMILARITY:
 		case	TABLE_TYPE_DIGEST:
 			assert(expr_num==1);
-			digest_rule=create_digest_rule(expr_id[0], GIE_DELETE_OPT	//del digest
+			digest_rule=create_digest_rule(expr_id[0], 1	//del digest
+									,0
 									,NULL
 									,0
 									,NULL);
-			MESA_lqueue_join_tail(maat_scanner->gie_aux[i].update_q,&digest_rule, sizeof(void*));
+			MESA_lqueue_join_tail(maat_scanner->digest_update_q[table->table_id],&digest_rule, sizeof(void*));
 			break;
 		default:
 			assert(0);
@@ -2045,20 +1908,18 @@ int del_region_rule(struct _Maat_table_info_t* table,int region_id,int group_id,
 }
 int add_group_rule(struct _Maat_table_info_t* table,struct db_group_rule_t* db_group_rule,struct _Maat_scanner_t *scanner,void* logger)
 {
-	struct _Maat_group_inner_t* group_rule=NULL;
-	struct _Maat_compile_inner_t*compile_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
+	struct _Maat_compile_rule_t*compile_rule=NULL;
 	int ret=0;
-	group_rule=(struct _Maat_group_inner_t*)HASH_fetch_by_id(scanner->group_hash, db_group_rule->group_id);
+	group_rule=(struct _Maat_group_rule_t*)HASH_fetch_by_id(scanner->group_hash, db_group_rule->group_id);
 	if(group_rule==NULL)
 	{
 		group_rule=create_group_rule(db_group_rule->group_id);
-		group_rule->table_id=table->table_id;
-			
 		ret=HASH_add_by_id(scanner->group_hash, db_group_rule->group_id,group_rule);
 		assert(ret>=0);
 	}
 	
-	compile_rule=(struct _Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->compile_id);
+	compile_rule=(struct _Maat_compile_rule_t*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->compile_id);
 	if(compile_rule==NULL)
 	{
 		compile_rule=create_compile_rule(db_group_rule->compile_id);
@@ -2080,9 +1941,9 @@ int add_group_rule(struct _Maat_table_info_t* table,struct db_group_rule_t* db_g
 }
 void del_group_rule(struct _Maat_table_info_t* table,struct db_group_rule_t* db_group_rule,struct _Maat_scanner_t *scanner,void* logger)
 {
-	struct _Maat_compile_inner_t*compile_rule=NULL;
-	struct _Maat_group_inner_t* group_rule=NULL;
-	compile_rule=(struct _Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->compile_id);
+	struct _Maat_compile_rule_t*compile_rule=NULL;
+	struct _Maat_group_rule_t* group_rule=NULL;
+	compile_rule=(struct _Maat_compile_rule_t*)HASH_fetch_by_id(scanner->compile_hash, db_group_rule->compile_id);
 	if(compile_rule==NULL)
 	{
 		MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module ,
@@ -2118,13 +1979,12 @@ void del_group_rule(struct _Maat_table_info_t* table,struct db_group_rule_t* db_
 }
 int add_compile_rule(struct _Maat_table_info_t* table,struct db_compile_rule_t* db_compile_rule,struct _Maat_scanner_t *scanner,void* logger)
 {
-	struct _Maat_compile_inner_t *compile_rule=NULL;
+	struct _Maat_compile_rule_t *compile_rule=NULL;
 	struct _head_Maat_rule_t *p_maat_rule_head=&(db_compile_rule->m_rule_head);
-	compile_rule=(struct _Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, p_maat_rule_head->config_id);
+	compile_rule=(struct _Maat_compile_rule_t*)HASH_fetch_by_id(scanner->compile_hash, p_maat_rule_head->config_id);
 	if(compile_rule==NULL)
 	{
 		compile_rule=create_compile_rule(p_maat_rule_head->config_id);
-		compile_rule->table_id=table->table_id;
 		HASH_add_by_id(scanner->compile_hash,p_maat_rule_head->config_id,compile_rule);
 	}
 	if(compile_rule->db_c_rule!=NULL)//duplicate config
@@ -2137,8 +1997,8 @@ int add_compile_rule(struct _Maat_table_info_t* table,struct db_compile_rule_t*
 }
 int del_compile_rule(struct _Maat_table_info_t* table,struct db_compile_rule_t* db_compile_rule,struct _Maat_scanner_t *scanner,void* logger)
 {
-	struct _Maat_compile_inner_t *compile_rule=NULL;
-	compile_rule=(struct _Maat_compile_inner_t*)HASH_fetch_by_id(scanner->compile_hash, db_compile_rule->m_rule_head.config_id);
+	struct _Maat_compile_rule_t *compile_rule=NULL;
+	compile_rule=(struct _Maat_compile_rule_t*)HASH_fetch_by_id(scanner->compile_hash, db_compile_rule->m_rule_head.config_id);
 	if(compile_rule==NULL)
 	{
 		MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module ,
@@ -2680,30 +2540,14 @@ void update_digest_rule(struct _Maat_table_info_t* table,const char* table_line,
 	struct db_digest_rule_t* digest_rule=(struct db_digest_rule_t*)calloc(sizeof(struct db_digest_rule_t),1);
 	int ret=0;
 	char digest_buff[MAX_TABLE_LINE_SIZE]={'\0'};
-	if(table->table_type==TABLE_TYPE_DIGEST)
-	{
-		ret=sscanf(table_line,"%d\t%d\t%llu\t%s\t%hd\t%d",&(digest_rule->region_id)
+	ret=sscanf(table_line,"%d\t%d\t%llu\t%s\t%hd\t%d",&(digest_rule->region_id)
 											,&(digest_rule->group_id)
 											,&(digest_rule->orgin_len)
 											,digest_buff
 											,&(digest_rule->confidence_degree)
 											,&(digest_rule->is_valid));
-	}
-	else if(table->table_type==TABLE_TYPE_SIMILARITY)
-	{
-		digest_rule->orgin_len=0;
-		ret=sscanf(table_line,"%d\t%d\t%s\t%hd\t%d",&(digest_rule->region_id)
-											,&(digest_rule->group_id)
-											,digest_buff
-											,&(digest_rule->confidence_degree)
-											,&(digest_rule->is_valid));
-	}
-	else
-	{
-		assert(0);
-	}
 	digest_rule->digest_string=digest_buff;
-	if(!(ret==6||ret==5)||digest_rule->confidence_degree>100||digest_rule->confidence_degree<0)
+	if(ret!=6||digest_rule->confidence_degree>10||digest_rule->confidence_degree<0)
 	{
 		MESA_handle_runtime_log(logger,RLOG_LV_FATAL,maat_module ,
 							"update error,invalid format  of digest table %s:%s"
@@ -2779,7 +2623,7 @@ void garbage_bagging(enum maat_garbage_type type,void *p,MESA_lqueue_head garbag
 	MESA_lqueue_join_tail(garbage_q,&bag,sizeof(void*));
 	return;
 }
-void garbage_bury(MESA_lqueue_head garbage_q,void *logger)
+void garbage_bury(MESA_lqueue_head garbage_q,int timeout,void *logger)
 {
 	MESA_queue_errno_t q_ret=MESA_QUEUE_RET_OK;
 	_maat_garbage_t* bag=NULL;
@@ -2794,7 +2638,7 @@ void garbage_bury(MESA_lqueue_head garbage_q,void *logger)
 		data_size=sizeof(void*);
 		q_ret=(MESA_queue_errno_t)MESA_lqueue_get_head(garbage_q,&bag,&data_size);
 		assert(data_size==sizeof(void*)&&q_ret==MESA_QUEUE_RET_OK);
-		if(now-bag->create_time<10)
+		if(now-bag->create_time<timeout)
 		{
 			MESA_lqueue_join_tail(garbage_q,&bag,sizeof(void*));
 			continue;
@@ -2874,8 +2718,8 @@ void do_scanner_update(struct _Maat_scanner_t* scanner,MESA_lqueue_head garbage_
 	int i=0;
 	long q_cnt;
 	GIE_create_para_t para;
-	para.gram_value=7;
-	para.position_accuracy=10;
+	para.index_interval=100;
+	para.query_accuracy=0.1;
 	tmp1=create_bool_matcher(scanner->compile_hash,
 											scan_thread_num,
 											logger);
@@ -2896,34 +2740,26 @@ void do_scanner_update(struct _Maat_scanner_t* scanner,MESA_lqueue_head garbage_
 							,scanner);
 	for(i=0;i<MAX_TABLE_NUM;i++)
 	{
-		if(scanner->gie_aux[i].update_q==NULL)
+		if(scanner->digest_update_q[i]==NULL)
 		{
 			continue;
 		}
-		q_cnt=MESA_lqueue_get_count(scanner->gie_aux[i].update_q);
+		q_cnt=MESA_lqueue_get_count(scanner->digest_update_q[i]);
 		if(q_cnt==0)
 		{
 			continue;
 		}
-		if(scanner->gie_aux[i].gie_handle==NULL)
+		pthread_rwlock_wrlock(&(scanner->digest_rwlock[i]));
+		if(scanner->digest_handle[i]==NULL)
 		{
-			if(scanner->gie_aux[i].table_type==TABLE_TYPE_SIMILARITY)
-			{
-				para.ED_reexamine=1;
-				para.format=GIE_INPUT_FORMAT_PLAIN;
-			}
-			else
-			{
-				para.ED_reexamine=0;
-				para.format=GIE_INPUT_FORMAT_SFH;
-			}
-			scanner->gie_aux[i].gie_handle=GIE_create(&para);
+			scanner->digest_handle[i]=GIE_create(&para);
 		}
-		digest_batch_update(scanner->gie_aux[i].gie_handle
-							,scanner->gie_aux[i].update_q
+		digest_batch_update(scanner->digest_handle[i]
+							,scanner->digest_update_q[i]
 							,logger
 							,scanner
 							,i);
+		pthread_rwlock_unlock(&(scanner->digest_rwlock[i]));
 	}
 	if(scanner->tmp_district_map!=NULL)
 	{
@@ -3117,11 +2953,10 @@ void maat_update_cb(const char* table_name,const char* line,void *u_para)
 		case	TABLE_TYPE_IP:
 			update_ip_rule(feather->p_table_info[table_id], line, scanner,feather->logger,feather->GROUP_MODE_ON);
 			break;
-		case	TABLE_TYPE_INTERVAL:
+		case	TABLE_TYPE_INTVAL:
 			update_intval_rule(feather->p_table_info[table_id], line, scanner,feather->logger,feather->GROUP_MODE_ON);
 			break;
 		case	TABLE_TYPE_DIGEST:
-		case	TABLE_TYPE_SIMILARITY:
 			update_digest_rule(feather->p_table_info[table_id], line, scanner,feather->logger,feather->GROUP_MODE_ON);
 			break;
 		case	TABLE_TYPE_COMPILE:
@@ -3165,33 +3000,19 @@ void *thread_rule_monitor(void *arg)
 		scan_dir_cnt++;
 		//plugin table register is not allowed during update;
 		pthread_mutex_lock(&(feather->plugin_table_reg_mutex));
-		if(feather->REDIS_MODE_ON==1)
-		{
-			redis_monitor_traverse(feather->maat_version
-									,feather->redis_read_ctx
-									,maat_start_cb
-									,maat_update_cb
-									,maat_finish_cb
-									,feather
-									,feather->decrypt_key	//Not used.
-									,feather);
-		}
-		else
-		{
-			config_monitor_traverse(feather->maat_version,
-									inc_cfg_dir, 
-									maat_start_cb,
-									maat_update_cb,
-									maat_finish_cb,
-									feather,
-									feather->decrypt_key,
-									feather->logger);
-		}
+		config_monitor_traverse(feather->maat_version,
+								inc_cfg_dir, 
+								maat_start_cb,
+								maat_update_cb,
+								maat_finish_cb,
+								feather,
+								feather->decrypt_key,
+								feather->logger);
 		pthread_mutex_unlock(&(feather->plugin_table_reg_mutex));
 		if(feather->update_tmp_scanner!=NULL)
 		{
 			old_scanner=feather->scanner;
-			//Some OS doesn't have __sync_lock_test_and_set.
+			//__sync_lock_test_and_set not work in some OS.
 			//feather->scanner=__sync_lock_test_and_set(&(feather->scanner),feather->update_tmp_scanner);
 			feather->scanner=feather->update_tmp_scanner;
 			if(old_scanner!=NULL)
@@ -3221,7 +3042,7 @@ void *thread_rule_monitor(void *arg)
 										feather->scanner->version,feather->scanner->cfg_num);
 			}
 		}
-		garbage_bury(feather->garbage_q,feather->logger);
+		garbage_bury(feather->garbage_q,feather->effect_interval_ms/1000+10,feather->logger);
 		if(feather->stat_on==1&&scan_dir_cnt%2==0)//output every 2 seconds
 		{
 			maat_stat_output(feather);
@@ -3230,7 +3051,7 @@ void *thread_rule_monitor(void *arg)
 	
 	MESA_htable_destroy(feather->map_tablename2id,free);
 	destroy_maat_scanner(feather->scanner);
-	garbage_bury(feather->garbage_q,feather->logger);
+	garbage_bury(feather->garbage_q,feather->effect_interval_ms/1000+10,feather->logger);
 	MESA_lqueue_destroy(feather->garbage_q,lqueue_destroy_cb,NULL);
 	FS_stop(&(feather->stat_handle));
 
@@ -3261,13 +3082,6 @@ void *thread_rule_monitor(void *arg)
 	aligment_int64_array_free(feather->hit_cnt);
 	aligment_int64_array_free(feather->orphan_group_saving);
 	aligment_int64_array_free(feather->last_region_saving);
-	if(feather->REDIS_MODE_ON==1&&feather->redis_read_ctx!=NULL)
-	{
-		pthread_mutex_lock(&(feather->redis_write_lock));
-		redisFree(feather->redis_read_ctx);
-		feather->redis_read_ctx=NULL;
-		pthread_mutex_unlock(&(feather->redis_write_lock));
-	}
 	free(feather);
 	return NULL;
 }
diff --git a/src/entry/Maat_rule_internal.h b/src/entry/Maat_rule_internal.h
index c74dde2..6f24281 100644
--- a/src/entry/Maat_rule_internal.h
+++ b/src/entry/Maat_rule_internal.h
@@ -182,7 +182,7 @@ struct _Maat_group_inner_t
 	char* group_name;
 	dynamic_array_t *regions;
 	void* compile_shortcut;
-	pthread_mutex_t mutex;
+	pthread_rwlock_t rwlock;
 };
 struct _Maat_compile_inner_t
 {