[FEATURE]support benchmark

scanner/expr_matcher/adapter_rs/adapter_rs.cpp

@@ -65,7 +65,7 @@ struct adapter_rs_runtime {
     struct bool_matcher *bm;
 };
 
-/* adapter_hs instance */
+/* adapter_rs instance */
 struct adapter_rs {
     size_t n_worker_thread;
     size_t n_expr;
@@ -106,7 +106,7 @@ int adapter_rs_verify_regex_expression(const char *regex_expr,
     return ret;
 }
 /**
- * @brief build hs block database for literal string and regex expression respectively
+ * @brief build rs database for literal string and regex expression respectively
  * 
  * @retval 0(success) -1(failed)
 */
@@ -196,7 +196,7 @@ static struct bool_expr *bool_exprs_new(struct expr_rule *rules, size_t n_rule,
 
     struct bool_expr *bool_exprs = ALLOC(struct bool_expr, n_rule);
 
-    /* populate adpt_hs_compile_data and bool_expr */
+    /* populate adpt_rs_compile_data and bool_expr */
     for (size_t i = 0; i < n_rule; i++) {
 
         for (size_t j = 0; j < rules[i].n_patterns; j++) {
@@ -276,22 +276,22 @@ void *adapter_rs_new(struct expr_rule *rules, size_t n_rule,
 
     rs_inst->rs_rt = ALLOC(struct adapter_rs_runtime, 1);
 
-    //hs_rt->bm
+    //rs_rt->bm
     rs_inst->rs_rt->bm = bool_matcher_new(bool_exprs, n_rule, &mem_size);
     if (rs_inst->rs_rt->bm != NULL) {
         log_info(logger, MODULE_ADAPTER_RS, 
-                 "Adapter_hs module: build bool matcher of %zu expressions"
+                 "Adapter_rs module: build bool matcher of %zu expressions"
                  " with %zu bytes memory", n_rule, mem_size);
     } else {
         log_error(logger, MODULE_ADAPTER_RS,
-                  "[%s:%d] Adapter_hs module: build bool matcher failed",
+                  "[%s:%d] Adapter_rs module: build bool matcher failed",
                   __FUNCTION__, __LINE__);
         
         rs_ret = -1;
     }
     FREE(bool_exprs);
 
-    /* build hs database hs_rt->literal_db & hs_rt->regex_db */
+    /* build rs database rs_rt->literal_db & rs_rt->regex_db */
     int ret = adpt_rs_build_database(rs_inst->rs_rt, n_worker_thread,
                                      literal_cd, regex_cd, logger);
     if (ret < 0) {
@@ -577,16 +577,6 @@ int adapter_rs_scan_stream(void *rs_stream, const char *data, size_t data_len,
         return -1;
     }
     
-    /* 
-        In streaming mode, a non-zero return from the user-specified event-handler
-        function has consequences for the rest of that stream's lifetime: when a
-        non-zero return occurs, it signals that no more of the stream should be
-        scanned. Consequently if the user makes a subsequent call to
-        `hs_scan_stream` on a stream whose processing was terminated in this way,
-        hs_scan_stream will return `HS_SCAN_TERMINATED`. This case has not been
-        demonstrated in pcapscan, as its callback always returns 0. 
-    */
-
     int ret = 0, err_count = 0;
     struct adapter_rs_stream *stream = (struct adapter_rs_stream *)rs_stream;
     int thread_id = stream->thread_id;

src/maat_command.c

@@ -252,7 +252,6 @@ int maat_wrap_redis_get_reply(redisContext *c, redisReply **reply)
 
 int maat_cmd_set_line(struct maat *maat_inst, const struct maat_cmd_line *line_rule)
 {
-    int i = 0;
 	int ret = 0;
 	long long absolute_expire_time = 0;
 
@@ -268,42 +267,42 @@ int maat_cmd_set_line(struct maat *maat_inst, const struct maat_cmd_line *line_r
 
 	struct serial_rule *s_rule = ALLOC(struct serial_rule, 1);
 
-    int table_id = table_manager_get_table_id(maat_inst->tbl_mgr, line_rule->table_name);
+	int table_id = table_manager_get_table_id(maat_inst->tbl_mgr, line_rule->table_name);
-    if (table_id < 0) {
+	if (table_id < 0) {
-        log_error(maat_inst->logger, MODULE_MAAT_COMMAND, 
+		log_error(maat_inst->logger, MODULE_MAAT_COMMAND,
-                  "[%s:%d] Command set line id %lld failed: unknown table %s", 
+				  "[%s:%d] Command set line id %lld failed: unknown table %s",
-                  __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name);
+				  __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name);
-        FREE(s_rule);
+		FREE(s_rule);
-        return -1;
+		return -1;
-    }
+	}
 
-    int valid_column = table_manager_get_valid_column(maat_inst->tbl_mgr, table_id);
+	int valid_column = table_manager_get_valid_column(maat_inst->tbl_mgr, table_id);
-    if (valid_column < 0) {
+	if (valid_column < 0) {
-        log_error(maat_inst->logger, MODULE_MAAT_COMMAND,
+		log_error(maat_inst->logger, MODULE_MAAT_COMMAND,
-                  "[%s:%d] Command set line id %lld failed: table %s is not a plugin or ip_plugin table",
+				  "[%s:%d] Command set line id %lld failed: table %s is not a plugin or ip_plugin table",
-                  __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name);
+				  __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name);
-        FREE(s_rule);
+		FREE(s_rule);
-        return -1;
+		return -1;
-    }
+	}
-   
-    int valid_offset = maat_get_valid_flag_offset(line_rule->table_line, valid_column);
-    if (valid_offset < 0) {
-        log_error(maat_inst->logger, MODULE_MAAT_COMMAND,
-                  "[%s:%d] Command set line id %lld failed: table %s valid_offset error",
-                  __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name);
-        FREE(s_rule);
-        return -1;
-    }
 
-    int is_valid = atoi(line_rule->table_line + valid_offset);
+	int valid_offset = maat_get_valid_flag_offset(line_rule->table_line, valid_column);
-    if (line_rule->expire_after > 0) {
+	if (valid_offset < 0) {
-        absolute_expire_time = server_time + line_rule->expire_after;
+		log_error(maat_inst->logger, MODULE_MAAT_COMMAND,
-    }
+				  "[%s:%d] Command set line id %lld failed: table %s valid_offset error",
+				  __FUNCTION__, __LINE__, line_rule->rule_id, line_rule->table_name);
+		FREE(s_rule);
+		return -1;
+	}
 
-    maat_set_serial_rule(s_rule + i, (enum maat_operation)is_valid, line_rule->rule_id,
+	int is_valid = atoi(line_rule->table_line + valid_offset);
+	if (line_rule->expire_after > 0) {
+		absolute_expire_time = server_time + line_rule->expire_after;
+	}
+
+    maat_set_serial_rule(s_rule, (enum maat_operation)is_valid, line_rule->rule_id,
                          line_rule->table_name, line_rule->table_line, absolute_expire_time);
 
-    int success_cnt = maat_cmd_write_rule(write_ctx, s_rule, 1, server_time, maat_inst->logger);
+	int success_cnt = maat_cmd_write_rule(write_ctx, s_rule, 1, server_time, maat_inst->logger);
 	if (success_cnt != 1) {
 		ret = -1;
 		goto error_out;

src/maat_expr.c

@@ -1173,4 +1173,4 @@ long long expr_runtime_scan_bytes(struct expr_runtime *expr_rt)
     alignment_int64_array_reset(expr_rt->scan_bytes, expr_rt->n_worker_thread);
 
     return sum;
-}
+}

test/CMakeLists.txt

@@ -34,6 +34,7 @@ add_executable(maat_ex_data_gtest maat_ex_data_gtest.cpp)
 target_link_libraries(maat_ex_data_gtest maat_frame_static gtest_static)
 
 add_subdirectory(group_exclude)
+add_subdirectory(benchmark)
 
 file(COPY table_info.conf DESTINATION ./)
 file(COPY tsg_table_info.conf DESTINATION ./)
@@ -47,6 +48,7 @@ file(COPY testdata DESTINATION ./)
 file(COPY test_streamfiles DESTINATION ./)
 file(COPY json_update DESTINATION ./)
 file(COPY group_exclude DESTINATION ./)
+file(COPY benchmark DESTINATION ./)
 
 include(GoogleTest)
 gtest_discover_tests(maat_framework_gtest)

test/benchmark/CMakeLists.txt

@@ -0,0 +1,7 @@
+include_directories(${PROJECT_SOURCE_DIR}/src/inc_internal)
+
+add_executable(benchmark_hs_gtest benchmark_hs_gtest.cpp)
+target_link_libraries(benchmark_hs_gtest maat_frame_static gtest_static)
+
+add_executable(benchmark_rs_gtest benchmark_rs_gtest.cpp)
+target_link_libraries(benchmark_rs_gtest maat_frame_static gtest_static)

test/benchmark/benchmark_table_info.conf

@@ -0,0 +1,579 @@
+[
+    {
+        "table_id":1,
+        "table_name":"EXPR_LITERAL_1K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":2,
+        "table_name":"EXPR_LITERAL_5K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":3,
+        "table_name":"EXPR_LITERAL_10K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":4,
+        "table_name":"EXPR_LITERAL_50K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":5,
+        "table_name":"EXPR_LITERAL_100K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":6,
+        "table_name":"EXPR_LITERAL_500K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":7,
+        "table_name":"EXPR_LITERAL_1M",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":8,
+        "table_name":"EXPR_LITERAL_2M",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":9,
+        "table_name":"EXPR_LITERAL_5M",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":10,
+        "table_name":"IP_1K",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":11,
+        "table_name":"IP_5K",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":12,
+        "table_name":"IP_10K",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":13,
+        "table_name":"IP_50K",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":14,
+        "table_name":"IP_100K",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":15,
+        "table_name":"IP_500K",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":16,
+        "table_name":"IP_1M",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":17,
+        "table_name":"IP_2M",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":18,
+        "table_name":"IP_5M",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":19,
+        "table_name":"IP_10M",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":20,
+        "table_name":"INTEGER_1K",
+        "table_type":"intval",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "low_bound":3,
+            "up_bound":4
+        }
+    },
+    {
+        "table_id":21,
+        "table_name":"INTEGER_5K",
+        "table_type":"intval",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "low_bound":3,
+            "up_bound":4
+        }
+    },
+    {
+        "table_id":22,
+        "table_name":"INTEGER_10K",
+        "table_type":"intval",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "low_bound":3,
+            "up_bound":4
+        }
+    },
+    {
+        "table_id":23,
+        "table_name":"INTEGER_50K",
+        "table_type":"intval",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "low_bound":3,
+            "up_bound":4
+        }
+    },
+    {
+        "table_id":24,
+        "table_name":"INTEGER_100K",
+        "table_type":"intval",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "low_bound":3,
+            "up_bound":4
+        }
+    },
+    {
+        "table_id":25,
+        "table_name":"FLAG_1K",
+        "table_type":"flag",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "flag":3,
+            "flag_mask":4
+        }
+    },
+    {
+        "table_id":26,
+        "table_name":"FLAG_5K",
+        "table_type":"flag",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "flag":3,
+            "flag_mask":4
+        }
+    },
+    {
+        "table_id":27,
+        "table_name":"FLAG_10K",
+        "table_type":"flag",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "flag":3,
+            "flag_mask":4
+        }
+    },
+    {
+        "table_id":28,
+        "table_name":"FLAG_50K",
+        "table_type":"flag",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "flag":3,
+            "flag_mask":4
+        }
+    },
+    {
+        "table_id":29,
+        "table_name":"FLAG_100K",
+        "table_type":"flag",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "flag":3,
+            "flag_mask":4
+        }
+    },
+    {
+        "table_id":30,
+        "table_name":"STREAM_1K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":31,
+        "table_name":"STREAM_5K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":32,
+        "table_name":"STREAM_10K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":33,
+        "table_name":"STREAM_50K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":34,
+        "table_name":"STREAM_100K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":35,
+        "table_name":"STREAM_500K",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":36,
+        "table_name":"STREAM_1M",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":37,
+        "table_name":"STREAM_2M",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":38,
+        "table_name":"STREAM_5M",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":39,
+        "table_name":"COMPILE_PERF",
+        "table_type":"compile",
+        "valid_column":8,
+        "custom": {
+            "compile_id":1,
+            "tags":6,
+            "clause_num":9
+        }
+    },
+    {
+        "table_id":40,
+        "table_name":"GROUP2COMPILE_PERF",
+        "table_type":"group2compile",
+        "associated_compile_table_id":39,
+        "valid_column":3,
+        "custom": {
+            "group_id":1,
+            "compile_id":2,
+            "not_flag":4,
+            "virtual_table_name":5,
+            "clause_index":6
+        }
+    }
+]

