648db22b |
1 | /* |
2 | * Copyright (c) Meta Platforms, Inc. and affiliates. |
3 | * All rights reserved. |
4 | * |
5 | * This source code is licensed under both the BSD-style license (found in the |
6 | * LICENSE file in the root directory of this source tree) and the GPLv2 (found |
7 | * in the COPYING file in the root directory of this source tree). |
8 | * You may select, at your option, one of the above-listed licenses. |
9 | */ |
10 | |
11 | #include "zstd_compress_internal.h" /* ZSTD_hashPtr, ZSTD_count, ZSTD_storeSeq */ |
12 | #include "zstd_fast.h" |
13 | |
f535537f |
14 | static |
15 | ZSTD_ALLOW_POINTER_OVERFLOW_ATTR |
16 | void ZSTD_fillHashTableForCDict(ZSTD_matchState_t* ms, |
648db22b |
17 | const void* const end, |
18 | ZSTD_dictTableLoadMethod_e dtlm) |
19 | { |
20 | const ZSTD_compressionParameters* const cParams = &ms->cParams; |
21 | U32* const hashTable = ms->hashTable; |
22 | U32 const hBits = cParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS; |
23 | U32 const mls = cParams->minMatch; |
24 | const BYTE* const base = ms->window.base; |
25 | const BYTE* ip = base + ms->nextToUpdate; |
26 | const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE; |
27 | const U32 fastHashFillStep = 3; |
28 | |
29 | /* Currently, we always use ZSTD_dtlm_full for filling CDict tables. |
30 | * Feel free to remove this assert if there's a good reason! */ |
31 | assert(dtlm == ZSTD_dtlm_full); |
32 | |
33 | /* Always insert every fastHashFillStep position into the hash table. |
34 | * Insert the other positions if their hash entry is empty. |
35 | */ |
36 | for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) { |
37 | U32 const curr = (U32)(ip - base); |
38 | { size_t const hashAndTag = ZSTD_hashPtr(ip, hBits, mls); |
39 | ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr); } |
40 | |
41 | if (dtlm == ZSTD_dtlm_fast) continue; |
42 | /* Only load extra positions for ZSTD_dtlm_full */ |
43 | { U32 p; |
44 | for (p = 1; p < fastHashFillStep; ++p) { |
45 | size_t const hashAndTag = ZSTD_hashPtr(ip + p, hBits, mls); |
46 | if (hashTable[hashAndTag >> ZSTD_SHORT_CACHE_TAG_BITS] == 0) { /* not yet filled */ |
47 | ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr + p); |
48 | } } } } |
49 | } |
50 | |
f535537f |
51 | static |
52 | ZSTD_ALLOW_POINTER_OVERFLOW_ATTR |
53 | void ZSTD_fillHashTableForCCtx(ZSTD_matchState_t* ms, |
648db22b |
54 | const void* const end, |
55 | ZSTD_dictTableLoadMethod_e dtlm) |
56 | { |
57 | const ZSTD_compressionParameters* const cParams = &ms->cParams; |
58 | U32* const hashTable = ms->hashTable; |
59 | U32 const hBits = cParams->hashLog; |
60 | U32 const mls = cParams->minMatch; |
61 | const BYTE* const base = ms->window.base; |
62 | const BYTE* ip = base + ms->nextToUpdate; |
63 | const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE; |
64 | const U32 fastHashFillStep = 3; |
65 | |
66 | /* Currently, we always use ZSTD_dtlm_fast for filling CCtx tables. |
67 | * Feel free to remove this assert if there's a good reason! */ |
68 | assert(dtlm == ZSTD_dtlm_fast); |
69 | |
70 | /* Always insert every fastHashFillStep position into the hash table. |
71 | * Insert the other positions if their hash entry is empty. |
72 | */ |
73 | for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) { |
74 | U32 const curr = (U32)(ip - base); |
75 | size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls); |
76 | hashTable[hash0] = curr; |
77 | if (dtlm == ZSTD_dtlm_fast) continue; |
78 | /* Only load extra positions for ZSTD_dtlm_full */ |
79 | { U32 p; |
80 | for (p = 1; p < fastHashFillStep; ++p) { |
81 | size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls); |
82 | if (hashTable[hash] == 0) { /* not yet filled */ |
83 | hashTable[hash] = curr + p; |
84 | } } } } |
85 | } |
86 | |
87 | void ZSTD_fillHashTable(ZSTD_matchState_t* ms, |
88 | const void* const end, |
89 | ZSTD_dictTableLoadMethod_e dtlm, |
90 | ZSTD_tableFillPurpose_e tfp) |
91 | { |
92 | if (tfp == ZSTD_tfp_forCDict) { |
93 | ZSTD_fillHashTableForCDict(ms, end, dtlm); |
94 | } else { |
95 | ZSTD_fillHashTableForCCtx(ms, end, dtlm); |
96 | } |
97 | } |
98 | |
99 | |
100 | /** |
101 | * If you squint hard enough (and ignore repcodes), the search operation at any |
102 | * given position is broken into 4 stages: |
103 | * |
104 | * 1. Hash (map position to hash value via input read) |
105 | * 2. Lookup (map hash val to index via hashtable read) |
106 | * 3. Load (map index to value at that position via input read) |
107 | * 4. Compare |
108 | * |
109 | * Each of these steps involves a memory read at an address which is computed |
110 | * from the previous step. This means these steps must be sequenced and their |
111 | * latencies are cumulative. |
112 | * |
113 | * Rather than do 1->2->3->4 sequentially for a single position before moving |
114 | * onto the next, this implementation interleaves these operations across the |
115 | * next few positions: |
116 | * |
117 | * R = Repcode Read & Compare |
118 | * H = Hash |
119 | * T = Table Lookup |
120 | * M = Match Read & Compare |
121 | * |
122 | * Pos | Time --> |
123 | * ----+------------------- |
124 | * N | ... M |
125 | * N+1 | ... TM |
126 | * N+2 | R H T M |
127 | * N+3 | H TM |
128 | * N+4 | R H T M |
129 | * N+5 | H ... |
130 | * N+6 | R ... |
131 | * |
132 | * This is very much analogous to the pipelining of execution in a CPU. And just |
133 | * like a CPU, we have to dump the pipeline when we find a match (i.e., take a |
134 | * branch). |
135 | * |
136 | * When this happens, we throw away our current state, and do the following prep |
137 | * to re-enter the loop: |
138 | * |
139 | * Pos | Time --> |
140 | * ----+------------------- |
141 | * N | H T |
142 | * N+1 | H |
143 | * |
144 | * This is also the work we do at the beginning to enter the loop initially. |
145 | */ |
f535537f |
146 | FORCE_INLINE_TEMPLATE |
147 | ZSTD_ALLOW_POINTER_OVERFLOW_ATTR |
148 | size_t ZSTD_compressBlock_fast_noDict_generic( |
648db22b |
149 | ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], |
150 | void const* src, size_t srcSize, |
151 | U32 const mls, U32 const hasStep) |
152 | { |
153 | const ZSTD_compressionParameters* const cParams = &ms->cParams; |
154 | U32* const hashTable = ms->hashTable; |
155 | U32 const hlog = cParams->hashLog; |
156 | /* support stepSize of 0 */ |
157 | size_t const stepSize = hasStep ? (cParams->targetLength + !(cParams->targetLength) + 1) : 2; |
158 | const BYTE* const base = ms->window.base; |
159 | const BYTE* const istart = (const BYTE*)src; |
160 | const U32 endIndex = (U32)((size_t)(istart - base) + srcSize); |
161 | const U32 prefixStartIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog); |
162 | const BYTE* const prefixStart = base + prefixStartIndex; |
163 | const BYTE* const iend = istart + srcSize; |
164 | const BYTE* const ilimit = iend - HASH_READ_SIZE; |
165 | |
166 | const BYTE* anchor = istart; |
167 | const BYTE* ip0 = istart; |
168 | const BYTE* ip1; |
169 | const BYTE* ip2; |
170 | const BYTE* ip3; |
171 | U32 current0; |
172 | |
173 | U32 rep_offset1 = rep[0]; |
174 | U32 rep_offset2 = rep[1]; |
175 | U32 offsetSaved1 = 0, offsetSaved2 = 0; |
176 | |
177 | size_t hash0; /* hash for ip0 */ |
178 | size_t hash1; /* hash for ip1 */ |
179 | U32 idx; /* match idx for ip0 */ |
180 | U32 mval; /* src value at match idx */ |
181 | |
182 | U32 offcode; |
183 | const BYTE* match0; |
184 | size_t mLength; |
185 | |
186 | /* ip0 and ip1 are always adjacent. The targetLength skipping and |
187 | * uncompressibility acceleration is applied to every other position, |
188 | * matching the behavior of #1562. step therefore represents the gap |
189 | * between pairs of positions, from ip0 to ip2 or ip1 to ip3. */ |
190 | size_t step; |
191 | const BYTE* nextStep; |
192 | const size_t kStepIncr = (1 << (kSearchStrength - 1)); |
193 | |
194 | DEBUGLOG(5, "ZSTD_compressBlock_fast_generic"); |
195 | ip0 += (ip0 == prefixStart); |
196 | { U32 const curr = (U32)(ip0 - base); |
197 | U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, cParams->windowLog); |
198 | U32 const maxRep = curr - windowLow; |
199 | if (rep_offset2 > maxRep) offsetSaved2 = rep_offset2, rep_offset2 = 0; |
200 | if (rep_offset1 > maxRep) offsetSaved1 = rep_offset1, rep_offset1 = 0; |
201 | } |
202 | |
203 | /* start each op */ |
204 | _start: /* Requires: ip0 */ |
205 | |
206 | step = stepSize; |
207 | nextStep = ip0 + kStepIncr; |
208 | |
209 | /* calculate positions, ip0 - anchor == 0, so we skip step calc */ |
210 | ip1 = ip0 + 1; |
211 | ip2 = ip0 + step; |
212 | ip3 = ip2 + 1; |
213 | |
214 | if (ip3 >= ilimit) { |
215 | goto _cleanup; |
216 | } |
217 | |
218 | hash0 = ZSTD_hashPtr(ip0, hlog, mls); |
219 | hash1 = ZSTD_hashPtr(ip1, hlog, mls); |
220 | |
221 | idx = hashTable[hash0]; |
222 | |
223 | do { |
224 | /* load repcode match for ip[2]*/ |
225 | const U32 rval = MEM_read32(ip2 - rep_offset1); |
226 | |
227 | /* write back hash table entry */ |
228 | current0 = (U32)(ip0 - base); |
229 | hashTable[hash0] = current0; |
230 | |
231 | /* check repcode at ip[2] */ |
232 | if ((MEM_read32(ip2) == rval) & (rep_offset1 > 0)) { |
233 | ip0 = ip2; |
234 | match0 = ip0 - rep_offset1; |
235 | mLength = ip0[-1] == match0[-1]; |
236 | ip0 -= mLength; |
237 | match0 -= mLength; |
238 | offcode = REPCODE1_TO_OFFBASE; |
239 | mLength += 4; |
240 | |
241 | /* First write next hash table entry; we've already calculated it. |
242 | * This write is known to be safe because the ip1 is before the |
243 | * repcode (ip2). */ |
244 | hashTable[hash1] = (U32)(ip1 - base); |
245 | |
246 | goto _match; |
247 | } |
248 | |
249 | /* load match for ip[0] */ |
250 | if (idx >= prefixStartIndex) { |
251 | mval = MEM_read32(base + idx); |
252 | } else { |
253 | mval = MEM_read32(ip0) ^ 1; /* guaranteed to not match. */ |
254 | } |
255 | |
256 | /* check match at ip[0] */ |
257 | if (MEM_read32(ip0) == mval) { |
258 | /* found a match! */ |
259 | |
260 | /* First write next hash table entry; we've already calculated it. |
261 | * This write is known to be safe because the ip1 == ip0 + 1, so |
262 | * we know we will resume searching after ip1 */ |
263 | hashTable[hash1] = (U32)(ip1 - base); |
264 | |
265 | goto _offset; |
266 | } |
267 | |
268 | /* lookup ip[1] */ |
269 | idx = hashTable[hash1]; |
270 | |
271 | /* hash ip[2] */ |
272 | hash0 = hash1; |
273 | hash1 = ZSTD_hashPtr(ip2, hlog, mls); |
274 | |
275 | /* advance to next positions */ |
276 | ip0 = ip1; |
277 | ip1 = ip2; |
278 | ip2 = ip3; |
279 | |
280 | /* write back hash table entry */ |
281 | current0 = (U32)(ip0 - base); |
282 | hashTable[hash0] = current0; |
283 | |
284 | /* load match for ip[0] */ |
285 | if (idx >= prefixStartIndex) { |
286 | mval = MEM_read32(base + idx); |
287 | } else { |
288 | mval = MEM_read32(ip0) ^ 1; /* guaranteed to not match. */ |
289 | } |
290 | |
291 | /* check match at ip[0] */ |
292 | if (MEM_read32(ip0) == mval) { |
293 | /* found a match! */ |
294 | |
295 | /* first write next hash table entry; we've already calculated it */ |
296 | if (step <= 4) { |
297 | /* We need to avoid writing an index into the hash table >= the |
298 | * position at which we will pick up our searching after we've |
299 | * taken this match. |
300 | * |
301 | * The minimum possible match has length 4, so the earliest ip0 |
302 | * can be after we take this match will be the current ip0 + 4. |
303 | * ip1 is ip0 + step - 1. If ip1 is >= ip0 + 4, we can't safely |
304 | * write this position. |
305 | */ |
306 | hashTable[hash1] = (U32)(ip1 - base); |
307 | } |
308 | |
309 | goto _offset; |
310 | } |
311 | |
312 | /* lookup ip[1] */ |
313 | idx = hashTable[hash1]; |
314 | |
315 | /* hash ip[2] */ |
316 | hash0 = hash1; |
317 | hash1 = ZSTD_hashPtr(ip2, hlog, mls); |
318 | |
319 | /* advance to next positions */ |
320 | ip0 = ip1; |
321 | ip1 = ip2; |
322 | ip2 = ip0 + step; |
323 | ip3 = ip1 + step; |
324 | |
325 | /* calculate step */ |
326 | if (ip2 >= nextStep) { |
327 | step++; |
328 | PREFETCH_L1(ip1 + 64); |
329 | PREFETCH_L1(ip1 + 128); |
330 | nextStep += kStepIncr; |
331 | } |
332 | } while (ip3 < ilimit); |
333 | |
334 | _cleanup: |
335 | /* Note that there are probably still a couple positions we could search. |
336 | * However, it seems to be a meaningful performance hit to try to search |
337 | * them. So let's not. */ |
338 | |
339 | /* When the repcodes are outside of the prefix, we set them to zero before the loop. |
340 | * When the offsets are still zero, we need to restore them after the block to have a correct |
341 | * repcode history. If only one offset was invalid, it is easy. The tricky case is when both |
342 | * offsets were invalid. We need to figure out which offset to refill with. |
343 | * - If both offsets are zero they are in the same order. |
344 | * - If both offsets are non-zero, we won't restore the offsets from `offsetSaved[12]`. |
345 | * - If only one is zero, we need to decide which offset to restore. |
346 | * - If rep_offset1 is non-zero, then rep_offset2 must be offsetSaved1. |
347 | * - It is impossible for rep_offset2 to be non-zero. |
348 | * |
349 | * So if rep_offset1 started invalid (offsetSaved1 != 0) and became valid (rep_offset1 != 0), then |
350 | * set rep[0] = rep_offset1 and rep[1] = offsetSaved1. |
351 | */ |
352 | offsetSaved2 = ((offsetSaved1 != 0) && (rep_offset1 != 0)) ? offsetSaved1 : offsetSaved2; |
353 | |
354 | /* save reps for next block */ |
355 | rep[0] = rep_offset1 ? rep_offset1 : offsetSaved1; |
356 | rep[1] = rep_offset2 ? rep_offset2 : offsetSaved2; |
357 | |
358 | /* Return the last literals size */ |
359 | return (size_t)(iend - anchor); |
360 | |
361 | _offset: /* Requires: ip0, idx */ |
362 | |
363 | /* Compute the offset code. */ |
364 | match0 = base + idx; |
365 | rep_offset2 = rep_offset1; |
366 | rep_offset1 = (U32)(ip0-match0); |
367 | offcode = OFFSET_TO_OFFBASE(rep_offset1); |
368 | mLength = 4; |
369 | |
370 | /* Count the backwards match length. */ |
371 | while (((ip0>anchor) & (match0>prefixStart)) && (ip0[-1] == match0[-1])) { |
372 | ip0--; |
373 | match0--; |
374 | mLength++; |
375 | } |
376 | |
377 | _match: /* Requires: ip0, match0, offcode */ |
378 | |
379 | /* Count the forward length. */ |
380 | mLength += ZSTD_count(ip0 + mLength, match0 + mLength, iend); |
381 | |
382 | ZSTD_storeSeq(seqStore, (size_t)(ip0 - anchor), anchor, iend, offcode, mLength); |
383 | |
384 | ip0 += mLength; |
385 | anchor = ip0; |
386 | |
387 | /* Fill table and check for immediate repcode. */ |
388 | if (ip0 <= ilimit) { |
389 | /* Fill Table */ |
390 | assert(base+current0+2 > istart); /* check base overflow */ |
391 | hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2; /* here because current+2 could be > iend-8 */ |
392 | hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base); |
393 | |
394 | if (rep_offset2 > 0) { /* rep_offset2==0 means rep_offset2 is invalidated */ |
395 | while ( (ip0 <= ilimit) && (MEM_read32(ip0) == MEM_read32(ip0 - rep_offset2)) ) { |
396 | /* store sequence */ |
397 | size_t const rLength = ZSTD_count(ip0+4, ip0+4-rep_offset2, iend) + 4; |
398 | { U32 const tmpOff = rep_offset2; rep_offset2 = rep_offset1; rep_offset1 = tmpOff; } /* swap rep_offset2 <=> rep_offset1 */ |
399 | hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base); |
400 | ip0 += rLength; |
401 | ZSTD_storeSeq(seqStore, 0 /*litLen*/, anchor, iend, REPCODE1_TO_OFFBASE, rLength); |
402 | anchor = ip0; |
403 | continue; /* faster when present (confirmed on gcc-8) ... (?) */ |
404 | } } } |
405 | |
406 | goto _start; |
407 | } |
408 | |
409 | #define ZSTD_GEN_FAST_FN(dictMode, mls, step) \ |
410 | static size_t ZSTD_compressBlock_fast_##dictMode##_##mls##_##step( \ |
411 | ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], \ |
412 | void const* src, size_t srcSize) \ |
413 | { \ |
414 | return ZSTD_compressBlock_fast_##dictMode##_generic(ms, seqStore, rep, src, srcSize, mls, step); \ |
415 | } |
416 | |
417 | ZSTD_GEN_FAST_FN(noDict, 4, 1) |
418 | ZSTD_GEN_FAST_FN(noDict, 5, 1) |
419 | ZSTD_GEN_FAST_FN(noDict, 6, 1) |
420 | ZSTD_GEN_FAST_FN(noDict, 7, 1) |
421 | |
422 | ZSTD_GEN_FAST_FN(noDict, 4, 0) |
423 | ZSTD_GEN_FAST_FN(noDict, 5, 0) |
424 | ZSTD_GEN_FAST_FN(noDict, 6, 0) |
425 | ZSTD_GEN_FAST_FN(noDict, 7, 0) |
426 | |
427 | size_t ZSTD_compressBlock_fast( |
428 | ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], |
429 | void const* src, size_t srcSize) |
430 | { |
431 | U32 const mls = ms->cParams.minMatch; |
432 | assert(ms->dictMatchState == NULL); |
433 | if (ms->cParams.targetLength > 1) { |
434 | switch(mls) |
435 | { |
436 | default: /* includes case 3 */ |
437 | case 4 : |
438 | return ZSTD_compressBlock_fast_noDict_4_1(ms, seqStore, rep, src, srcSize); |
439 | case 5 : |
440 | return ZSTD_compressBlock_fast_noDict_5_1(ms, seqStore, rep, src, srcSize); |
441 | case 6 : |
442 | return ZSTD_compressBlock_fast_noDict_6_1(ms, seqStore, rep, src, srcSize); |
443 | case 7 : |
444 | return ZSTD_compressBlock_fast_noDict_7_1(ms, seqStore, rep, src, srcSize); |
445 | } |
446 | } else { |
447 | switch(mls) |
448 | { |
449 | default: /* includes case 3 */ |
450 | case 4 : |
451 | return ZSTD_compressBlock_fast_noDict_4_0(ms, seqStore, rep, src, srcSize); |
452 | case 5 : |
453 | return ZSTD_compressBlock_fast_noDict_5_0(ms, seqStore, rep, src, srcSize); |
454 | case 6 : |
455 | return ZSTD_compressBlock_fast_noDict_6_0(ms, seqStore, rep, src, srcSize); |
456 | case 7 : |
457 | return ZSTD_compressBlock_fast_noDict_7_0(ms, seqStore, rep, src, srcSize); |
458 | } |
459 | |
460 | } |
461 | } |
462 | |
463 | FORCE_INLINE_TEMPLATE |
f535537f |
464 | ZSTD_ALLOW_POINTER_OVERFLOW_ATTR |
648db22b |
465 | size_t ZSTD_compressBlock_fast_dictMatchState_generic( |
466 | ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], |
467 | void const* src, size_t srcSize, U32 const mls, U32 const hasStep) |
468 | { |
469 | const ZSTD_compressionParameters* const cParams = &ms->cParams; |
470 | U32* const hashTable = ms->hashTable; |
471 | U32 const hlog = cParams->hashLog; |
472 | /* support stepSize of 0 */ |
473 | U32 const stepSize = cParams->targetLength + !(cParams->targetLength); |
474 | const BYTE* const base = ms->window.base; |
475 | const BYTE* const istart = (const BYTE*)src; |
476 | const BYTE* ip0 = istart; |
477 | const BYTE* ip1 = ip0 + stepSize; /* we assert below that stepSize >= 1 */ |
478 | const BYTE* anchor = istart; |
479 | const U32 prefixStartIndex = ms->window.dictLimit; |
480 | const BYTE* const prefixStart = base + prefixStartIndex; |
481 | const BYTE* const iend = istart + srcSize; |
482 | const BYTE* const ilimit = iend - HASH_READ_SIZE; |
483 | U32 offset_1=rep[0], offset_2=rep[1]; |
484 | |
485 | const ZSTD_matchState_t* const dms = ms->dictMatchState; |
486 | const ZSTD_compressionParameters* const dictCParams = &dms->cParams ; |
487 | const U32* const dictHashTable = dms->hashTable; |
488 | const U32 dictStartIndex = dms->window.dictLimit; |
489 | const BYTE* const dictBase = dms->window.base; |
490 | const BYTE* const dictStart = dictBase + dictStartIndex; |
491 | const BYTE* const dictEnd = dms->window.nextSrc; |
492 | const U32 dictIndexDelta = prefixStartIndex - (U32)(dictEnd - dictBase); |
493 | const U32 dictAndPrefixLength = (U32)(istart - prefixStart + dictEnd - dictStart); |
494 | const U32 dictHBits = dictCParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS; |
495 | |
496 | /* if a dictionary is still attached, it necessarily means that |
497 | * it is within window size. So we just check it. */ |
498 | const U32 maxDistance = 1U << cParams->windowLog; |
499 | const U32 endIndex = (U32)((size_t)(istart - base) + srcSize); |
500 | assert(endIndex - prefixStartIndex <= maxDistance); |
501 | (void)maxDistance; (void)endIndex; /* these variables are not used when assert() is disabled */ |
502 | |
503 | (void)hasStep; /* not currently specialized on whether it's accelerated */ |
504 | |
505 | /* ensure there will be no underflow |
506 | * when translating a dict index into a local index */ |
507 | assert(prefixStartIndex >= (U32)(dictEnd - dictBase)); |
508 | |
509 | if (ms->prefetchCDictTables) { |
510 | size_t const hashTableBytes = (((size_t)1) << dictCParams->hashLog) * sizeof(U32); |
f535537f |
511 | PREFETCH_AREA(dictHashTable, hashTableBytes); |
648db22b |
512 | } |
513 | |
514 | /* init */ |
515 | DEBUGLOG(5, "ZSTD_compressBlock_fast_dictMatchState_generic"); |
516 | ip0 += (dictAndPrefixLength == 0); |
517 | /* dictMatchState repCode checks don't currently handle repCode == 0 |
518 | * disabling. */ |
519 | assert(offset_1 <= dictAndPrefixLength); |
520 | assert(offset_2 <= dictAndPrefixLength); |
521 | |
522 | /* Outer search loop */ |
523 | assert(stepSize >= 1); |
524 | while (ip1 <= ilimit) { /* repcode check at (ip0 + 1) is safe because ip0 < ip1 */ |
525 | size_t mLength; |
526 | size_t hash0 = ZSTD_hashPtr(ip0, hlog, mls); |
527 | |
528 | size_t const dictHashAndTag0 = ZSTD_hashPtr(ip0, dictHBits, mls); |
529 | U32 dictMatchIndexAndTag = dictHashTable[dictHashAndTag0 >> ZSTD_SHORT_CACHE_TAG_BITS]; |
530 | int dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag0); |
531 | |
532 | U32 matchIndex = hashTable[hash0]; |
533 | U32 curr = (U32)(ip0 - base); |
534 | size_t step = stepSize; |
535 | const size_t kStepIncr = 1 << kSearchStrength; |
536 | const BYTE* nextStep = ip0 + kStepIncr; |
537 | |
538 | /* Inner search loop */ |
539 | while (1) { |
540 | const BYTE* match = base + matchIndex; |
541 | const U32 repIndex = curr + 1 - offset_1; |
542 | const BYTE* repMatch = (repIndex < prefixStartIndex) ? |
543 | dictBase + (repIndex - dictIndexDelta) : |
544 | base + repIndex; |
545 | const size_t hash1 = ZSTD_hashPtr(ip1, hlog, mls); |
546 | size_t const dictHashAndTag1 = ZSTD_hashPtr(ip1, dictHBits, mls); |
547 | hashTable[hash0] = curr; /* update hash table */ |
548 | |
549 | if (((U32) ((prefixStartIndex - 1) - repIndex) >= |
550 | 3) /* intentional underflow : ensure repIndex isn't overlapping dict + prefix */ |
551 | && (MEM_read32(repMatch) == MEM_read32(ip0 + 1))) { |
552 | const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend; |
553 | mLength = ZSTD_count_2segments(ip0 + 1 + 4, repMatch + 4, iend, repMatchEnd, prefixStart) + 4; |
554 | ip0++; |
555 | ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength); |
556 | break; |
557 | } |
558 | |
559 | if (dictTagsMatch) { |
560 | /* Found a possible dict match */ |
561 | const U32 dictMatchIndex = dictMatchIndexAndTag >> ZSTD_SHORT_CACHE_TAG_BITS; |
562 | const BYTE* dictMatch = dictBase + dictMatchIndex; |
563 | if (dictMatchIndex > dictStartIndex && |
564 | MEM_read32(dictMatch) == MEM_read32(ip0)) { |
565 | /* To replicate extDict parse behavior, we only use dict matches when the normal matchIndex is invalid */ |
566 | if (matchIndex <= prefixStartIndex) { |
567 | U32 const offset = (U32) (curr - dictMatchIndex - dictIndexDelta); |
568 | mLength = ZSTD_count_2segments(ip0 + 4, dictMatch + 4, iend, dictEnd, prefixStart) + 4; |
569 | while (((ip0 > anchor) & (dictMatch > dictStart)) |
570 | && (ip0[-1] == dictMatch[-1])) { |
571 | ip0--; |
572 | dictMatch--; |
573 | mLength++; |
574 | } /* catch up */ |
575 | offset_2 = offset_1; |
576 | offset_1 = offset; |
577 | ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength); |
578 | break; |
579 | } |
580 | } |
581 | } |
582 | |
583 | if (matchIndex > prefixStartIndex && MEM_read32(match) == MEM_read32(ip0)) { |
584 | /* found a regular match */ |
585 | U32 const offset = (U32) (ip0 - match); |
586 | mLength = ZSTD_count(ip0 + 4, match + 4, iend) + 4; |
587 | while (((ip0 > anchor) & (match > prefixStart)) |
588 | && (ip0[-1] == match[-1])) { |
589 | ip0--; |
590 | match--; |
591 | mLength++; |
592 | } /* catch up */ |
593 | offset_2 = offset_1; |
594 | offset_1 = offset; |
595 | ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength); |
596 | break; |
597 | } |
598 | |
599 | /* Prepare for next iteration */ |
600 | dictMatchIndexAndTag = dictHashTable[dictHashAndTag1 >> ZSTD_SHORT_CACHE_TAG_BITS]; |
601 | dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag1); |
602 | matchIndex = hashTable[hash1]; |
603 | |
604 | if (ip1 >= nextStep) { |
605 | step++; |
606 | nextStep += kStepIncr; |
607 | } |
608 | ip0 = ip1; |
609 | ip1 = ip1 + step; |
610 | if (ip1 > ilimit) goto _cleanup; |
611 | |
612 | curr = (U32)(ip0 - base); |
613 | hash0 = hash1; |
614 | } /* end inner search loop */ |
615 | |
616 | /* match found */ |
617 | assert(mLength); |
618 | ip0 += mLength; |
619 | anchor = ip0; |
620 | |
621 | if (ip0 <= ilimit) { |
622 | /* Fill Table */ |
623 | assert(base+curr+2 > istart); /* check base overflow */ |
624 | hashTable[ZSTD_hashPtr(base+curr+2, hlog, mls)] = curr+2; /* here because curr+2 could be > iend-8 */ |
625 | hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base); |
626 | |
627 | /* check immediate repcode */ |
628 | while (ip0 <= ilimit) { |
629 | U32 const current2 = (U32)(ip0-base); |
630 | U32 const repIndex2 = current2 - offset_2; |
631 | const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? |
632 | dictBase - dictIndexDelta + repIndex2 : |
633 | base + repIndex2; |
634 | if ( ((U32)((prefixStartIndex-1) - (U32)repIndex2) >= 3 /* intentional overflow */) |
635 | && (MEM_read32(repMatch2) == MEM_read32(ip0))) { |
636 | const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend; |
637 | size_t const repLength2 = ZSTD_count_2segments(ip0+4, repMatch2+4, iend, repEnd2, prefixStart) + 4; |
638 | U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; /* swap offset_2 <=> offset_1 */ |
639 | ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, repLength2); |
640 | hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = current2; |
641 | ip0 += repLength2; |
642 | anchor = ip0; |
643 | continue; |
644 | } |
645 | break; |
646 | } |
647 | } |
648 | |
649 | /* Prepare for next iteration */ |
650 | assert(ip0 == anchor); |
651 | ip1 = ip0 + stepSize; |
652 | } |
653 | |
654 | _cleanup: |
655 | /* save reps for next block */ |
656 | rep[0] = offset_1; |
657 | rep[1] = offset_2; |
658 | |
659 | /* Return the last literals size */ |
660 | return (size_t)(iend - anchor); |
661 | } |
662 | |
663 | |
664 | ZSTD_GEN_FAST_FN(dictMatchState, 4, 0) |
665 | ZSTD_GEN_FAST_FN(dictMatchState, 5, 0) |
666 | ZSTD_GEN_FAST_FN(dictMatchState, 6, 0) |
667 | ZSTD_GEN_FAST_FN(dictMatchState, 7, 0) |
668 | |
669 | size_t ZSTD_compressBlock_fast_dictMatchState( |
670 | ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], |
671 | void const* src, size_t srcSize) |
672 | { |
673 | U32 const mls = ms->cParams.minMatch; |
674 | assert(ms->dictMatchState != NULL); |
675 | switch(mls) |
676 | { |
677 | default: /* includes case 3 */ |
678 | case 4 : |
679 | return ZSTD_compressBlock_fast_dictMatchState_4_0(ms, seqStore, rep, src, srcSize); |
680 | case 5 : |
681 | return ZSTD_compressBlock_fast_dictMatchState_5_0(ms, seqStore, rep, src, srcSize); |
682 | case 6 : |
683 | return ZSTD_compressBlock_fast_dictMatchState_6_0(ms, seqStore, rep, src, srcSize); |
684 | case 7 : |
685 | return ZSTD_compressBlock_fast_dictMatchState_7_0(ms, seqStore, rep, src, srcSize); |
686 | } |
687 | } |
688 | |
689 | |
f535537f |
690 | static |
691 | ZSTD_ALLOW_POINTER_OVERFLOW_ATTR |
692 | size_t ZSTD_compressBlock_fast_extDict_generic( |
648db22b |
693 | ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], |
694 | void const* src, size_t srcSize, U32 const mls, U32 const hasStep) |
695 | { |
696 | const ZSTD_compressionParameters* const cParams = &ms->cParams; |
697 | U32* const hashTable = ms->hashTable; |
698 | U32 const hlog = cParams->hashLog; |
699 | /* support stepSize of 0 */ |
700 | size_t const stepSize = cParams->targetLength + !(cParams->targetLength) + 1; |
701 | const BYTE* const base = ms->window.base; |
702 | const BYTE* const dictBase = ms->window.dictBase; |
703 | const BYTE* const istart = (const BYTE*)src; |
704 | const BYTE* anchor = istart; |
705 | const U32 endIndex = (U32)((size_t)(istart - base) + srcSize); |
706 | const U32 lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog); |
707 | const U32 dictStartIndex = lowLimit; |
708 | const BYTE* const dictStart = dictBase + dictStartIndex; |
709 | const U32 dictLimit = ms->window.dictLimit; |
710 | const U32 prefixStartIndex = dictLimit < lowLimit ? lowLimit : dictLimit; |
711 | const BYTE* const prefixStart = base + prefixStartIndex; |
712 | const BYTE* const dictEnd = dictBase + prefixStartIndex; |
713 | const BYTE* const iend = istart + srcSize; |
714 | const BYTE* const ilimit = iend - 8; |
715 | U32 offset_1=rep[0], offset_2=rep[1]; |
716 | U32 offsetSaved1 = 0, offsetSaved2 = 0; |
717 | |
718 | const BYTE* ip0 = istart; |
719 | const BYTE* ip1; |
720 | const BYTE* ip2; |
721 | const BYTE* ip3; |
722 | U32 current0; |
723 | |
724 | |
725 | size_t hash0; /* hash for ip0 */ |
726 | size_t hash1; /* hash for ip1 */ |
727 | U32 idx; /* match idx for ip0 */ |
728 | const BYTE* idxBase; /* base pointer for idx */ |
729 | |
730 | U32 offcode; |
731 | const BYTE* match0; |
732 | size_t mLength; |
733 | const BYTE* matchEnd = 0; /* initialize to avoid warning, assert != 0 later */ |
734 | |
735 | size_t step; |
736 | const BYTE* nextStep; |
737 | const size_t kStepIncr = (1 << (kSearchStrength - 1)); |
738 | |
739 | (void)hasStep; /* not currently specialized on whether it's accelerated */ |
740 | |
741 | DEBUGLOG(5, "ZSTD_compressBlock_fast_extDict_generic (offset_1=%u)", offset_1); |
742 | |
743 | /* switch to "regular" variant if extDict is invalidated due to maxDistance */ |
744 | if (prefixStartIndex == dictStartIndex) |
745 | return ZSTD_compressBlock_fast(ms, seqStore, rep, src, srcSize); |
746 | |
747 | { U32 const curr = (U32)(ip0 - base); |
748 | U32 const maxRep = curr - dictStartIndex; |
749 | if (offset_2 >= maxRep) offsetSaved2 = offset_2, offset_2 = 0; |
750 | if (offset_1 >= maxRep) offsetSaved1 = offset_1, offset_1 = 0; |
751 | } |
752 | |
753 | /* start each op */ |
754 | _start: /* Requires: ip0 */ |
755 | |
756 | step = stepSize; |
757 | nextStep = ip0 + kStepIncr; |
758 | |
759 | /* calculate positions, ip0 - anchor == 0, so we skip step calc */ |
760 | ip1 = ip0 + 1; |
761 | ip2 = ip0 + step; |
762 | ip3 = ip2 + 1; |
763 | |
764 | if (ip3 >= ilimit) { |
765 | goto _cleanup; |
766 | } |
767 | |
768 | hash0 = ZSTD_hashPtr(ip0, hlog, mls); |
769 | hash1 = ZSTD_hashPtr(ip1, hlog, mls); |
770 | |
771 | idx = hashTable[hash0]; |
772 | idxBase = idx < prefixStartIndex ? dictBase : base; |
773 | |
774 | do { |
775 | { /* load repcode match for ip[2] */ |
776 | U32 const current2 = (U32)(ip2 - base); |
777 | U32 const repIndex = current2 - offset_1; |
778 | const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base; |
779 | U32 rval; |
780 | if ( ((U32)(prefixStartIndex - repIndex) >= 4) /* intentional underflow */ |
781 | & (offset_1 > 0) ) { |
782 | rval = MEM_read32(repBase + repIndex); |
783 | } else { |
784 | rval = MEM_read32(ip2) ^ 1; /* guaranteed to not match. */ |
785 | } |
786 | |
787 | /* write back hash table entry */ |
788 | current0 = (U32)(ip0 - base); |
789 | hashTable[hash0] = current0; |
790 | |
791 | /* check repcode at ip[2] */ |
792 | if (MEM_read32(ip2) == rval) { |
793 | ip0 = ip2; |
794 | match0 = repBase + repIndex; |
795 | matchEnd = repIndex < prefixStartIndex ? dictEnd : iend; |
796 | assert((match0 != prefixStart) & (match0 != dictStart)); |
797 | mLength = ip0[-1] == match0[-1]; |
798 | ip0 -= mLength; |
799 | match0 -= mLength; |
800 | offcode = REPCODE1_TO_OFFBASE; |
801 | mLength += 4; |
802 | goto _match; |
803 | } } |
804 | |
805 | { /* load match for ip[0] */ |
806 | U32 const mval = idx >= dictStartIndex ? |
807 | MEM_read32(idxBase + idx) : |
808 | MEM_read32(ip0) ^ 1; /* guaranteed not to match */ |
809 | |
810 | /* check match at ip[0] */ |
811 | if (MEM_read32(ip0) == mval) { |
812 | /* found a match! */ |
813 | goto _offset; |
814 | } } |
815 | |
816 | /* lookup ip[1] */ |
817 | idx = hashTable[hash1]; |
818 | idxBase = idx < prefixStartIndex ? dictBase : base; |
819 | |
820 | /* hash ip[2] */ |
821 | hash0 = hash1; |
822 | hash1 = ZSTD_hashPtr(ip2, hlog, mls); |
823 | |
824 | /* advance to next positions */ |
825 | ip0 = ip1; |
826 | ip1 = ip2; |
827 | ip2 = ip3; |
828 | |
829 | /* write back hash table entry */ |
830 | current0 = (U32)(ip0 - base); |
831 | hashTable[hash0] = current0; |
832 | |
833 | { /* load match for ip[0] */ |
834 | U32 const mval = idx >= dictStartIndex ? |
835 | MEM_read32(idxBase + idx) : |
836 | MEM_read32(ip0) ^ 1; /* guaranteed not to match */ |
837 | |
838 | /* check match at ip[0] */ |
839 | if (MEM_read32(ip0) == mval) { |
840 | /* found a match! */ |
841 | goto _offset; |
842 | } } |
843 | |
844 | /* lookup ip[1] */ |
845 | idx = hashTable[hash1]; |
846 | idxBase = idx < prefixStartIndex ? dictBase : base; |
847 | |
848 | /* hash ip[2] */ |
849 | hash0 = hash1; |
850 | hash1 = ZSTD_hashPtr(ip2, hlog, mls); |
851 | |
852 | /* advance to next positions */ |
853 | ip0 = ip1; |
854 | ip1 = ip2; |
855 | ip2 = ip0 + step; |
856 | ip3 = ip1 + step; |
857 | |
858 | /* calculate step */ |
859 | if (ip2 >= nextStep) { |
860 | step++; |
861 | PREFETCH_L1(ip1 + 64); |
862 | PREFETCH_L1(ip1 + 128); |
863 | nextStep += kStepIncr; |
864 | } |
865 | } while (ip3 < ilimit); |
866 | |
867 | _cleanup: |
868 | /* Note that there are probably still a couple positions we could search. |
869 | * However, it seems to be a meaningful performance hit to try to search |
870 | * them. So let's not. */ |
871 | |
872 | /* If offset_1 started invalid (offsetSaved1 != 0) and became valid (offset_1 != 0), |
873 | * rotate saved offsets. See comment in ZSTD_compressBlock_fast_noDict for more context. */ |
874 | offsetSaved2 = ((offsetSaved1 != 0) && (offset_1 != 0)) ? offsetSaved1 : offsetSaved2; |
875 | |
876 | /* save reps for next block */ |
877 | rep[0] = offset_1 ? offset_1 : offsetSaved1; |
878 | rep[1] = offset_2 ? offset_2 : offsetSaved2; |
879 | |
880 | /* Return the last literals size */ |
881 | return (size_t)(iend - anchor); |
882 | |
883 | _offset: /* Requires: ip0, idx, idxBase */ |
884 | |
885 | /* Compute the offset code. */ |
886 | { U32 const offset = current0 - idx; |
887 | const BYTE* const lowMatchPtr = idx < prefixStartIndex ? dictStart : prefixStart; |
888 | matchEnd = idx < prefixStartIndex ? dictEnd : iend; |
889 | match0 = idxBase + idx; |
890 | offset_2 = offset_1; |
891 | offset_1 = offset; |
892 | offcode = OFFSET_TO_OFFBASE(offset); |
893 | mLength = 4; |
894 | |
895 | /* Count the backwards match length. */ |
896 | while (((ip0>anchor) & (match0>lowMatchPtr)) && (ip0[-1] == match0[-1])) { |
897 | ip0--; |
898 | match0--; |
899 | mLength++; |
900 | } } |
901 | |
902 | _match: /* Requires: ip0, match0, offcode, matchEnd */ |
903 | |
904 | /* Count the forward length. */ |
905 | assert(matchEnd != 0); |
906 | mLength += ZSTD_count_2segments(ip0 + mLength, match0 + mLength, iend, matchEnd, prefixStart); |
907 | |
908 | ZSTD_storeSeq(seqStore, (size_t)(ip0 - anchor), anchor, iend, offcode, mLength); |
909 | |
910 | ip0 += mLength; |
911 | anchor = ip0; |
912 | |
913 | /* write next hash table entry */ |
914 | if (ip1 < ip0) { |
915 | hashTable[hash1] = (U32)(ip1 - base); |
916 | } |
917 | |
918 | /* Fill table and check for immediate repcode. */ |
919 | if (ip0 <= ilimit) { |
920 | /* Fill Table */ |
921 | assert(base+current0+2 > istart); /* check base overflow */ |
922 | hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2; /* here because current+2 could be > iend-8 */ |
923 | hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base); |
924 | |
925 | while (ip0 <= ilimit) { |
926 | U32 const repIndex2 = (U32)(ip0-base) - offset_2; |
927 | const BYTE* const repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2; |
928 | if ( (((U32)((prefixStartIndex-1) - repIndex2) >= 3) & (offset_2 > 0)) /* intentional underflow */ |
929 | && (MEM_read32(repMatch2) == MEM_read32(ip0)) ) { |
930 | const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend; |
931 | size_t const repLength2 = ZSTD_count_2segments(ip0+4, repMatch2+4, iend, repEnd2, prefixStart) + 4; |
932 | { U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; } /* swap offset_2 <=> offset_1 */ |
933 | ZSTD_storeSeq(seqStore, 0 /*litlen*/, anchor, iend, REPCODE1_TO_OFFBASE, repLength2); |
934 | hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base); |
935 | ip0 += repLength2; |
936 | anchor = ip0; |
937 | continue; |
938 | } |
939 | break; |
940 | } } |
941 | |
942 | goto _start; |
943 | } |
944 | |
945 | ZSTD_GEN_FAST_FN(extDict, 4, 0) |
946 | ZSTD_GEN_FAST_FN(extDict, 5, 0) |
947 | ZSTD_GEN_FAST_FN(extDict, 6, 0) |
948 | ZSTD_GEN_FAST_FN(extDict, 7, 0) |
949 | |
950 | size_t ZSTD_compressBlock_fast_extDict( |
951 | ZSTD_matchState_t* ms, seqStore_t* seqStore, U32 rep[ZSTD_REP_NUM], |
952 | void const* src, size_t srcSize) |
953 | { |
954 | U32 const mls = ms->cParams.minMatch; |
955 | assert(ms->dictMatchState == NULL); |
956 | switch(mls) |
957 | { |
958 | default: /* includes case 3 */ |
959 | case 4 : |
960 | return ZSTD_compressBlock_fast_extDict_4_0(ms, seqStore, rep, src, srcSize); |
961 | case 5 : |
962 | return ZSTD_compressBlock_fast_extDict_5_0(ms, seqStore, rep, src, srcSize); |
963 | case 6 : |
964 | return ZSTD_compressBlock_fast_extDict_6_0(ms, seqStore, rep, src, srcSize); |
965 | case 7 : |
966 | return ZSTD_compressBlock_fast_extDict_7_0(ms, seqStore, rep, src, srcSize); |
967 | } |
968 | } |