Spaces:
Running on Zero
Running on Zero
| // Phase52: warp-parallel frozen normalization, then original B matching/evaluation. | |
| // All exceptional rows replay the unchanged serial normalizer on one GPU lane. | |
| // Input/output semantics, 2x arenas, raw streams and taxonomy packing retain B. | |
| struct Candidate { int kind, index, start, end; }; | |
| __device__ __forceinline__ bool token(unsigned char c) { | |
| return (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_'; | |
| } | |
| __device__ __forceinline__ bool exact_token(unsigned char c) { | |
| return token(c) || (c >= 'A' && c <= 'Z'); | |
| } | |
| __device__ __forceinline__ unsigned char lower(unsigned char c) { | |
| return c >= 'A' && c <= 'Z' ? c + 32 : c; | |
| } | |
| __device__ __forceinline__ unsigned char normalize(unsigned char c) { | |
| c = lower(c); | |
| if (c == '-' || c == '.' || c == ',' || c == ':' || c == ';' || | |
| c == '(' || c == ')' || c == '[' || c == ']' || c == '{' || | |
| c == '}' || c == '/') return ' '; | |
| return c == '`' ? '\'' : c; | |
| } | |
| __device__ __forceinline__ bool space(unsigned char c) { | |
| return c == ' ' || (c >= 9 && c <= 13) || (c >= 0x1c && c <= 0x1f); | |
| } | |
| // All candidate identities are unique before the fixed-size buffer is used. | |
| // An overflow transfers the whole row to CPU; no partial result is retained. | |
| __device__ bool append_hit( | |
| int key, int start, int end, const int* key_offsets, | |
| const int* key_consumers, const int* consumers, | |
| Candidate* candidates, int* count, unsigned char* conjunctions | |
| ) { | |
| for (int i = key_offsets[key]; i < key_offsets[key + 1]; ++i) { | |
| const int* spec = consumers + key_consumers[i] * 4; | |
| if (spec[0] == 2) { | |
| conjunctions[spec[1]] |= (unsigned char)(1u << spec[2]); | |
| continue; | |
| } | |
| bool duplicate = false; | |
| for (int j = 0; j < *count; ++j) { | |
| Candidate prior = candidates[j]; | |
| if (prior.kind == spec[0] && prior.index == spec[1] && | |
| prior.start == start && prior.end == end) { | |
| duplicate = true; break; | |
| } | |
| } | |
| if (duplicate) continue; | |
| if (*count == MAX_CANDIDATES) return false; | |
| candidates[*count] = Candidate{spec[0], spec[1], start, end}; | |
| ++*count; | |
| } | |
| return true; | |
| } | |
| __device__ int lower_bound_offset(const unsigned int* offsets, int n, int value) { | |
| int left = 0, right = n; | |
| while (left < right) { | |
| int middle = left + (right - left) / 2; | |
| if (offsets[middle] < (unsigned int)value) left = middle + 1; | |
| else right = middle; | |
| } | |
| return left; | |
| } | |
| __device__ bool contains_term( | |
| const unsigned char* text, int left, int right, int term, | |
| const unsigned char* term_bytes, const int* term_offsets | |
| ) { | |
| int first = term_offsets[term], length = term_offsets[term + 1] - first; | |
| if (!length || right - left < length) return false; | |
| for (int start = left; start + length <= right; ++start) { | |
| if (start > left && token(text[start - 1])) continue; | |
| if (start + length < right && token(text[start + length])) continue; | |
| int i = 0; | |
| while (i < length && text[start + i] == term_bytes[first + i]) ++i; | |
| if (i == length) return true; | |
| } | |
| return false; | |
| } | |
| __device__ void context_bounds( | |
| const unsigned char* normalized, const unsigned int* offsets, int norm_length, | |
| int source_length, int start, int end, int width, int* left, int* right | |
| ) { | |
| int source_left = start > width ? start - width : 0; | |
| int source_right = width > source_length - end ? source_length : end + width; | |
| *left = lower_bound_offset(offsets, norm_length, source_left); | |
| *right = lower_bound_offset(offsets, norm_length, source_right); | |
| // Match Phase24's borrowed-window treatment of collapsed leading spaces. | |
| if (*left < *right && normalized[*left] == ' ') ++*left; | |
| } | |
| __device__ bool alias_context_ok( | |
| int context, const int* contexts, const int* clauses, const int* term_ids, | |
| const unsigned char* term_bytes, const int* term_offsets, | |
| const unsigned char* normalized, const unsigned int* offsets, int norm_length, | |
| int source_length, int start, int end | |
| ) { | |
| if (context < 0) return true; | |
| const int* spec = contexts + context * 5; | |
| int left, right; | |
| context_bounds(normalized, offsets, norm_length, source_length, | |
| start, end, spec[0], &left, &right); | |
| for (int i = 0; i < spec[4]; ++i) | |
| if (contains_term(normalized, left, right, term_ids[spec[3] + i], | |
| term_bytes, term_offsets)) return false; | |
| for (int i = 0; i < spec[2]; ++i) { | |
| const int* clause = clauses + 2 * (spec[1] + i); | |
| bool accepted = true; | |
| for (int j = 0; j < clause[1]; ++j) { | |
| if (!contains_term(normalized, left, right, term_ids[clause[0] + j], | |
| term_bytes, term_offsets)) { | |
| accepted = false; break; | |
| } | |
| } | |
| if (accepted) return true; | |
| } | |
| return false; | |
| } | |
| // Strict UTF-8 scalar decoder. Zero width rejects the entire row. | |
| __device__ __forceinline__ int phase32b_decode( | |
| const unsigned char* raw, int length, int position, unsigned int* scalar | |
| ) { | |
| unsigned int first = raw[position]; | |
| if (first < 0x80) { *scalar = first; return 1; } | |
| int width; | |
| unsigned int value, minimum; | |
| if (first >= 0xc2 && first <= 0xdf) { width = 2; value = first & 31; minimum = 0x80; } | |
| else if (first >= 0xe0 && first <= 0xef) { width = 3; value = first & 15; minimum = 0x800; } | |
| else if (first >= 0xf0 && first <= 0xf4) { width = 4; value = first & 7; minimum = 0x10000; } | |
| else return 0; | |
| if (width > length - position) return 0; | |
| for (int index = 1; index < width; ++index) { | |
| unsigned int next = raw[position + index]; | |
| if ((next & 0xc0) != 0x80) return 0; | |
| value = (value << 6) | (next & 63); | |
| } | |
| if (value < minimum || value > 0x10ffff || (value >= 0xd800 && value <= 0xdfff)) return 0; | |
| *scalar = value; | |
| return width; | |
| } | |
| // Frozen U13 mapping output is decoded into scalars before RANGE postprocessing. | |
| // Directly copying pool bytes would skip punctuation and whitespace semantics. | |
| __device__ bool phase32b_emit_scalar( | |
| unsigned int scalar, int source_index, const unsigned char* whitespace, | |
| unsigned char* normalized, unsigned int* offsets, int capacity, | |
| int* norm_length, bool* pending_space | |
| ) { | |
| switch (scalar) { | |
| case 0x2d: case 0x2010: case 0x2011: case 0x2012: case 0x2013: | |
| case 0x2014: case 0x2015: case 0x2212: | |
| case 0x2e: case 0x2c: case 0x3a: case 0x3b: case 0x28: case 0x29: | |
| case 0x5b: case 0x5d: case 0x7b: case 0x7d: case 0xff0f: case 0x2f: | |
| scalar = 32; break; | |
| case 0x27: case 0x2019: case 0x2018: case 0x201b: case 0x60: case 0xb4: | |
| scalar = 39; break; | |
| } | |
| bool is_space = scalar < 128 ? space((unsigned char)scalar) : | |
| ((whitespace[scalar >> 3] & (1u << (scalar & 7))) != 0); | |
| if (is_space) { | |
| *pending_space = *norm_length != 0; | |
| return true; | |
| } | |
| unsigned char encoded[4]; | |
| int width; | |
| if (scalar < 0x80) { | |
| width = 1; encoded[0] = (unsigned char)scalar; | |
| } else if (scalar < 0x800) { | |
| width = 2; encoded[0] = 0xc0 | (scalar >> 6); | |
| encoded[1] = 0x80 | (scalar & 63); | |
| } else if (scalar < 0x10000) { | |
| width = 3; encoded[0] = 0xe0 | (scalar >> 12); | |
| encoded[1] = 0x80 | ((scalar >> 6) & 63); | |
| encoded[2] = 0x80 | (scalar & 63); | |
| } else { | |
| width = 4; encoded[0] = 0xf0 | (scalar >> 18); | |
| encoded[1] = 0x80 | ((scalar >> 12) & 63); | |
| encoded[2] = 0x80 | ((scalar >> 6) & 63); | |
| encoded[3] = 0x80 | (scalar & 63); | |
| } | |
| // Check the complete scalar and optional separator before either is written. | |
| int required = width + (*pending_space ? 1 : 0); | |
| if (required > capacity - *norm_length) return false; | |
| if (*pending_space) { | |
| normalized[*norm_length] = ' '; | |
| offsets[(*norm_length)++] = source_index; | |
| *pending_space = false; | |
| } | |
| for (int unit = 0; unit < width; ++unit) { | |
| normalized[*norm_length] = encoded[unit]; | |
| offsets[(*norm_length)++] = source_index; | |
| } | |
| return true; | |
| } | |
| // Exceptional rows replay B's original ordered decoder/mapping/capacity logic. | |
| // Successful speculative tiles may already have written a prefix; replay starts | |
| // at zero and overwrites it. No speculative failing tile is ever published. | |
| __device__ unsigned char phase52_serial_normalize( | |
| const unsigned char* raw, int length, const unsigned int* unicode_index, | |
| const unsigned char* unicode_pool, const unsigned char* python_whitespace, | |
| unsigned char* normalized, unsigned int* offsets, int norm_capacity, | |
| int* output_length, int* output_source_length | |
| ) { | |
| int norm_length = 0, source_length = 0; | |
| bool pending_space = false; | |
| for (int i = 0; i < length;) { | |
| unsigned int scalar; | |
| int width = phase32b_decode(raw, length, i, &scalar); | |
| if (!width) { return 5; } | |
| // Original-text Python ignorecase semantics retain these four extras. | |
| // Keep the entire original row on CPU rather than approximate raw matching. | |
| if (scalar == 0x0130 || scalar == 0x0131 || scalar == 0x017f || scalar == 0x212a) { | |
| return 2; | |
| } | |
| if (scalar < 128) { | |
| if (!phase32b_emit_scalar(normalize((unsigned char)scalar), source_length, | |
| python_whitespace, normalized, offsets, norm_capacity, &norm_length, &pending_space)) { | |
| return 6; | |
| } | |
| } else { | |
| unsigned int mapping = unicode_index[scalar]; | |
| if (mapping == 0) { | |
| if (!phase32b_emit_scalar(scalar, source_length, python_whitespace, | |
| normalized, offsets, norm_capacity, &norm_length, &pending_space)) { | |
| return 6; | |
| } | |
| } else { | |
| // The host binds exact asset hashes. Retain device range/decoder | |
| // guards as a fail-closed corruption check, not a fallback route. | |
| if (mapping > PHASE32B_POOL_BYTES - 2u) { return 7; } | |
| int mapped_bytes = (int)unicode_pool[mapping] | ((int)unicode_pool[mapping + 1] << 8); | |
| if ((unsigned int)mapped_bytes > PHASE32B_POOL_BYTES - mapping - 2u) { | |
| return 7; | |
| } | |
| const unsigned char* mapped = unicode_pool + mapping + 2; | |
| for (int position = 0; position < mapped_bytes;) { | |
| unsigned int mapped_scalar; | |
| int mapped_width = phase32b_decode(mapped, mapped_bytes, position, &mapped_scalar); | |
| if (!mapped_width) { return 7; } | |
| if (!phase32b_emit_scalar(mapped_scalar, source_length, python_whitespace, | |
| normalized, offsets, norm_capacity, &norm_length, &pending_space)) { | |
| return 6; | |
| } | |
| position += mapped_width; | |
| } | |
| } | |
| } | |
| i += width; | |
| ++source_length; | |
| } | |
| *output_length = norm_length; | |
| *output_source_length = source_length; | |
| return 0; | |
| } | |
| // A lane owns one original scalar's post-mapping piece. Its scratch payload is | |
| // trimmed at both ends, with internal spaces collapsed. All its eventual bytes | |
| // have the same original source offset, including internal collapsed separators. | |
| // The two end flags preserve whitespace that trimming removes; they are needed | |
| // when this piece is composed with preceding/following original scalars. | |
| __device__ __forceinline__ bool phase52_piece_scalar( | |
| unsigned int scalar, const unsigned char* whitespace, unsigned char* piece, | |
| int* length, bool* pending, bool* seen_unit, bool* leading_space, bool* trailing_space | |
| ) { | |
| switch (scalar) { | |
| case 0x2d: case 0x2010: case 0x2011: case 0x2012: case 0x2013: | |
| case 0x2014: case 0x2015: case 0x2212: | |
| case 0x2e: case 0x2c: case 0x3a: case 0x3b: case 0x28: case 0x29: | |
| case 0x5b: case 0x5d: case 0x7b: case 0x7d: case 0xff0f: case 0x2f: | |
| scalar = 32; break; | |
| case 0x27: case 0x2019: case 0x2018: case 0x201b: case 0x60: case 0xb4: | |
| scalar = 39; break; | |
| } | |
| bool is_space = scalar < 128 ? space((unsigned char)scalar) : | |
| ((whitespace[scalar >> 3] & (1u << (scalar & 7))) != 0); | |
| if (!*seen_unit) { *seen_unit = true; *leading_space = is_space; } | |
| *trailing_space = is_space; | |
| if (is_space) { *pending = *length != 0; return true; } | |
| unsigned char encoded[4]; | |
| int width; | |
| if (scalar < 0x80) { | |
| width = 1; encoded[0] = (unsigned char)scalar; | |
| } else if (scalar < 0x800) { | |
| width = 2; encoded[0] = 0xc0 | (scalar >> 6); | |
| encoded[1] = 0x80 | (scalar & 63); | |
| } else if (scalar < 0x10000) { | |
| width = 3; encoded[0] = 0xe0 | (scalar >> 12); | |
| encoded[1] = 0x80 | ((scalar >> 6) & 63); | |
| encoded[2] = 0x80 | (scalar & 63); | |
| } else { | |
| width = 4; encoded[0] = 0xf0 | (scalar >> 18); | |
| encoded[1] = 0x80 | ((scalar >> 12) & 63); | |
| encoded[2] = 0x80 | ((scalar >> 6) & 63); | |
| encoded[3] = 0x80 | (scalar & 63); | |
| } | |
| if (width + (*pending ? 1 : 0) > PHASE52_MAX_PIECE_BYTES - *length) return false; | |
| if (*pending) { piece[(*length)++ * 32] = ' '; *pending = false; } | |
| for (int unit = 0; unit < width; ++unit) piece[(*length)++ * 32] = encoded[unit]; | |
| return true; | |
| } | |
| extern "C" __global__ void range52_normalize_warp( | |
| const unsigned char* data, const long long* row_offsets, int rows, int max_row_bytes, | |
| const unsigned int* unicode_index, const unsigned char* unicode_pool, | |
| const unsigned char* python_whitespace, unsigned char* normalized_data, | |
| unsigned int* source_offsets, int* normalized_lengths, int* source_lengths, | |
| unsigned char* codes, unsigned int* facts | |
| ) { | |
| // The host launch contract is exactly 128 threads: four independent warps. | |
| __shared__ unsigned char shared_payload[PHASE52_WARPS_PER_BLOCK * PHASE52_SCRATCH_BYTES * 32]; | |
| int lane = threadIdx.x & 31, local_warp = threadIdx.x >> 5; | |
| int row = blockIdx.x * PHASE52_WARPS_PER_BLOCK + local_warp; | |
| if (row >= rows) return; // Uniform for all lanes of this warp. | |
| unsigned char* piece = shared_payload + local_warp * PHASE52_SCRATCH_BYTES * 32 + lane; | |
| unsigned int* fact = facts + (long long)row * 8; | |
| if (lane < 8) fact[lane] = 0; | |
| if (lane == 0) { | |
| codes[row] = 0; | |
| normalized_lengths[row] = source_lengths[row] = 0; | |
| } | |
| long long base = row_offsets[row], raw_length = row_offsets[row + 1] - base; | |
| if (raw_length > max_row_bytes) { | |
| if (lane == 0) codes[row] = 4; | |
| return; | |
| } | |
| int length = (int)raw_length, norm_capacity = length * 2; | |
| const unsigned char* raw = data + base; | |
| unsigned char* normalized = normalized_data + base * 2; | |
| unsigned int* offsets = source_offsets + base * 2; | |
| int norm_length = 0, source_length = 0; | |
| bool pending_space = false; | |
| for (int tile = 0; tile < length; tile += 32) { | |
| int position = tile + lane, piece_length = 0; | |
| bool replay = false, valid_lead = false; | |
| bool local_pending = false, seen_unit = false, leading_space = false, trailing_space = false; | |
| if (position < length) { | |
| unsigned char first = raw[position]; | |
| if ((first & 0xc0) == 0x80) { | |
| // A continuation is an identity piece only when a strict valid | |
| // lead in the previous 1..3 bytes owns it. This also checks the | |
| // first lanes of a tile whose scalar began in the previous tile. | |
| bool covered = false; | |
| for (int back = 1; back <= 3 && back <= position; ++back) { | |
| if ((raw[position - back] & 0xc0) == 0x80) continue; | |
| unsigned int ignored; | |
| int width = phase32b_decode(raw, length, position - back, &ignored); | |
| if (width > back) { covered = true; break; } | |
| } | |
| if (!covered) replay = true; | |
| } else { | |
| unsigned int scalar; | |
| int width = phase32b_decode(raw, length, position, &scalar); | |
| if (!width) replay = true; | |
| else { | |
| valid_lead = true; | |
| if (scalar == 0x0130 || scalar == 0x0131 || scalar == 0x017f || scalar == 0x212a) | |
| replay = true; | |
| else if (scalar < 128) { | |
| replay = !phase52_piece_scalar(normalize((unsigned char)scalar), python_whitespace, | |
| piece, &piece_length, &local_pending, &seen_unit, &leading_space, &trailing_space); | |
| } else { | |
| unsigned int mapping = unicode_index[scalar]; | |
| if (!mapping) { | |
| replay = !phase52_piece_scalar(scalar, python_whitespace, piece, | |
| &piece_length, &local_pending, &seen_unit, &leading_space, &trailing_space); | |
| } else if (mapping > PHASE32B_POOL_BYTES - 2u) replay = true; | |
| else { | |
| int mapped_bytes = (int)unicode_pool[mapping] | ((int)unicode_pool[mapping + 1] << 8); | |
| if ((unsigned int)mapped_bytes > PHASE32B_POOL_BYTES - mapping - 2u || | |
| mapped_bytes > PHASE52_MAX_PIECE_BYTES) replay = true; | |
| else { | |
| const unsigned char* mapped = unicode_pool + mapping + 2; | |
| for (int at = 0; at < mapped_bytes && !replay;) { | |
| unsigned int mapped_scalar; | |
| int mapped_width = phase32b_decode(mapped, mapped_bytes, at, &mapped_scalar); | |
| if (!mapped_width) replay = true; | |
| else { | |
| replay = !phase52_piece_scalar(mapped_scalar, python_whitespace, piece, | |
| &piece_length, &local_pending, &seen_unit, &leading_space, &trailing_space); | |
| at += mapped_width; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // No thread leaves before a warp-wide decision. Continuation/inactive | |
| // lanes have empty identity summaries but still participate in every scan. | |
| bool replay_row = __any_sync(PHASE52_FULL_MASK, replay); | |
| unsigned int lower_lanes = lane == 0 ? 0u : (1u << lane) - 1u; | |
| unsigned int lead_mask = __ballot_sync(PHASE52_FULL_MASK, valid_lead); | |
| unsigned int text_mask = __ballot_sync(PHASE52_FULL_MASK, piece_length != 0); | |
| unsigned int effective_mask = __ballot_sync(PHASE52_FULL_MASK, seen_unit); | |
| unsigned int effective_before = effective_mask & lower_lanes; | |
| int previous_lane = effective_before ? 31 - __clz(effective_before) : 0; | |
| bool previous_trailing = __shfl_sync(PHASE52_FULL_MASK, (int)trailing_space, previous_lane) != 0; | |
| bool incoming_space = effective_before ? previous_trailing : pending_space; | |
| bool preceding_text = norm_length != 0 || (text_mask & lower_lanes) != 0; | |
| bool separator = piece_length != 0 && preceding_text && (incoming_space || leading_space); | |
| int emitted = piece_length + (separator ? 1 : 0); | |
| int inclusive = emitted; | |
| for (int distance = 1; distance < 32; distance <<= 1) { | |
| int prior = __shfl_up_sync(PHASE52_FULL_MASK, inclusive, distance); | |
| if (lane >= distance) inclusive += prior; | |
| } | |
| int tile_bytes = __shfl_sync(PHASE52_FULL_MASK, inclusive, 31); | |
| if (tile_bytes > norm_capacity - norm_length) replay_row = true; | |
| if (replay_row) { | |
| // Serial replay resolves all ordering ambiguities, including a | |
| // capacity error earlier than a raw4 or corrupt mapping in this tile. | |
| // Speculative scratch is private and this tile has not been stored. | |
| // Order every lane's earlier global stores before lane 0 overwrites | |
| // their prefix; votes/shuffles alone are not a memory barrier. | |
| __syncwarp(PHASE52_FULL_MASK); | |
| if (lane == 0) { | |
| int replay_length = 0, replay_source_length = 0; | |
| unsigned char code = phase52_serial_normalize(raw, length, unicode_index, | |
| unicode_pool, python_whitespace, normalized, offsets, norm_capacity, | |
| &replay_length, &replay_source_length); | |
| normalized_lengths[row] = replay_length; | |
| source_lengths[row] = replay_source_length; | |
| codes[row] = code; | |
| } | |
| __syncwarp(PHASE52_FULL_MASK); | |
| return; | |
| } | |
| int original_index = source_length + __popc(lead_mask & lower_lanes); | |
| int output = norm_length + inclusive - emitted; | |
| if (separator) { | |
| normalized[output] = ' '; | |
| offsets[output++] = original_index; | |
| } | |
| for (int unit = 0; unit < piece_length; ++unit) { | |
| normalized[output] = piece[unit * 32]; | |
| offsets[output++] = original_index; | |
| } | |
| norm_length += tile_bytes; | |
| source_length += __popc(lead_mask); | |
| int final_lane = effective_mask ? 31 - __clz(effective_mask) : 0; | |
| bool final_trailing = __shfl_sync(PHASE52_FULL_MASK, (int)trailing_space, final_lane) != 0; | |
| if (effective_mask) pending_space = norm_length != 0 && final_trailing; | |
| } | |
| if (lane == 0) { | |
| normalized_lengths[row] = norm_length; | |
| source_lengths[row] = source_length; | |
| } | |
| } | |
| extern "C" __global__ void range52_match_evaluate( | |
| const unsigned char* data, const long long* row_offsets, | |
| const long long* timestamps, int rows, int max_row_bytes, | |
| const unsigned int* transitions, const unsigned short* classes, | |
| const int* dfa_meta, const int* output_offsets, const int* output_keys, | |
| const int* key_lengths, const int* key_offsets, const int* key_consumers, | |
| const int* consumers, const long long* aliases, const int* lexical, | |
| const int* contexts, const int* clauses, const int* term_ids, | |
| const unsigned char* term_bytes, const int* term_offsets, | |
| const unsigned int* unicode_index, const unsigned char* unicode_pool, | |
| const unsigned char* python_whitespace, int conjunction_count, | |
| unsigned char* normalized_data, unsigned int* source_offsets, | |
| Candidate* all_candidates, unsigned char* codes, unsigned int* facts, | |
| const int* normalized_lengths, const int* source_lengths | |
| ) { | |
| int row = blockIdx.x * blockDim.x + threadIdx.x; | |
| if (row >= rows || codes[row] >= 2) return; | |
| unsigned int* fact = facts + (long long)row * 8; | |
| long long base = row_offsets[row]; | |
| int length = (int)(row_offsets[row + 1] - base); | |
| const unsigned char* raw = data + base; | |
| unsigned char* normalized = normalized_data + base * 2; | |
| unsigned int* offsets = source_offsets + base * 2; | |
| int norm_length = normalized_lengths[row], source_length = source_lengths[row]; | |
| Candidate* candidates = all_candidates + (long long)row * MAX_CANDIDATES; | |
| int count = 0; | |
| unsigned char conjunctions[MAX_CONJUNCTIONS] = {0}; | |
| bool native_candidate = false, exact_candidate = false; | |
| // Stream 0: normalized. Stream 1: raw case-sensitive. Stream 2: raw ASCII fold. | |
| for (int stream = 0; stream < 3; ++stream) { | |
| const int* meta = dfa_meta + stream * 4; | |
| if (meta[3] == 0) continue; | |
| const unsigned char* text = stream == 0 ? normalized : raw; | |
| int n = stream == 0 ? norm_length : length; | |
| unsigned int state = 0; | |
| int raw_source_position = -1; | |
| for (int pos = 0; pos < n; ++pos) { | |
| // Validated UTF-8; every lead/ASCII byte starts one original scalar. | |
| if (stream != 0 && (text[pos] & 0xc0) != 0x80) ++raw_source_position; | |
| unsigned char c = stream == 2 ? lower(text[pos]) : text[pos]; | |
| state = transitions[meta[0] + state * meta[1] + classes[stream * 256 + c]]; | |
| int first = output_offsets[meta[2] + state]; | |
| int last = output_offsets[meta[2] + state + 1]; | |
| for (int out = first; out < last; ++out) { | |
| int key = output_keys[out]; | |
| int start = pos + 1 - key_lengths[key], end = pos + 1; | |
| bool left_ok = start == 0 || !(stream == 0 ? token(text[start - 1]) : exact_token(text[start - 1])); | |
| bool right_ok = end == n || !(stream == 0 ? token(text[end]) : exact_token(text[end])); | |
| if (!left_ok || !right_ok) continue; | |
| if (stream == 0) native_candidate = true; | |
| else exact_candidate = true; | |
| // Raw keys remain ASCII: a hit spans key_lengths[key] scalars. | |
| // Compatibility mappings never enter either raw matching stream. | |
| int original_end = stream == 0 ? offsets[end - 1] + 1 : raw_source_position + 1; | |
| int original_start = stream == 0 ? offsets[start] : original_end - key_lengths[key]; | |
| if (!append_hit(key, original_start, original_end, key_offsets, | |
| key_consumers, consumers, candidates, &count, conjunctions)) { | |
| codes[row] = 3; return; | |
| } | |
| } | |
| } | |
| } | |
| bool accepted_nonsemantic = false, accepted_evidence = false; | |
| bool unresolved_exposure = false, unresolved_event = false; | |
| unsigned int supported = 0, observations = 0; | |
| for (int i = 0; i < count; ++i) { | |
| Candidate candidate = candidates[i]; | |
| if (candidate.kind == 0) { | |
| const long long* alias = aliases + candidate.index * 8; | |
| bool longest = true; | |
| for (int j = 0; j < count; ++j) { | |
| Candidate other = candidates[j]; | |
| if (other.kind == 0 && other.start == candidate.start && | |
| aliases[other.index * 8] == alias[0] && other.end > candidate.end) { | |
| longest = false; break; | |
| } | |
| } | |
| if (!longest) continue; | |
| ++observations; // Retained observations count before temporal/context checks. | |
| if (timestamps[row] < alias[1] || (alias[3] && timestamps[row] >= alias[2])) continue; | |
| if (!alias_context_ok((int)alias[7], contexts, clauses, term_ids, | |
| term_bytes, term_offsets, normalized, offsets, | |
| norm_length, source_length, candidate.start, candidate.end)) continue; | |
| accepted_nonsemantic = true; | |
| if (alias[4] != -1 && (alias[5] == 0 || alias[5] == 1)) { | |
| accepted_evidence = true; supported |= 1u << alias[4]; | |
| } else if (alias[6]) unresolved_exposure = true; | |
| } else { | |
| const int* rule = lexical + candidate.index * 7; | |
| ++observations; | |
| bool context_ok = rule[2] == 0; | |
| if (!context_ok) { | |
| int left, right; | |
| context_bounds(normalized, offsets, norm_length, source_length, | |
| candidate.start, candidate.end, rule[0], &left, &right); | |
| for (int j = 0; j < rule[2]; ++j) { | |
| if (contains_term(normalized, left, right, term_ids[rule[1] + j], | |
| term_bytes, term_offsets)) { context_ok = true; break; } | |
| } | |
| } | |
| if (rule[3]) { | |
| if (rule[4]) { accepted_evidence = true; supported |= 8; } | |
| else { if (rule[5]) unresolved_exposure = true; if (rule[6]) unresolved_event = true; } | |
| } else { | |
| if (context_ok) accepted_nonsemantic = true; | |
| if (rule[4] && context_ok) { accepted_evidence = true; supported |= 8; } | |
| else if (rule[5]) unresolved_exposure = true; | |
| } | |
| } | |
| } | |
| for (int i = 0; i < conjunction_count; ++i) { | |
| if (conjunctions[i] == 15) { ++observations; accepted_evidence = true; supported |= 8; } | |
| } | |
| if (!observations) return; | |
| fact[0] = accepted_evidence || accepted_nonsemantic || unresolved_event ? 0 : 2; | |
| for (int family = 0; family < 4; ++family) | |
| fact[family + 1] = supported & (1u << family) ? 0 : | |
| (family != 3 && !supported && unresolved_exposure ? 1 : 2); | |
| fact[5] = observations; fact[6] = native_candidate; fact[7] = exact_candidate; | |
| codes[row] = 1; | |
| } | |