test/maat_framework_gtest.cpp

@@ -767,7 +767,7 @@ protected:
         maat_options_set_stat_file(opts, "./stat.log");
         maat_options_set_logger(opts, "./maat_framework_gtest.log", LOG_LEVEL_INFO);
         maat_options_set_accept_tags(opts, accept_tags);
-        maat_options_set_expr_engine(opts, MAAT_EXPR_ENGINE_RS);
+        //maat_options_set_expr_engine(opts, MAAT_EXPR_ENGINE_HS); //default
 
         _shared_maat_inst = maat_new(opts, table_info_path);
         maat_options_free(opts);
@@ -1952,7 +1952,7 @@ TEST_F(MaatRsStringScan, StreamScanUTF8) {
     long long results[ARRAY_SIZE] = {0};
     size_t n_hit_result = 0;
     int thread_id = 0;
-    char scan_data[2048];
+    char scan_data[1500];
     struct maat *maat_inst = MaatRsStringScan::_shared_maat_inst;
     struct maat_state *state = maat_state_new(maat_inst, thread_id);
 
@@ -1968,6 +1968,7 @@ TEST_F(MaatRsStringScan, StreamScanUTF8) {
     int pass_flag = 0;
     while (0 == feof(fp)) {
 		size_t read_size = fread(scan_data, 1, sizeof(scan_data), fp);
+        //read_size can't exceed 1500
 		int ret = maat_stream_scan(sp, scan_data, read_size, results, ARRAY_SIZE,
                                     &n_hit_result, state);
 		if (ret == MAAT_SCAN_HIT) {

test/maat_framework_perf_gtest.cpp

@@ -256,8 +256,54 @@ static int ip_table_set_line(struct maat *maat_inst, const char *table_name, enu
     return maat_cmd_set_line(maat_inst, &line_rule);
 }
 
-void test_add_expr_command(struct maat *maat_inst, const char *table_name, 
+static int integer_table_set_line(struct maat *maat_inst, const char *table_name,
-                           const char *keywords)
+                                  enum maat_operation op, long long item_id,
+                                  long long group_id, int low_bound, int up_bound,
+                                  int expire_after)
+{
+    char table_line[1024] = {0};
+    int table_id = maat_get_table_id(maat_inst, table_name);
+    if (table_id < 0) {
+        return 0;
+    }
+
+    sprintf(table_line, "%lld\t%lld\t%d\t%d\t%d",
+            item_id, group_id, low_bound, up_bound, op);
+    struct maat_cmd_line line_rule;
+
+    line_rule.rule_id = item_id;
+    line_rule.table_line = table_line;
+    line_rule.table_name = table_name;
+    line_rule.expire_after = expire_after;
+
+    return maat_cmd_set_line(maat_inst, &line_rule);
+}
+
+static int flag_table_set_line(struct maat *maat_inst, const char *table_name,
+                                  enum maat_operation op, long long item_id,
+                                  long long group_id, long long flag,
+                                  long long flag_mask, int expire_after)
+{
+    char table_line[1024] = {0};
+    int table_id = maat_get_table_id(maat_inst, table_name);
+    if (table_id < 0) {
+        return 0;
+    }
+
+    sprintf(table_line, "%lld\t%lld\t%lld\t%lld\t%d",
+            item_id, group_id, flag, flag_mask, op);
+    struct maat_cmd_line line_rule;
+
+    line_rule.rule_id = item_id;
+    line_rule.table_line = table_line;
+    line_rule.table_name = table_name;
+    line_rule.expire_after = expire_after;
+
+    return maat_cmd_set_line(maat_inst, &line_rule);
+}
+
+static void test_add_expr_command(struct maat *maat_inst, const char *table_name, 
+                                  const char *keywords)
 {
     long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
     int ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0);
@@ -270,12 +316,12 @@ void test_add_expr_command(struct maat *maat_inst, const char *table_name,
 
     long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1);
     ret = expr_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id,
-                              keywords, NULL, 1, 0, 0, 0);
+                              keywords, "null", 1, 0, 0, 0);
     EXPECT_EQ(ret, 1);
 }
 
-void test_add_ip_command(struct maat *maat_inst, const char *table_name, 
+static void test_add_ip_command(struct maat *maat_inst, const char *table_name, 
-                         const char *ip, uint16_t port)
+                                const char *ip, uint16_t port)
 {
     long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
     int ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0);
@@ -292,6 +338,42 @@ void test_add_ip_command(struct maat *maat_inst, const char *table_name,
     EXPECT_EQ(ret, 1);
 }
 
+static void test_add_integer_command(struct maat *maat_inst, const char *table_name, 
+                                     int low_bound, int up_bound)
+{
+    long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
+    int ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0);
+    EXPECT_EQ(ret, 1);
+
+    long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1);
+    ret = group2compile_table_set_line(maat_inst, "GROUP2COMPILE", MAAT_OP_ADD, group_id,
+                                       compile_id, 0, "null", 1, 0);
+    EXPECT_EQ(ret, 1);
+
+    long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1);
+    ret = integer_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id,
+                                 low_bound, up_bound, 0);
+    EXPECT_EQ(ret, 1);
+}
+
+static void test_add_flag_command(struct maat *maat_inst, const char *table_name, 
+                                  long long flag, long long flag_mask)
+{
+    long long compile_id = maat_cmd_incrby(maat_inst, "TEST_SEQ", 1);
+    int ret = compile_table_set_line(maat_inst, "COMPILE", MAAT_OP_ADD, compile_id, "null", 1, 0);
+    EXPECT_EQ(ret, 1);
+
+    long long group_id = maat_cmd_incrby(maat_inst, "SEQUENCE_GROUP", 1);
+    ret = group2compile_table_set_line(maat_inst, "GROUP2COMPILE", MAAT_OP_ADD, group_id,
+                                       compile_id, 0, "null", 1, 0);
+    EXPECT_EQ(ret, 1);
+
+    long long item_id = maat_cmd_incrby(maat_inst, "SEQUENCE_REGION", 1);
+    ret = flag_table_set_line(maat_inst, table_name, MAAT_OP_ADD, item_id, group_id,
+                              flag, flag_mask, 0);
+    EXPECT_EQ(ret, 1);
+}
+
 class MaatPerfStringScan : public testing::Test
 {
 protected:
@@ -344,7 +426,7 @@ void *perf_string_scan_thread(void *arg)
     struct maat *maat_inst = param->maat_inst;
     const char *table_name = param->table_name;
     struct timespec start, end;
-    const char *scan_data = "String TEST should hit";
+    const char *scan_data = "today and yesterday should hit";
     long long results[ARRAY_SIZE] = {0};
     int hit_times = 0;
     size_t n_hit_result = 0;
@@ -392,13 +474,67 @@ void *perf_string_update_thread(void *arg)
     return is_all_hit;
 }
 
