github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-06-28 16:41:01 +03:00
Code Issues Packages Projects Releases Wiki Activity

refactor mcclellan runtime

Browse Source 
1. use u32 to hold the state during runtime to prevent repeated zero extension
2. have a tight small loop for processing characters which breaks when
   something interesting happens
This commit is contained in:
Alex Coyte 2016-11-25 15:33:27 +11:00 committed by Matthew Barr
parent ef99ae108f
commit 106667e24e
3 changed files with 288 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

402
src/nfa/mcclellan.c
View File

@ -42,10 +42,10 @@
static really_inline static really_inline
char doComplexReport(NfaCallback cb, void *ctxt, const struct mcclellan *m, char doComplexReport(NfaCallback cb, void *ctxt, const struct mcclellan *m,
u16 s, u64a loc, char eod, u16 *const cached_accept_state, u32 s, u64a loc, char eod, u32 *cached_accept_state,
u32 *const cached_accept_id) { u32 *cached_accept_id) {
DEBUG_PRINTF("reporting state = %hu, loc=%llu, eod %hhu\n", DEBUG_PRINTF("reporting state = %u, loc=%llu, eod %hhu\n",
(u16)(s & STATE_MASK), loc, eod); s & STATE_MASK, loc, eod);
if (!eod && s == *cached_accept_state) { if (!eod && s == *cached_accept_state) {
if (cb(0, loc, *cached_accept_id, ctxt) == MO_HALT_MATCHING) { if (cb(0, loc, *cached_accept_id, ctxt) == MO_HALT_MATCHING) {
@ -89,25 +89,106 @@ char doComplexReport(NfaCallback cb, void *ctxt, const struct mcclellan *m,
} }
static really_inline static really_inline
char mcclellanExec16_i(const struct mcclellan *m, u16 *state, const u8 *buf, const u8 *run_mcclellan_accel(const struct mcclellan *m,
const struct mstate_aux *aux, u32 s,
const u8 **min_accel_offset,
const u8 *c, const u8 *c_end) {
DEBUG_PRINTF("skipping\n");
u32 accel_offset = aux[s].accel_offset;
assert(aux[s].accel_offset);
assert(accel_offset >= m->aux_offset);
assert(!m->sherman_offset || accel_offset < m->sherman_offset);
const union AccelAux *aaux = (const void *)((const char *)m + accel_offset);
const u8 *c2 = run_accel(aaux, c, c_end);
if (c2 < *min_accel_offset + BAD_ACCEL_DIST) {
*min_accel_offset = c2 + BIG_ACCEL_PENALTY;
} else {
*min_accel_offset = c2 + SMALL_ACCEL_PENALTY;
}
if (*min_accel_offset >= c_end - ACCEL_MIN_LEN) {
*min_accel_offset = c_end;
}
DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n",
c2 - c, *min_accel_offset - c2, c_end - c2);
return c2;
}
static really_inline
u32 doNormal16(const struct mcclellan *m, const u8 **c_inout, const u8 *end,
u32 s, char do_accel, enum MatchMode mode) {
const u8 *c = *c_inout;
const u16 *succ_table
= (const u16 *)((const char *)m + sizeof(struct mcclellan));
assert(ISALIGNED_N(succ_table, 2));
u32 sherman_base = m->sherman_limit;
const char *sherman_base_offset
= (const char *)m - sizeof(struct NFA) + m->sherman_offset;
u32 as = m->alphaShift;
s &= STATE_MASK;
while (c < end && s) {
u8 cprime = m->remap[*c];
DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx (s=%u)\n", *c,
ourisprint(*c) ? *c : '?', cprime, s);
if (s < sherman_base) {
DEBUG_PRINTF("doing normal\n");
assert(s < m->state_count);
s = succ_table[(s << as) + cprime];
} else {
const char *sherman_state
= findShermanState(m, sherman_base_offset, sherman_base, s);
DEBUG_PRINTF("doing sherman (%hu)\n", s);
s = doSherman16(sherman_state, cprime, succ_table, as);
}
DEBUG_PRINTF("s: %u (%u)\n", s, s & STATE_MASK);
c++;
if (do_accel && (s & ACCEL_FLAG)) {
break;
}
if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) {
break;
}
s &= STATE_MASK;
}
*c_inout = c;
return s;
}
static really_inline
char mcclellanExec16_i(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **c_final, enum MatchMode mode) { char single, const u8 **c_final, enum MatchMode mode) {
assert(ISALIGNED_N(state, 2)); assert(ISALIGNED_N(state, 2));
if (!len) {
if (mode == STOP_AT_MATCH) {
*c_final = buf;
}
return MO_CONTINUE_MATCHING;
}
u16 s = *state; u32 s = *state;
const u8 *c = buf, *c_end = buf + len; const u8 *c = buf;
const u16 *succ_table = (const u16 *)((const char *)m const u8 *c_end = buf + len;
+ sizeof(struct mcclellan)); const struct mstate_aux *aux
assert(ISALIGNED_N(succ_table, 2)); = (const struct mstate_aux *)((const char *)m + m->aux_offset
const u16 sherman_base = m->sherman_limit; - sizeof(struct NFA));
const char *sherman_base_offset
= (const char *)m - sizeof(struct NFA) + m->sherman_offset;
const u32 as = m->alphaShift;
s &= STATE_MASK; s &= STATE_MASK;
u32 cached_accept_id = 0; u32 cached_accept_id = 0;
u16 cached_accept_state = 0; u32 cached_accept_state = 0;
DEBUG_PRINTF("s: %hu, len %zu\n", s, len); DEBUG_PRINTF("s: %hu, len %zu\n", s, len);
@ -120,20 +201,13 @@ char mcclellanExec16_i(const struct mcclellan *m, u16 *state, const u8 *buf,
goto with_accel; goto with_accel;
without_accel: without_accel:
while (c < min_accel_offset && s) { do {
u8 cprime = m->remap[*(c++)]; assert(c < min_accel_offset);
DEBUG_PRINTF("c: %02hhx cp:%02hhx (s=%hu)\n", *(c-1), cprime, s); if (!s) {
if (s < sherman_base) { goto exit;
DEBUG_PRINTF("doing normal\n");
assert(s < m->state_count);
s = succ_table[((u32)s << as) + cprime];
} else {
const char *sherman_state
= findShermanState(m, sherman_base_offset, sherman_base, s);
DEBUG_PRINTF("doing sherman (%hu)\n", s);
s = doSherman16(sherman_state, cprime, succ_table, as);
} }
DEBUG_PRINTF("s: %hu (%hu)\n", s, (u16)(s & STATE_MASK));
s = doNormal16(m, &c, min_accel_offset, s, 0, mode);
if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) {
if (mode == STOP_AT_MATCH) { if (mode == STOP_AT_MATCH) {
@ -150,30 +224,42 @@ without_accel:
return MO_HALT_MATCHING; /* termination requested */ return MO_HALT_MATCHING; /* termination requested */
} }
} else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0, } else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0,
&cached_accept_state, &cached_accept_state, &cached_accept_id)
&cached_accept_id) == MO_HALT_MATCHING) { == MO_HALT_MATCHING) {
return MO_HALT_MATCHING; return MO_HALT_MATCHING;
} }
} }
assert(c <= min_accel_offset);
} while (c < min_accel_offset);
s &= STATE_MASK; s &= STATE_MASK;
if (c == c_end) {
goto exit;
} else {
goto with_accel;
} }
with_accel: with_accel:
while (c < c_end && s) { do {
u8 cprime = m->remap[*(c++)]; assert(c < c_end);
DEBUG_PRINTF("c: %02hhx cp:%02hhx (s=%hu)\n", *(c-1), cprime, s); if (!s) {
if (s < sherman_base) { goto exit;
DEBUG_PRINTF("doing normal\n");
assert(s < m->state_count);
s = succ_table[((u32)s << as) + cprime];
} else {
const char *sherman_state
= findShermanState(m, sherman_base_offset, sherman_base, s);
DEBUG_PRINTF("doing sherman (%hu)\n", s);
s = doSherman16(sherman_state, cprime, succ_table, as);
} }
DEBUG_PRINTF("s: %hu (%hu)\n", s, (u16)(s & STATE_MASK));
if (s & ACCEL_FLAG) {
DEBUG_PRINTF("skipping\n");
s &= STATE_MASK;
c = run_mcclellan_accel(m, aux, s, &min_accel_offset, c, c_end);
if (c == c_end) {
goto exit;
} else {
goto without_accel;
}
}
s = doNormal16(m, &c, c_end, s, 1, mode);
if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) {
if (mode == STOP_AT_MATCH) { if (mode == STOP_AT_MATCH) {
@ -190,42 +276,17 @@ with_accel:
return MO_HALT_MATCHING; /* termination requested */ return MO_HALT_MATCHING; /* termination requested */
} }
} else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0, } else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0,
&cached_accept_state, &cached_accept_state, &cached_accept_id)
&cached_accept_id) == MO_HALT_MATCHING) { == MO_HALT_MATCHING) {
return MO_HALT_MATCHING; return MO_HALT_MATCHING;
} }
} else if (s & ACCEL_FLAG) {
DEBUG_PRINTF("skipping\n");
const struct mstate_aux *this_aux = get_aux(m, s & STATE_MASK);
u32 accel_offset = this_aux->accel_offset;
assert(accel_offset >= m->aux_offset);
assert(accel_offset < m->sherman_offset);
const union AccelAux *aaux
= (const void *)((const char *)m + accel_offset);
const u8 *c2 = run_accel(aaux, c, c_end);
if (c2 < min_accel_offset + BAD_ACCEL_DIST) {
min_accel_offset = c2 + BIG_ACCEL_PENALTY;
} else {
min_accel_offset = c2 + SMALL_ACCEL_PENALTY;
} }
if (min_accel_offset >= c_end - ACCEL_MIN_LEN) { assert(c <= c_end);
min_accel_offset = c_end; } while (c < c_end);
}
DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n", exit:
c2 - c, min_accel_offset - c2, c_end - c2);
c = c2;
s &= STATE_MASK; s &= STATE_MASK;
goto without_accel;
}
s &= STATE_MASK;
}
if (mode == STOP_AT_MATCH) { if (mode == STOP_AT_MATCH) {
*c_final = c_end; *c_final = c_end;
@ -236,7 +297,7 @@ with_accel:
} }
static never_inline static never_inline
char mcclellanExec16_i_cb(const struct mcclellan *m, u16 *state, const u8 *buf, char mcclellanExec16_i_cb(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point) { char single, const u8 **final_point) {
return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single,
@ -244,7 +305,7 @@ char mcclellanExec16_i_cb(const struct mcclellan *m, u16 *state, const u8 *buf,
} }
static never_inline static never_inline
char mcclellanExec16_i_sam(const struct mcclellan *m, u16 *state, const u8 *buf, char mcclellanExec16_i_sam(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point) { char single, const u8 **final_point) {
return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single,
@ -252,7 +313,7 @@ char mcclellanExec16_i_sam(const struct mcclellan *m, u16 *state, const u8 *buf,
} }
static never_inline static never_inline
char mcclellanExec16_i_nm(const struct mcclellan *m, u16 *state, const u8 *buf, char mcclellanExec16_i_nm(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point) { char single, const u8 **final_point) {
return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single,
@ -260,7 +321,7 @@ char mcclellanExec16_i_nm(const struct mcclellan *m, u16 *state, const u8 *buf,
} }
static really_inline static really_inline
char mcclellanExec16_i_ni(const struct mcclellan *m, u16 *state, const u8 *buf, char mcclellanExec16_i_ni(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point, char single, const u8 **final_point,
enum MatchMode mode) { enum MatchMode mode) {
@ -271,35 +332,68 @@ char mcclellanExec16_i_ni(const struct mcclellan *m, u16 *state, const u8 *buf,
return mcclellanExec16_i_sam(m, state, buf, len, offAdj, cb, ctxt, return mcclellanExec16_i_sam(m, state, buf, len, offAdj, cb, ctxt,
single, final_point); single, final_point);
} else { } else {
assert (mode == NO_MATCHES); assert(mode == NO_MATCHES);
return mcclellanExec16_i_nm(m, state, buf, len, offAdj, cb, ctxt, return mcclellanExec16_i_nm(m, state, buf, len, offAdj, cb, ctxt,
single, final_point); single, final_point);
} }
} }
static really_inline static really_inline
char mcclellanExec8_i(const struct mcclellan *m, u8 *state, const u8 *buf, u32 doNormal8(const struct mcclellan *m, const u8 **c_inout, const u8 *end,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, u32 s, char do_accel, enum MatchMode mode) {
char single, const u8 **c_final, enum MatchMode mode) { const u8 *c = *c_inout;
u8 s = *state; u32 accel_limit = m->accel_limit_8;
const u8 *c = buf, *c_end = buf + len; u32 accept_limit = m->accept_limit_8;
const u32 as = m->alphaShift;
const u8 *succ_table = (const u8 *)((const char *)m const u8 *succ_table = (const u8 *)((const char *)m
+ sizeof(struct mcclellan)); + sizeof(struct mcclellan));
const u32 as = m->alphaShift; while (c < end && s) {
const struct mstate_aux *aux; u8 cprime = m->remap[*c];
DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx\n", *c,
ourisprint(*c) ? *c : '?', cprime);
s = succ_table[(s << as) + cprime];
aux = (const struct mstate_aux *)((const char *)m + m->aux_offset DEBUG_PRINTF("s: %hhu\n", s);
c++;
if (do_accel) {
if (s >= accel_limit) {
break;
}
} else {
if (mode != NO_MATCHES && s >= accept_limit) {
break;
}
}
}
*c_inout = c;
return s;
}
static really_inline
char mcclellanExec8_i(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **c_final, enum MatchMode mode) {
if (!len) {
*c_final = buf;
return MO_CONTINUE_MATCHING;
}
u32 s = *state;
const u8 *c = buf;
const u8 *c_end = buf + len;
const struct mstate_aux *aux
= (const struct mstate_aux *)((const char *)m + m->aux_offset
- sizeof(struct NFA)); - sizeof(struct NFA));
u32 accept_limit = m->accept_limit_8;
u16 accel_limit = m->accel_limit_8;
u16 accept_limit = m->accept_limit_8;
u32 cached_accept_id = 0; u32 cached_accept_id = 0;
u16 cached_accept_state = 0; u32 cached_accept_state = 0;
DEBUG_PRINTF("accel %hu, accept %hu\n", accel_limit, accept_limit); DEBUG_PRINTF("accel %hu, accept %hu\n",
m->accel_limit_8, m->accept_limit_8);
DEBUG_PRINTF("s: %hhu, len %zu\n", s, len); DEBUG_PRINTF("s: %u, len %zu\n", s, len);
const u8 *min_accel_offset = c; const u8 *min_accel_offset = c;
if (!m->has_accel || len < ACCEL_MIN_LEN) { if (!m->has_accel || len < ACCEL_MIN_LEN) {
@ -310,12 +404,13 @@ char mcclellanExec8_i(const struct mcclellan *m, u8 *state, const u8 *buf,
goto with_accel; goto with_accel;
without_accel: without_accel:
while (c < min_accel_offset && s) { do {
u8 cprime = m->remap[*(c++)]; assert(c < min_accel_offset);
DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx\n", *(c-1), if (!s) {
ourisprint(*(c-1)) ? *(c-1) : '?', cprime); goto exit;
s = succ_table[((u32)s << as) + cprime]; }
DEBUG_PRINTF("s: %hhu\n", s);
s = doNormal8(m, &c, min_accel_offset, s, 0, mode);
if (mode != NO_MATCHES && s >= accept_limit) { if (mode != NO_MATCHES && s >= accept_limit) {
if (mode == STOP_AT_MATCH) { if (mode == STOP_AT_MATCH) {
@ -332,23 +427,38 @@ without_accel:
return MO_HALT_MATCHING; return MO_HALT_MATCHING;
} }
} else if (doComplexReport(cb, ctxt, m, s, loc, 0, } else if (doComplexReport(cb, ctxt, m, s, loc, 0,
&cached_accept_state, &cached_accept_state, &cached_accept_id)
&cached_accept_id)
== MO_HALT_MATCHING) { == MO_HALT_MATCHING) {
return MO_HALT_MATCHING; return MO_HALT_MATCHING;
} }
} }
assert(c <= min_accel_offset);
} while (c < min_accel_offset);
if (c == c_end) {
goto exit;
} }
with_accel: with_accel:
while (c < c_end && s) { do {
u8 cprime = m->remap[*(c++)]; u32 accel_limit = m->accel_limit_8;
DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx\n", *(c-1), assert(c < c_end);
ourisprint(*(c-1)) ? *(c-1) : '?', cprime);
s = succ_table[((u32)s << as) + cprime]; if (!s) {
DEBUG_PRINTF("s: %hhu\n", s); goto exit;
}
if (s >= accel_limit && aux[s].accel_offset) {
c = run_mcclellan_accel(m, aux, s, &min_accel_offset, c, c_end);
if (c == c_end) {
goto exit;
} else {
goto without_accel;
}
}
s = doNormal8(m, &c, c_end, s, 1, mode);
if (s >= accel_limit) { /* accept_limit >= accel_limit */
if (mode != NO_MATCHES && s >= accept_limit) { if (mode != NO_MATCHES && s >= accept_limit) {
if (mode == STOP_AT_MATCH) { if (mode == STOP_AT_MATCH) {
DEBUG_PRINTF("match - pausing\n"); DEBUG_PRINTF("match - pausing\n");
@ -364,37 +474,16 @@ with_accel:
return MO_HALT_MATCHING; return MO_HALT_MATCHING;
} }
} else if (doComplexReport(cb, ctxt, m, s, loc, 0, } else if (doComplexReport(cb, ctxt, m, s, loc, 0,
&cached_accept_state, &cached_accept_state, &cached_accept_id)
&cached_accept_id)
== MO_HALT_MATCHING) { == MO_HALT_MATCHING) {
return MO_HALT_MATCHING; return MO_HALT_MATCHING;
} }
} else if (aux[s].accel_offset) {
DEBUG_PRINTF("skipping\n");
const union AccelAux *aaux = (const void *)((const char *)m
+ aux[s].accel_offset);
const u8 *c2 = run_accel(aaux, c, c_end);
if (c2 < min_accel_offset + BAD_ACCEL_DIST) {
min_accel_offset = c2 + BIG_ACCEL_PENALTY;
} else {
min_accel_offset = c2 + SMALL_ACCEL_PENALTY;
} }
if (min_accel_offset >= c_end - ACCEL_MIN_LEN) { assert(c <= c_end);
min_accel_offset = c_end; } while (c < c_end);
}
DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n",
c2 - c, min_accel_offset - c2, c_end - c2);
c = c2;
goto without_accel;
}
}
}
exit:
*state = s; *state = s;
if (mode == STOP_AT_MATCH) { if (mode == STOP_AT_MATCH) {
*c_final = c_end; *c_final = c_end;
@ -403,7 +492,7 @@ with_accel:
} }
static never_inline static never_inline
char mcclellanExec8_i_cb(const struct mcclellan *m, u8 *state, const u8 *buf, char mcclellanExec8_i_cb(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point) { char single, const u8 **final_point) {
return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single,
@ -411,7 +500,7 @@ char mcclellanExec8_i_cb(const struct mcclellan *m, u8 *state, const u8 *buf,
} }
static never_inline static never_inline
char mcclellanExec8_i_sam(const struct mcclellan *m, u8 *state, const u8 *buf, char mcclellanExec8_i_sam(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point) { char single, const u8 **final_point) {
return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single,
@ -419,7 +508,7 @@ char mcclellanExec8_i_sam(const struct mcclellan *m, u8 *state, const u8 *buf,
} }
static never_inline static never_inline
char mcclellanExec8_i_nm(const struct mcclellan *m, u8 *state, const u8 *buf, char mcclellanExec8_i_nm(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point) { char single, const u8 **final_point) {
return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single,
@ -427,7 +516,7 @@ char mcclellanExec8_i_nm(const struct mcclellan *m, u8 *state, const u8 *buf,
} }
static really_inline static really_inline
char mcclellanExec8_i_ni(const struct mcclellan *m, u8 *state, const u8 *buf, char mcclellanExec8_i_ni(const struct mcclellan *m, u32 *state, const u8 *buf,
size_t len, u64a offAdj, NfaCallback cb, void *ctxt, size_t len, u64a offAdj, NfaCallback cb, void *ctxt,
char single, const u8 **final_point, char single, const u8 **final_point,
enum MatchMode mode) { enum MatchMode mode) {
@ -445,7 +534,7 @@ char mcclellanExec8_i_ni(const struct mcclellan *m, u8 *state, const u8 *buf,
} }
static really_inline static really_inline
char mcclellanCheckEOD(const struct NFA *nfa, u16 s, u64a offset, char mcclellanCheckEOD(const struct NFA *nfa, u32 s, u64a offset,
NfaCallback cb, void *ctxt) { NfaCallback cb, void *ctxt) {
const struct mcclellan *m = getImplNfa(nfa); const struct mcclellan *m = getImplNfa(nfa);
const struct mstate_aux *aux = get_aux(m, s); const struct mstate_aux *aux = get_aux(m, s);
@ -466,7 +555,7 @@ char nfaExecMcClellan16_Q2i(const struct NFA *n, u64a offset, const u8 *buffer,
s64a sp; s64a sp;
assert(ISALIGNED_N(q->state, 2)); assert(ISALIGNED_N(q->state, 2));
u16 s = *(u16 *)q->state; u32 s = *(u16 *)q->state;
if (q->report_current) { if (q->report_current) {
assert(s); assert(s);
@ -478,7 +567,7 @@ char nfaExecMcClellan16_Q2i(const struct NFA *n, u64a offset, const u8 *buffer,
rv = cb(0, q_cur_offset(q), m->arb_report, context); rv = cb(0, q_cur_offset(q), m->arb_report, context);
} else { } else {
u32 cached_accept_id = 0; u32 cached_accept_id = 0;
u16 cached_accept_state = 0; u32 cached_accept_state = 0;
rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0, rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0,
&cached_accept_state, &cached_accept_id); &cached_accept_state, &cached_accept_id);
@ -532,8 +621,7 @@ char nfaExecMcClellan16_Q2i(const struct NFA *n, u64a offset, const u8 *buffer,
if (mode == STOP_AT_MATCH && final_look != cur_buf + local_ep) { if (mode == STOP_AT_MATCH && final_look != cur_buf + local_ep) {
DEBUG_PRINTF("this is as far as we go\n"); DEBUG_PRINTF("this is as far as we go\n");
assert(q->cur); assert(q->cur);
DEBUG_PRINTF("state %hu final_look %zd\n", s, DEBUG_PRINTF("state %hu final_look %zd\n", s, final_look - cur_buf);
final_look - cur_buf);
q->cur--; q->cur--;
q->items[q->cur].type = MQE_START; q->items[q->cur].type = MQE_START;
q->items[q->cur].location = final_look - cur_buf + 1; /* due to q->items[q->cur].location = final_look - cur_buf + 1; /* due to
@ -584,12 +672,12 @@ char nfaExecMcClellan16_Q2i(const struct NFA *n, u64a offset, const u8 *buffer,
} }
static really_inline static really_inline
char nfaExecMcClellan16_Bi(const struct NFA *n, u64a offset, char nfaExecMcClellan16_Bi(const struct NFA *n, u64a offset, const u8 *buffer,
const u8 *buffer, size_t length, size_t length, NfaCallback cb, void *context,
NfaCallback cb, void *context, char single) { char single) {
assert(n->type == MCCLELLAN_NFA_16); assert(n->type == MCCLELLAN_NFA_16);
const struct mcclellan *m = getImplNfa(n); const struct mcclellan *m = getImplNfa(n);
u16 s = m->start_anchored; u32 s = m->start_anchored;
if (mcclellanExec16_i(m, &s, buffer, length, offset, cb, context, single, if (mcclellanExec16_i(m, &s, buffer, length, offset, cb, context, single,
NULL, CALLBACK_OUTPUT) NULL, CALLBACK_OUTPUT)
@ -615,7 +703,7 @@ char nfaExecMcClellan8_Q2i(const struct NFA *n, u64a offset, const u8 *buffer,
const struct mcclellan *m = getImplNfa(n); const struct mcclellan *m = getImplNfa(n);
s64a sp; s64a sp;
u8 s = *(u8 *)q->state; u32 s = *(u8 *)q->state;
if (q->report_current) { if (q->report_current) {
assert(s); assert(s);
@ -627,7 +715,7 @@ char nfaExecMcClellan8_Q2i(const struct NFA *n, u64a offset, const u8 *buffer,
rv = cb(0, q_cur_offset(q), m->arb_report, context); rv = cb(0, q_cur_offset(q), m->arb_report, context);
} else { } else {
u32 cached_accept_id = 0; u32 cached_accept_id = 0;
u16 cached_accept_state = 0; u32 cached_accept_state = 0;
rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0, rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0,
&cached_accept_state, &cached_accept_id); &cached_accept_state, &cached_accept_id);
@ -738,7 +826,7 @@ char nfaExecMcClellan8_Bi(const struct NFA *n, u64a offset, const u8 *buffer,
char single) { char single) {
assert(n->type == MCCLELLAN_NFA_8); assert(n->type == MCCLELLAN_NFA_8);
const struct mcclellan *m = getImplNfa(n); const struct mcclellan *m = getImplNfa(n);
u8 s = (u8)m->start_anchored; u32 s = m->start_anchored;
if (mcclellanExec8_i(m, &s, buffer, length, offset, cb, context, single, if (mcclellanExec8_i(m, &s, buffer, length, offset, cb, context, single,
NULL, CALLBACK_OUTPUT) NULL, CALLBACK_OUTPUT)
@ -811,7 +899,7 @@ char nfaExecMcClellan8_reportCurrent(const struct NFA *n, struct mq *q) {
const struct mcclellan *m = getImplNfa(n); const struct mcclellan *m = getImplNfa(n);
NfaCallback cb = q->cb; NfaCallback cb = q->cb;
void *ctxt = q->context; void *ctxt = q->context;
u8 s = *(u8 *)q->state; u32 s = *(u8 *)q->state;
u8 single = m->flags & MCCLELLAN_FLAG_SINGLE; u8 single = m->flags & MCCLELLAN_FLAG_SINGLE;
u64a offset = q_cur_offset(q); u64a offset = q_cur_offset(q);
assert(q_cur_type(q) == MQE_START); assert(q_cur_type(q) == MQE_START);
@ -823,7 +911,7 @@ char nfaExecMcClellan8_reportCurrent(const struct NFA *n, struct mq *q) {
cb(0, offset, m->arb_report, ctxt); cb(0, offset, m->arb_report, ctxt);
} else { } else {
u32 cached_accept_id = 0; u32 cached_accept_id = 0;
u16 cached_accept_state = 0; u32 cached_accept_state = 0;
doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state, doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state,
&cached_accept_id); &cached_accept_id);
@ -837,7 +925,7 @@ char nfaExecMcClellan16_reportCurrent(const struct NFA *n, struct mq *q) {
const struct mcclellan *m = getImplNfa(n); const struct mcclellan *m = getImplNfa(n);
NfaCallback cb = q->cb; NfaCallback cb = q->cb;
void *ctxt = q->context; void *ctxt = q->context;
u16 s = *(u16 *)q->state; u32 s = *(u16 *)q->state;
const struct mstate_aux *aux = get_aux(m, s); const struct mstate_aux *aux = get_aux(m, s);
u8 single = m->flags & MCCLELLAN_FLAG_SINGLE; u8 single = m->flags & MCCLELLAN_FLAG_SINGLE;
u64a offset = q_cur_offset(q); u64a offset = q_cur_offset(q);
@ -851,7 +939,7 @@ char nfaExecMcClellan16_reportCurrent(const struct NFA *n, struct mq *q) {
cb(0, offset, m->arb_report, ctxt); cb(0, offset, m->arb_report, ctxt);
} else { } else {
u32 cached_accept_id = 0; u32 cached_accept_id = 0;
u16 cached_accept_state = 0; u32 cached_accept_state = 0;
doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state, doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state,
&cached_accept_id); &cached_accept_id);
@ -1025,7 +1113,7 @@ void nfaExecMcClellan8_SimpStream(const struct NFA *nfa, char *state,
size_t len, NfaCallback cb, void *ctxt) { size_t len, NfaCallback cb, void *ctxt) {
const struct mcclellan *m = getImplNfa(nfa); const struct mcclellan *m = getImplNfa(nfa);
u8 s = top ? m->start_anchored : *(u8 *)state; u32 s = top ? m->start_anchored : *(u8 *)state;
if (m->flags & MCCLELLAN_FLAG_SINGLE) { if (m->flags & MCCLELLAN_FLAG_SINGLE) {
mcclellanExec8_i(m, &s, buf + start_off, len - start_off, mcclellanExec8_i(m, &s, buf + start_off, len - start_off,
@ -1043,7 +1131,7 @@ void nfaExecMcClellan16_SimpStream(const struct NFA *nfa, char *state,
size_t len, NfaCallback cb, void *ctxt) { size_t len, NfaCallback cb, void *ctxt) {
const struct mcclellan *m = getImplNfa(nfa); const struct mcclellan *m = getImplNfa(nfa);
u16 s = top ? m->start_anchored : unaligned_load_u16(state); u32 s = top ? m->start_anchored : unaligned_load_u16(state);
if (m->flags & MCCLELLAN_FLAG_SINGLE) { if (m->flags & MCCLELLAN_FLAG_SINGLE) {
mcclellanExec16_i(m, &s, buf + start_off, len - start_off, mcclellanExec16_i(m, &s, buf + start_off, len - start_off,
@ -1071,13 +1159,15 @@ char nfaExecMcClellan16_testEOD(const struct NFA *nfa, const char *state,
context); context);
} }
char nfaExecMcClellan8_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { char nfaExecMcClellan8_queueInitState(UNUSED const struct NFA *nfa,
struct mq *q) {
assert(nfa->scratchStateSize == 1); assert(nfa->scratchStateSize == 1);
*(u8 *)q->state = 0; *(u8 *)q->state = 0;
return 0; return 0;
} }
char nfaExecMcClellan16_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { char nfaExecMcClellan16_queueInitState(UNUSED const struct NFA *nfa,
struct mq *q) {
assert(nfa->scratchStateSize == 2); assert(nfa->scratchStateSize == 2);
assert(ISALIGNED_N(q->state, 2)); assert(ISALIGNED_N(q->state, 2));
*(u16 *)q->state = 0; *(u16 *)q->state = 0;

18
src/nfa/mcclellan_common_impl.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, Intel Corporation * Copyright (c) 2015-2016, Intel Corporation
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
@ -33,7 +33,7 @@ enum MatchMode {
}; };
static really_inline static really_inline
const struct mstate_aux *get_aux(const struct mcclellan *m, u16 s) { const struct mstate_aux *get_aux(const struct mcclellan *m, u32 s) {
const char *nfa = (const char *)m - sizeof(struct NFA); const char *nfa = (const char *)m - sizeof(struct NFA);
const struct mstate_aux *aux const struct mstate_aux *aux
= s + (const struct mstate_aux *)(nfa + m->aux_offset); = s + (const struct mstate_aux *)(nfa + m->aux_offset);
@ -43,7 +43,7 @@ const struct mstate_aux *get_aux(const struct mcclellan *m, u16 s) {
} }
static really_inline static really_inline
u16 mcclellanEnableStarts(const struct mcclellan *m, u16 s) { u32 mcclellanEnableStarts(const struct mcclellan *m, u32 s) {
const struct mstate_aux *aux = get_aux(m, s); const struct mstate_aux *aux = get_aux(m, s);
DEBUG_PRINTF("enabling starts %hu->%hu\n", s, aux->top); DEBUG_PRINTF("enabling starts %hu->%hu\n", s, aux->top);
@ -51,7 +51,7 @@ u16 mcclellanEnableStarts(const struct mcclellan *m, u16 s) {
} }
static really_inline static really_inline
u16 doSherman16(const char *sherman_state, u8 cprime, const u16 *succ_table, u32 doSherman16(const char *sherman_state, u8 cprime, const u16 *succ_table,
u32 as) { u32 as) {
assert(ISALIGNED_N(sherman_state, 16)); assert(ISALIGNED_N(sherman_state, 16));
@ -70,15 +70,15 @@ u16 doSherman16(const char *sherman_state, u8 cprime, const u16 *succ_table,
if (z) { if (z) {
u32 i = ctz32(z & ~0xf) - 4; u32 i = ctz32(z & ~0xf) - 4;
u16 s_out = unaligned_load_u16((const u8 *)sherman_state u32 s_out = unaligned_load_u16((const u8 *)sherman_state
+ SHERMAN_STATES_OFFSET(len) + SHERMAN_STATES_OFFSET(len)
+ sizeof(u16) * i); + sizeof(u16) * i);
DEBUG_PRINTF("found sherman match at %u/%u for c'=%hhu " DEBUG_PRINTF("found sherman match at %u/%u for c'=%hhu s=%u\n", i,
"s=%hu\n", i, len, cprime, s_out); len, cprime, s_out);
return s_out; return s_out;
} }
} }
u16 daddy = *(const u16 *)(sherman_state + SHERMAN_DADDY_OFFSET); u32 daddy = *(const u16 *)(sherman_state + SHERMAN_DADDY_OFFSET);
return succ_table[((u32)daddy << as) + cprime]; return succ_table[(daddy << as) + cprime];
} }

8
src/nfa/mcclellan_internal.h
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2015, Intel Corporation * Copyright (c) 2015-2016, Intel Corporation
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
@ -90,8 +90,8 @@ struct mcclellan {
static really_inline static really_inline
const char *findShermanState(UNUSED const struct mcclellan *m, const char *findShermanState(UNUSED const struct mcclellan *m,
const char *sherman_base_offset, u16 sherman_base, const char *sherman_base_offset, u32 sherman_base,
u16 s) { u32 s) {
const char *rv const char *rv
= sherman_base_offset + SHERMAN_FIXED_SIZE * (s - sherman_base); = sherman_base_offset + SHERMAN_FIXED_SIZE * (s - sherman_base);
assert(rv < (const char *)m + m->length - sizeof(struct NFA)); assert(rv < (const char *)m + m->length - sizeof(struct NFA));
@ -102,7 +102,7 @@ const char *findShermanState(UNUSED const struct mcclellan *m,
static really_inline static really_inline
char *findMutableShermanState(char *sherman_base_offset, u16 sherman_base, char *findMutableShermanState(char *sherman_base_offset, u16 sherman_base,
u16 s) { u32 s) {
return sherman_base_offset + SHERMAN_FIXED_SIZE * (s - sherman_base); return sherman_base_offset + SHERMAN_FIXED_SIZE * (s - sherman_base);
} }