May be this will accelerate LZ4 decompression?

[lz77]

See LZ4_decompress_generic We can exclude operators

length = token >> 4;
length = token & 15;

when llll < 15 and mmmm < 15. We need to separate the seldom cases when llll == 15 or mmmm == 15. This is a schema in asm:

xor ecx,ecx
xor ebx,ebx
mov cl,[esi]         ; cl = token (llllmmmm)
mov bx,[esi+1]
neg ebx              ; ebx = -offset
add esi,3
shl ecx,4            ; cl = mmmm*16, ch = llll

cmp ch,$0F
je .too_many_literals

===

; Copying literals, ch == count of literals  ...

===

cmp cl,$F0
je .too_big_matchlen

; To copy by 4 bytes offset must be greater than 3
cmp ebx,-4
jg .1

; Copying matched bytes, cl == (count-4)*16 of matched bytes

mov eax,[esi+ebx]
mov [edi],eax                  ; copying 4 bytes
add esi,4 add edi,4

.while cl >= 4*16
mov eax,[esi+ebx]
mov [edi],eax                 ; copying by 4 bytes
add esi,4
add edi,4
sub cl,4*16                  ; sub cl, works also fast as dec cl
.endwhile

jmp .2
.1:
add cl,4*16

.2:
.while cl
mov al,[esi+ebx]
mov [edi],al                 ; copying by 1 byte
inc esi
inc edi
sub cl,16
.endwhile

What do you think about it?

[Cyan]

This is an interesting idea.
Do you believe you can benchmark it ?

[lz77]

I can benchmark it, but in future. At this moment I do not have decompressing function in asm with such codewords.

[Cyan]

It does work.

We have observed some (variable) decompression speed gains, ranging from 0 to 10%,
depending on file, cpu and compiler version.
The variance of the impact is significant, but since it seems neutral at worst, it is a good gain on average.

Therefore, this modification will be present in next lz4 release.

[lz77]

I added a condition check: to copy by 4 bytes offset must be greater than 3. (Sorry forgot).