+void *perf_regex_scan_thread(void *arg)
+{
+    struct thread_param *param = (struct thread_param *)arg;
+    struct maat *maat_inst = param->maat_inst;
+    const char *table_name = param->table_name;
+    struct timespec start, end;
+    const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=username,abckkk,1234567";
+    long long results[ARRAY_SIZE] = {0};
+    int hit_times = 0;
+    size_t n_hit_result = 0;
+    struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
+
+    int table_id = maat_get_table_id(maat_inst, table_name);
+    
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    for (int i = 0; i < param->test_count; i++) {
+        int ret = maat_scan_string(maat_inst, table_id, scan_data, strlen(scan_data),
+                                   results, ARRAY_SIZE, &n_hit_result, state);
+        if (ret == MAAT_SCAN_HIT) {
+            hit_times++;
+        }
+        maat_state_reset(state);
+    }
+    clock_gettime(CLOCK_MONOTONIC, &end);
+
+    param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
+    int *is_all_hit = ALLOC(int, 1);
+    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
+             "thread_id:%d regex_scan time_elapse:%lldms hit_times:%d", 
+             param->thread_id, param->time_elapse_ms, hit_times);
+    return is_all_hit;
+}
+
+void *perf_regex_update_thread(void *arg)
+{
+    struct thread_param *param = (struct thread_param *)arg;
+    struct maat *maat_inst = param->maat_inst;
+    const char *table_name = param->table_name;
+    const int CMD_EXPR_NUM = 10;
+    char keyword_buf[128];
+
+    for (int i = 0; i < CMD_EXPR_NUM; i++) {
+        random_keyword_generate(keyword_buf, sizeof(keyword_buf));
+        test_add_expr_command(maat_inst, table_name, keyword_buf);
+        sleep(1);
+    }
+
+    int *is_all_hit = ALLOC(int, 1);
+    *is_all_hit = 1;
+    
+    return is_all_hit;
+}
+
 void *perf_ip_scan_thread(void *arg)
 {
     struct thread_param *param = (struct thread_param *)arg;
     struct maat *maat_inst = param->maat_inst;
     const char *table_name = param->table_name;
     struct timespec start, end;
-    char ip_str[32] = "10.0.7.100";
+    char ip_str[32] = "10.0.0.1";
     uint32_t ip_addr;
     uint16_t port = htons(65530);
 
@@ -461,8 +597,113 @@ void *perf_ip_update_thread(void *arg)
     return is_all_hit;
 }
 
