353 lines
9.9 KiB
C++
353 lines
9.9 KiB
C++
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <gtest/gtest.h>
|
|
#include <limits.h>
|
|
#include <taosdef.h>
|
|
#include "os.h"
|
|
#include "tutil.h"
|
|
#include "regex.h"
|
|
#include "osDef.h"
|
|
#include "tcompare.h"
|
|
|
|
extern "C" {
|
|
typedef struct UsingRegex UsingRegex;
|
|
typedef struct HashRegexPtr HashRegexPtr;
|
|
int32_t getRegComp(const char *pPattern, HashRegexPtr **regexRet);
|
|
int32_t threadGetRegComp(regex_t **regex, const char *pPattern);
|
|
}
|
|
|
|
class regexTest {
|
|
public:
|
|
regexTest() { (void)InitRegexCache(); }
|
|
~regexTest() { (void)DestroyRegexCache(); }
|
|
};
|
|
static regexTest test;
|
|
|
|
static threadlocal regex_t pRegex;
|
|
static threadlocal char *pOldPattern = NULL;
|
|
|
|
void DestoryThreadLocalRegComp1() {
|
|
if (NULL != pOldPattern) {
|
|
regfree(&pRegex);
|
|
taosMemoryFree(pOldPattern);
|
|
pOldPattern = NULL;
|
|
}
|
|
}
|
|
|
|
static regex_t *threadGetRegComp1(const char *pPattern) {
|
|
if (NULL != pOldPattern) {
|
|
if( strcmp(pOldPattern, pPattern) == 0) {
|
|
return &pRegex;
|
|
} else {
|
|
DestoryThreadLocalRegComp1();
|
|
}
|
|
}
|
|
pOldPattern = (char*)taosMemoryMalloc(strlen(pPattern) + 1);
|
|
if (NULL == pOldPattern) {
|
|
uError("Failed to Malloc when compile regex pattern %s.", pPattern);
|
|
return NULL;
|
|
}
|
|
strcpy(pOldPattern, pPattern);
|
|
int32_t cflags = REG_EXTENDED;
|
|
int32_t ret = regcomp(&pRegex, pPattern, cflags);
|
|
if (ret != 0) {
|
|
char msgbuf[256] = {0};
|
|
regerror(ret, &pRegex, msgbuf, tListLen(msgbuf));
|
|
uError("Failed to compile regex pattern %s. reason %s", pPattern, msgbuf);
|
|
DestoryThreadLocalRegComp1();
|
|
return NULL;
|
|
}
|
|
return &pRegex;
|
|
}
|
|
|
|
TEST(testCase, regexCacheTest1) {
|
|
int times = 100000;
|
|
char s1[] = "abc";
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
#ifndef WINDOWS
|
|
uint64_t t0 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s1, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s1;
|
|
}
|
|
}
|
|
uint64_t t1 = taosGetTimestampUs();
|
|
|
|
printf("%s regex(current) %d times:%" PRIu64 " us.\n", s1, times, t1 - t0);
|
|
#endif
|
|
|
|
uint64_t t2 = taosGetTimestampUs();
|
|
for(int i = 0; i < times; i++) {
|
|
regex_t* rex = threadGetRegComp1(s1);
|
|
}
|
|
uint64_t t3 = taosGetTimestampUs();
|
|
|
|
printf("%s regex(before) %d times:%" PRIu64 " us.\n", s1, times, t3 - t2);
|
|
|
|
t2 = taosGetTimestampUs();
|
|
for(int i = 0; i < times; i++) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s1);
|
|
}
|
|
t3 = taosGetTimestampUs();
|
|
|
|
printf("%s regex(new) %d times:%" PRIu64 " us.\n", s1, times, t3 - t2);
|
|
}
|
|
|
|
TEST(testCase, regexCacheTest2) {
|
|
int times = 100000;
|
|
char s1[] = "abc%*";
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
#ifndef WINDOWS
|
|
uint64_t t0 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s1, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s1;
|
|
}
|
|
}
|
|
uint64_t t1 = taosGetTimestampUs();
|
|
|
|
printf("%s regex(current) %d times:%" PRIu64 " us.\n", s1, times, t1 - t0);
|
|
#endif
|
|
|
|
uint64_t t2 = taosGetTimestampUs();
|
|
for(int i = 0; i < times; i++) {
|
|
regex_t* rex = threadGetRegComp1(s1);
|
|
}
|
|
uint64_t t3 = taosGetTimestampUs();
|
|
|
|
printf("%s regex(before) %d times:%" PRIu64 " us.\n", s1, times, t3 - t2);
|
|
|
|
t2 = taosGetTimestampUs();
|
|
for(int i = 0; i < times; i++) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s1);
|
|
}
|
|
t3 = taosGetTimestampUs();
|
|
|
|
printf("%s regex(new) %d times:%" PRIu64 " us.\n", s1, times, t3 - t2);
|
|
}
|
|
|
|
TEST(testCase, regexCacheTest3) {
|
|
int times = 100000;
|
|
char s1[] = "abc%*";
|
|
char s2[] = "abc";
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
#ifndef WINDOWS
|
|
uint64_t t0 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s1, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s1;
|
|
}
|
|
}
|
|
uint64_t t1 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn regex(current) %d times:%" PRIu64 " us.\n", s1, s2, times, t1 - t0);
|
|
#endif
|
|
|
|
uint64_t t2 = taosGetTimestampUs();
|
|
for(int i = 0; i < times; i++) {
|
|
regex_t* rex = threadGetRegComp1(s1);
|
|
rex = threadGetRegComp1(s2);
|
|
}
|
|
uint64_t t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn regex(before) %d times:%" PRIu64 " us.\n", s1, s2, times, t3 - t2);
|
|
|
|
t2 = taosGetTimestampUs();
|
|
for(int i = 0; i < times; i++) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s1);
|
|
(void)threadGetRegComp(&rex, s2);
|
|
}
|
|
t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn regex(new) %d times:%" PRIu64 " us.\n", s1, s2, times, t3 - t2);
|
|
}
|
|
|
|
TEST(testCase, regexCacheTest4) {
|
|
int times = 100;
|
|
int count = 1000;
|
|
char s1[] = "abc%*";
|
|
char s2[] = "abc";
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
#ifndef WINDOWS
|
|
uint64_t t0 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s1, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s1;
|
|
}
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s2, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s2;
|
|
}
|
|
}
|
|
}
|
|
uint64_t t1 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(current) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t1 - t0);
|
|
#endif
|
|
|
|
uint64_t t2 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = threadGetRegComp1(s1);
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = threadGetRegComp1(s2);
|
|
}
|
|
}
|
|
uint64_t t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(before) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t3 - t2);
|
|
|
|
t2 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s1);
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s2);
|
|
}
|
|
}
|
|
t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(new) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t3 - t2);
|
|
}
|
|
|
|
// It is not a good idea to test this case, because it will take a long time.
|
|
/*
|
|
TEST(testCase, regexCacheTest5) {
|
|
int times = 10000;
|
|
int count = 10000;
|
|
char s1[] = "abc%*";
|
|
char s2[] = "abc";
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
uint64_t t0 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s1, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s1;
|
|
}
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s2, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s2;
|
|
}
|
|
}
|
|
}
|
|
uint64_t t1 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(current) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t1 - t0);
|
|
|
|
uint64_t t2 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = threadGetRegComp1(s1);
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = threadGetRegComp1(s2);
|
|
}
|
|
}
|
|
uint64_t t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(before) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t3 - t2);
|
|
|
|
t2 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s1);
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s2);
|
|
}
|
|
}
|
|
t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(new) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t3 - t2);
|
|
}
|
|
|
|
TEST(testCase, regexCacheTest6) {
|
|
int times = 10000;
|
|
int count = 1000;
|
|
char s1[] = "abc%*";
|
|
char s2[] = "abc";
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
|
|
uint64_t t0 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s1, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s1;
|
|
}
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
HashRegexPtr* ret = NULL;
|
|
int32_t code = getRegComp(s2, &ret);
|
|
if (code != 0) {
|
|
FAIL() << "Failed to compile regex pattern " << s2;
|
|
}
|
|
}
|
|
}
|
|
uint64_t t1 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(current) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t1 - t0);
|
|
|
|
uint64_t t2 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = threadGetRegComp1(s1);
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = threadGetRegComp1(s2);
|
|
}
|
|
}
|
|
uint64_t t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(before) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t3 - t2);
|
|
|
|
t2 = taosGetTimestampUs();
|
|
for (int i = 0; i < times; i++) {
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s1);
|
|
}
|
|
for (int j = 0; j < count; ++j) {
|
|
regex_t* rex = NULL;
|
|
(void)threadGetRegComp(&rex, s2);
|
|
}
|
|
}
|
|
t3 = taosGetTimestampUs();
|
|
|
|
printf("'%s' and '%s' take place by turn(per %d count) regex(new) %d times:%" PRIu64 " us.\n", s1, s2, count, times, t3 - t2);
|
|
}
|
|
*/
|