-TEST_F(MaatPerfStringScan, MultiThread) {
+void *perf_integer_scan_thread(void *arg)
-    const char *table_name = "KEYWORDS_TABLE";
+{
+    struct thread_param *param = (struct thread_param *)arg;
+    struct maat *maat_inst = param->maat_inst;
+    const char *table_name = param->table_name;
+    struct timespec start, end;
+    int hit_times = 0;
+    long long results[ARRAY_SIZE] = {0};
+    size_t n_hit_result = 0;
+
+    struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
+    int table_id = maat_get_table_id(maat_inst, table_name);
+
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    for (int i = 0; i < param->test_count; i++) {
+        int ret = maat_scan_integer(maat_inst, table_id, 3000, results,
+                                    ARRAY_SIZE, &n_hit_result, state);
+        if (ret == MAAT_SCAN_HIT) {
+            hit_times++;
+        }
+        maat_state_reset(state);
+    }
+    clock_gettime(CLOCK_MONOTONIC, &end);
+
+    param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + 
+                            (end.tv_nsec - start.tv_nsec) / 1000000;
+    int *is_all_hit = ALLOC(int, 1);
+    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
+             "thread_id:%d integer_scan time_elapse:%lldms hit_times:%d", 
+             param->thread_id, param->time_elapse_ms, hit_times);
+    return is_all_hit;
+}
+
+void *perf_integer_update_thread(void *arg)
+{
+    struct thread_param *param = (struct thread_param *)arg;
+    struct maat *maat_inst = param->maat_inst;
+    const char *table_name = param->table_name;
+    const int CMD_EXPR_NUM = 10;
+
+    for (int i = 0; i < CMD_EXPR_NUM; i++) {
+        test_add_integer_command(maat_inst, table_name, 3001+i, 3001+i);
+        sleep(1);
+    }
+
+    int *is_all_hit = ALLOC(int, 1);
+    *is_all_hit = 1;
+    
+    return is_all_hit;
+}
+
+void *perf_flag_scan_thread(void *arg)
+{
+    struct thread_param *param = (struct thread_param *)arg;
+    struct maat *maat_inst = param->maat_inst;
+    const char *table_name = param->table_name;
+    struct timespec start, end;
+    int hit_times = 0;
+    long long results[ARRAY_SIZE] = {0};
+    size_t n_hit_result = 0;
+    long long scan_data = 15;
+
+    struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
+    int table_id = maat_get_table_id(maat_inst, table_name);
+
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    for (int i = 0; i < param->test_count; i++) {
+        int ret = maat_scan_flag(maat_inst, table_id, scan_data, results,
+                                 ARRAY_SIZE, &n_hit_result, state);
+        if (ret == MAAT_SCAN_HIT) {
+            hit_times++;
+        }
+        maat_state_reset(state);
+    }
+    clock_gettime(CLOCK_MONOTONIC, &end);
+
+    param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 +
+                            (end.tv_nsec - start.tv_nsec) / 1000000;
+    int *is_all_hit = ALLOC(int, 1);
+    *is_all_hit = (hit_times == param->test_count ? 1 : 0);
+    log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
+             "thread_id:%d flag_scan time_elapse:%lldms hit_times:%d", 
+             param->thread_id, param->time_elapse_ms, hit_times);
+    return is_all_hit;
+}
+
+void *perf_flag_update_thread(void *arg)
+{
+    struct thread_param *param = (struct thread_param *)arg;
+    struct maat *maat_inst = param->maat_inst;
+    const char *table_name = param->table_name;
+    const int CMD_EXPR_NUM = 10;
+
+    for (int i = 0; i < CMD_EXPR_NUM; i++) {
+        test_add_flag_command(maat_inst, table_name, i, 15);
+        sleep(1);
+    }
+
+    int *is_all_hit = ALLOC(int, 1);
+    *is_all_hit = 1;
+    
+    return is_all_hit;
+}
+
+TEST_F(MaatPerfStringScan, LiteralMultiThread) {
+    const char *table_name = "EXPR_LITERAL_PERF_CONFIG";
     struct maat *maat_inst = MaatPerfStringScan::_shared_maat_inst;
 
     int table_id = maat_get_table_id(maat_inst, table_name);
@@ -502,12 +743,58 @@ TEST_F(MaatPerfStringScan, MultiThread) {
 		free(is_all_hit);
     }
     scan_per_second = scan_count * 1000 / time_elapse_ms;
-    //EXPECT_GT(scan_per_second, 800 * 1000);
     log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
              "StringScan match rate on %d-threads speed %lld lookups/s/thread",
              PERF_THREAD_NUM, scan_per_second);
 }
 
+TEST_F(MaatPerfStringScan, RegexMultiThread) {
+    const char *table_name = "EXPR_REGEX_PERF_CONFIG";
+    struct maat *maat_inst = MaatPerfStringScan::_shared_maat_inst;
+
+    int table_id = maat_get_table_id(maat_inst, table_name);
+    ASSERT_GT(table_id, 0);
+
+    pthread_t threads[PERF_THREAD_NUM + 1];
+    struct thread_param thread_params[PERF_THREAD_NUM + 1];
+    int i = 0;
+    int *is_all_hit = NULL;
+
+    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+        thread_params[i].maat_inst = maat_inst;
+        thread_params[i].thread_id = i;
+        thread_params[i].table_name = table_name;
+        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].time_elapse_ms = 0;
+        thread_params[i].logger = logger;
+
+        if (i < PERF_THREAD_NUM) {
+            pthread_create(&threads[i], NULL, perf_regex_scan_thread, thread_params+i);
+        } else {
+            thread_params[i].test_count = 0;
+            pthread_create(&threads[i], NULL, perf_regex_update_thread, thread_params+i);
+        }
+    }
+
+    long long time_elapse_ms = 0;
+    long long scan_count = 0;
+    long long scan_per_second = 0;
+    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+        pthread_join(threads[i], (void **)&is_all_hit);
+        time_elapse_ms += thread_params[i].time_elapse_ms;
+		scan_count += thread_params[i].test_count;
+
+		EXPECT_EQ(*is_all_hit, 1);
+		*is_all_hit = 0;
+		free(is_all_hit);
+    }
+    scan_per_second = scan_count * 1000 / time_elapse_ms;
+    
+    log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
+             "RegexScan match rate on %d-threads speed %lld lookups/s/thread",
+             PERF_THREAD_NUM, scan_per_second);
+}
+
 class MaatPerfStreamScan : public testing::Test
 {
 protected:
@@ -560,34 +847,31 @@ void *perf_stream_scan_thread(void *arg)
     struct maat *maat_inst = param->maat_inst;
     const char *table_name = param->table_name;
     struct timespec start, end;
-    const char *scan_data = "http://www.cyberessays.com/search_results.php?action=search&query=yulingjing,abckkk,1234567";
+    const char *scan_data = "http://www.cyberessays.com/search_results.php?today and yesterday";
     long long results[ARRAY_SIZE] = {0};
     int ret = 0, hit_times = 0;
     size_t n_hit_result = 0;
-    struct maat_state *state_array[ARRAY_SIZE];
+
-    struct maat_stream *sp[ARRAY_SIZE];
     int table_id = maat_get_table_id(maat_inst, table_name);
-    
+    struct maat_state *state = maat_state_new(maat_inst, param->thread_id);
+    struct maat_stream *sp = maat_stream_new(maat_inst, table_id, state);
+
     clock_gettime(CLOCK_MONOTONIC, &start);
     for (int i = 0; i < param->test_count; i++) {
-        for (int j = 0; j < ARRAY_SIZE; j++) {
+        ret = maat_stream_scan(sp, scan_data, strlen(scan_data), results, ARRAY_SIZE,
-            state_array[j] = maat_state_new(maat_inst, param->thread_id);
+                                &n_hit_result, state);
-            sp[j] = maat_stream_new(maat_inst, table_id, state_array[j]);
+        if (ret == MAAT_SCAN_HIT) {
-
+            hit_times++;
-            ret = maat_stream_scan(sp[j], scan_data, strlen(scan_data), results, ARRAY_SIZE,
-                                    &n_hit_result, state_array[j]);
-            if (ret == MAAT_SCAN_HIT) {
-                hit_times++;
-            }
-            maat_stream_free(sp[j]);
-            maat_state_free(state_array[j]);
         }
+        maat_state_reset(state);
     }
     clock_gettime(CLOCK_MONOTONIC, &end);
+    maat_stream_free(sp);
+    maat_state_free(state);
 
     param->time_elapse_ms = (end.tv_sec - start.tv_sec) * 1000 + (end.tv_nsec - start.tv_nsec) / 1000000;
     int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = ((hit_times == param->test_count*ARRAY_SIZE) ? 1 : 0);
+    *is_all_hit = ((hit_times == param->test_count) ? 1 : 0);
 
     log_info(param->logger, MODULE_FRAMEWORK_PERF_GTEST, 
              "thread_id:%d stream_scan time_elapse:%lldms hit_times:%d", 
@@ -595,64 +879,40 @@ void *perf_stream_scan_thread(void *arg)
     return is_all_hit;
 }
 
-void *perf_stream_update_thread(void *arg)
-{
-    struct thread_param *param = (struct thread_param *)arg;
-    struct maat *maat_inst = param->maat_inst;
-    const char *table_name = param->table_name;
-    const int CMD_EXPR_NUM = 10;
-    char keyword_buf[128];
-
-    for (int i = 0; i < CMD_EXPR_NUM; i++) {
-        random_keyword_generate(keyword_buf, sizeof(keyword_buf));
-        test_add_expr_command(maat_inst, table_name, keyword_buf);
-        sleep(1);
-    }
-
-    int *is_all_hit = ALLOC(int, 1);
-    *is_all_hit = 1;
-    
-    return is_all_hit;
-}
-
 TEST_F(MaatPerfStreamScan, MultiThread) {
-    const char *table_name = "HTTP_URL";
+    const char *table_name = "EXPR_LITERAL_PERF_CONFIG";
     struct maat *maat_inst = MaatPerfStreamScan::_shared_maat_inst;
 
     int table_id = maat_get_table_id(maat_inst, table_name);
     ASSERT_GT(table_id, 0);
 
-    pthread_t threads[PERF_THREAD_NUM + 1];
+    pthread_t threads[PERF_THREAD_NUM];
-    struct thread_param thread_params[PERF_THREAD_NUM + 1];
+    struct thread_param thread_params[PERF_THREAD_NUM];
     int i = 0;
     int *is_all_hit = NULL;
 
-    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+    for (i = 0; i < PERF_THREAD_NUM; i++) {
         thread_params[i].maat_inst = maat_inst;
         thread_params[i].thread_id = i;
         thread_params[i].table_name = table_name;
-        thread_params[i].test_count = PERF_SCAN_COUNT / 10;
+        thread_params[i].test_count = PERF_SCAN_COUNT;
         thread_params[i].time_elapse_ms = 0;
         thread_params[i].logger = logger;
 
         if (i < PERF_THREAD_NUM) {
             pthread_create(&threads[i], NULL, perf_stream_scan_thread, thread_params+i);
-        } else {
+        } 
-            thread_params[i].test_count = 0;
-            pthread_create(&threads[i], NULL, perf_stream_update_thread, thread_params+i);
-        }
     }
 
     long long time_elapse_ms = 0;
     long long scan_count = 0;
     long long scan_per_second = 0;
-    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+    for (i = 0; i < PERF_THREAD_NUM; i++) {
         pthread_join(threads[i], (void **)&is_all_hit);
         time_elapse_ms += thread_params[i].time_elapse_ms;
 		scan_count += thread_params[i].test_count;
         //maybe expr_runtime rebuild in stream_scan, so should not expect is_all_hit always 1
-		//EXPECT_EQ(*is_all_hit, 1);
+		EXPECT_EQ(*is_all_hit, 1);
-		*is_all_hit = 0;
 		free(is_all_hit);
     }
     scan_per_second = scan_count * 1000 / time_elapse_ms;
@@ -710,7 +970,7 @@ struct log_handle *MaatPerfIPScan::logger;
 
 TEST_F(MaatPerfIPScan, MultiThread)
 {
-    const char *table_name = "IP_PLUS_CONFIG";
+    const char *table_name = "IP_PERF_CONFIG";
     struct maat *maat_inst = MaatPerfIPScan::_shared_maat_inst;
 
     int table_id = maat_get_table_id(maat_inst, table_name);
@@ -756,6 +1016,192 @@ TEST_F(MaatPerfIPScan, MultiThread)
              PERF_THREAD_NUM, scan_per_second);
 }
 
+class MaatPerfIntegerScan : public testing::Test
+{
+protected:
+    static void SetUpTestCase() {
+        const char *accept_tags = "{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
+                                  "{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
+        char redis_ip[64] = "127.0.0.1";
+        int redis_port = 6379;
+        int redis_db = 0;
+
+        logger = log_handle_create("./maat_framework_perf_gtest.log", 0);        
+        int ret = write_config_to_redis(redis_ip, redis_port, redis_db, logger);
+        if (ret < 0) {
+            log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
+                      "[%s:%d] write config to redis failed.", __FUNCTION__, __LINE__);
+        }
+
+        struct maat_options *opts = maat_options_new();
+        maat_options_set_stat_file(opts, "./stat.log");
+        maat_options_set_perf_on(opts);
+        maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
+        maat_options_set_logger(opts, "./maat_framework_perf_gtest.log", LOG_LEVEL_INFO);
+        maat_options_set_accept_tags(opts, accept_tags);
+        maat_options_set_caller_thread_number(opts, 5);
+
+        _shared_maat_inst = maat_new(opts, table_info_path);
+        maat_options_free(opts);
+        if (NULL == _shared_maat_inst) {
+            log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
+                      "[%s:%d] create maat instance in MaatFlagScan failed.",
+                      __FUNCTION__, __LINE__);
+        }
+    }
+
+    static void TearDownTestCase() {
+        maat_free(_shared_maat_inst);
+        log_handle_destroy(logger);
+    }
+
+    static struct log_handle *logger;
+    static struct maat *_shared_maat_inst;
+};
+
+struct maat *MaatPerfIntegerScan::_shared_maat_inst;
+struct log_handle *MaatPerfIntegerScan::logger;
+
+TEST_F(MaatPerfIntegerScan, MultiThread) {
+    const char *table_name = "INTEGER_PERF_CONFIG";
+    struct maat *maat_inst = MaatPerfIntegerScan::_shared_maat_inst;
+
+    int table_id = maat_get_table_id(maat_inst, table_name);
+    ASSERT_GT(table_id, 0);
+
+    pthread_t threads[PERF_THREAD_NUM + 1];
+    struct thread_param thread_params[PERF_THREAD_NUM + 1];
+    int i = 0;
+    int *is_all_hit = NULL;
+
+    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+        thread_params[i].maat_inst = maat_inst;
+        thread_params[i].thread_id = i;
+        thread_params[i].table_name = table_name;
+        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].time_elapse_ms = 0;
+        thread_params[i].logger = logger;
+
+        if (i < PERF_THREAD_NUM) {
+            pthread_create(&threads[i], NULL, perf_integer_scan_thread, thread_params+i);
+        } else {
+            thread_params[i].test_count = 0;
+            pthread_create(&threads[i], NULL, perf_integer_update_thread, thread_params+i);
+        }
+    }
+
+    long long time_elapse_ms = 0;
+    long long scan_count = 0;
+    long long scan_per_second = 0;
+    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+        pthread_join(threads[i], (void **)&is_all_hit);
+        time_elapse_ms += thread_params[i].time_elapse_ms;
+		scan_count += thread_params[i].test_count;
+
+		EXPECT_EQ(*is_all_hit, 1);
+		*is_all_hit = 0;
+		free(is_all_hit);
+    }
+    scan_per_second = scan_count * 1000 / time_elapse_ms;
+
+    log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
+             "IntegerScan match rate on %d-threads speed %lld lookups/s/thread",
+             PERF_THREAD_NUM, scan_per_second);
+}
+
+class MaatPerfFlagScan : public testing::Test
+{
+protected:
+    static void SetUpTestCase() {
+        const char *accept_tags = "{\"tags\":[{\"tag\":\"location\",\"value\":\"北京/朝阳/华严北里/甲22号\"},"
+                                  "{\"tag\":\"isp\",\"value\":\"移动\"},{\"tag\":\"location\",\"value\":\"Astana\"}]}";
+        char redis_ip[64] = "127.0.0.1";
+        int redis_port = 6379;
+        int redis_db = 0;
+
+        logger = log_handle_create("./maat_framework_perf_gtest.log", 0);        
+        int ret = write_config_to_redis(redis_ip, redis_port, redis_db, logger);
+        if (ret < 0) {
+            log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
+                      "[%s:%d] write config to redis failed.", __FUNCTION__, __LINE__);
+        }
+
+        struct maat_options *opts = maat_options_new();
+        maat_options_set_stat_file(opts, "./stat.log");
+        maat_options_set_perf_on(opts);
+        maat_options_set_redis(opts, redis_ip, redis_port, redis_db);
+        maat_options_set_logger(opts, "./maat_framework_perf_gtest.log", LOG_LEVEL_INFO);
+        maat_options_set_accept_tags(opts, accept_tags);
+        maat_options_set_caller_thread_number(opts, 5);
+
+        _shared_maat_inst = maat_new(opts, table_info_path);
+        maat_options_free(opts);
+        if (NULL == _shared_maat_inst) {
+            log_error(logger, MODULE_FRAMEWORK_PERF_GTEST,
+                      "[%s:%d] create maat instance in MaatFlagScan failed.",
+                      __FUNCTION__, __LINE__);
+        }
+    }
+
+    static void TearDownTestCase() {
+        maat_free(_shared_maat_inst);
+        log_handle_destroy(logger);
+    }
+
+    static struct log_handle *logger;
+    static struct maat *_shared_maat_inst;
+};
+
+struct maat *MaatPerfFlagScan::_shared_maat_inst;
+struct log_handle *MaatPerfFlagScan::logger;
+
+TEST_F(MaatPerfFlagScan, MultiThread) {
+    const char *table_name = "FLAG_PERF_CONFIG";
+    struct maat *maat_inst = MaatPerfFlagScan::_shared_maat_inst;
+
+    int table_id = maat_get_table_id(maat_inst, table_name);
+    ASSERT_GT(table_id, 0);
+
+    pthread_t threads[PERF_THREAD_NUM + 1];
+    struct thread_param thread_params[PERF_THREAD_NUM + 1];
+    int i = 0;
+    int *is_all_hit = NULL;
+
+    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+        thread_params[i].maat_inst = maat_inst;
+        thread_params[i].thread_id = i;
+        thread_params[i].table_name = table_name;
+        thread_params[i].test_count = PERF_SCAN_COUNT;
+        thread_params[i].time_elapse_ms = 0;
+        thread_params[i].logger = logger;
+
+        if (i < PERF_THREAD_NUM) {
+            pthread_create(&threads[i], NULL, perf_flag_scan_thread, thread_params+i);
+        } else {
+            thread_params[i].test_count = 0;
+            pthread_create(&threads[i], NULL, perf_flag_update_thread, thread_params+i);
+        }
+    }
+
+    long long time_elapse_ms = 0;
+    long long scan_count = 0;
+    long long scan_per_second = 0;
+    for (i = 0; i < PERF_THREAD_NUM + 1; i++) {
+        pthread_join(threads[i], (void **)&is_all_hit);
+        time_elapse_ms += thread_params[i].time_elapse_ms;
+		scan_count += thread_params[i].test_count;
+
+		EXPECT_EQ(*is_all_hit, 1);
+		*is_all_hit = 0;
+		free(is_all_hit);
+    }
+    scan_per_second = scan_count * 1000 / time_elapse_ms;
+
+    log_info(maat_inst->logger, MODULE_FRAMEWORK_PERF_GTEST,
+             "FlagScan match rate on %d-threads speed %lld lookups/s/thread",
+             PERF_THREAD_NUM, scan_per_second);
+}
+
 class MaatPerfFQDNPluginScan : public testing::Test
 {
 protected:

test/maat_json.json

@@ -2973,7 +2973,135 @@
                     "not_flag": 0
                 }
             ]
-        } 
+        },
+        {
+            "compile_id": 211,
+            "service": 0,
+            "action": 0,
+            "do_blacklist": 0,
+            "do_log": 0,
+            "effective_rage": 0,
+            "user_region": "ip_perf_test",
+            "is_valid": "yes",
+            "groups": [
+                {
+                    "regions": [
+                        {
+                            "table_type": "ip_plus",
+                            "table_name": "IP_PERF_CONFIG",
+                            "table_content": {
+                                "addr_type": "ipv4",
+                                "addr_format": "range",
+                                "ip1": "10.0.0.1",
+                                "ip2": "10.0.0.6",
+                                "port_format": "range",
+                                "port1": "65530",
+                                "port2": "65535",
+                                "protocol": 6
+                            }
+                        }
+                    ],
+                    "not_flag": 0
+                }
+            ]
+        },
+        {
+            "compile_id": 212,
+            "service": 1,
+            "action": 1,
+            "do_blacklist": 1,
+            "do_log": 1,
+            "user_region": "integer_perf_test",
+            "is_valid": "yes",
+            "groups": [
+                {
+                    "group_name": "Untitled",
+                    "regions": [
+                        {
+                            "table_name": "INTEGER_PERF_CONFIG",
+                            "table_type": "interval",
+                            "table_content": {
+                                "low_boundary": 3000,
+                                "up_boundary": 3000
+                            }
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "compile_id": 213,
+            "service": 1,
+            "action": 1,
+            "do_blacklist": 1,
+            "do_log": 1,
+            "user_region": "expr_perf_test",
+            "is_valid": "yes",
+            "groups": [
+                {
+                    "regions": [
+                        {
+                            "table_name": "EXPR_LITERAL_PERF_CONFIG",
+                            "table_type": "expr",
+                            "table_content": {
+                                "keywords": "today&yesterday",
+                                "expr_type": "and",
+                                "match_method": "sub",
+                                "format": "uncase plain"
+                            }
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "compile_id": 214,
+            "service": 0,
+            "action": 0,
+            "do_blacklist": 0,
+            "do_log": 0,
+            "user_region": "flag_perf_test",
+            "is_valid": "yes",
+            "groups": [
+                {
+                    "regions": [
+                        {
+                            "table_type": "flag",
+                            "table_name": "FLAG_PERF_CONFIG",
+                            "table_content": {
+                                "flag": 15,
+                                "flag_mask": 15
+                            }
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "compile_id": 215,
+            "service": 1,
+            "action": 1,
+            "do_blacklist": 1,
+            "do_log": 1,
+            "user_region": "expr_perf_test",
+            "is_valid": "yes",
+            "groups": [
+                {
+                    "regions": [
+                        {
+                            "table_name": "EXPR_REGEX_PERF_CONFIG",
+                            "table_type": "expr",
+                            "table_content": {
+                                "keywords": "action=search\\&query=(.*)",
+                                "expr_type": "regex",
+                                "match_method": "sub",
+                                "format": "uncase plain"
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
     ],
     "plugin_table": [
         {

test/table_info.conf

@@ -495,5 +495,75 @@
         "table_name":"HTTP_URL_FILTER",
         "table_type":"virtual",
         "physical_table": "HTTP_URL"
+    },
+    {
+        "table_id":42,
+        "table_name":"IP_PERF_CONFIG",
+        "table_type":"ip_plus",
+        "valid_column":11,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "addr_type":3,
+            "addr_format":4,
+            "ip1":5,
+            "ip2":6,
+            "port_format":7,
+            "port1":8,
+            "port2":9,
+            "protocol":10
+        }
+    },
+    {
+        "table_id":43,
+        "table_name":"INTEGER_PERF_CONFIG",
+        "table_type":"intval",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "low_bound":3,
+            "up_bound":4
+        }
+    },
+    {
+        "table_id":44,
+        "table_name":"EXPR_LITERAL_PERF_CONFIG",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":45,
+        "table_name":"EXPR_REGEX_PERF_CONFIG",
+        "table_type":"expr",
+        "valid_column":7,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "keywords":3,
+            "expr_type":4,
+            "match_method":5,
+            "is_hexbin":6
+        }
+    },
+    {
+        "table_id":46,
+        "table_name":"FLAG_PERF_CONFIG",
+        "table_type":"flag",
+        "valid_column":5,
+        "custom": {
+            "item_id":1,
+            "group_id":2,
+            "flag":3,
+            "flag_mask":4
+        }
     }
 ]