ASM Community

;Calculate table:



Thomas1_ct proc uses ebx esi edi

    mov     edi, offset CRCtable  - 4

    xor     ecx, ecx

    

    _ml:

    mov     eax, ecx

    mov     ebx, 0EDB88320h

    add     edi, 4

    mov     esi, 8

    @@:

        shr eax, 1    

        sbb edx, edx  

        and edx, ebx

        xor eax, edx

    dec esi

    jnz @B

    inc     ecx

    mov     [edi], eax

    cmp     ecx, 256

    jb      _ml

ret

Thomas1_ct endp



; Calculate CRC

; (Uses Thomas1_ct for table generation)

Thomas2 proc uses ebx esi edi buf:DWORD, len:DWORD

    mov     esi, buf

    mov     edi, offset CRCtable

    mov     edx, len

    shr     edx, 1

    or      ecx, -1

    xor     eax, eax

    @@:

    mov     al, [esi]

    xor     al, cl

    shr     ecx, 8

    mov     ebx, [edi+4*eax]

    xor     ecx, ebx

    

    mov     al, [esi+1]

    xor     al, cl

    shr     ecx, 8

    mov     ebx, [edi+4*eax]

    add     esi,2

    xor     ecx, ebx

    

    dec     edx

    jnz     @B

    

    test    len, 1

    jz      @F

    mov     al, [esi]

    xor     al, cl

    inc     esi

    shr     ecx, 8

    mov     ebx, [edi+4*eax]

    xor     ecx, ebx

    @@:

    

    mov     eax, ecx   

    not     eax

    ret

Thomas2 endp

AMD Thunderbird 1.4GHz

------------------------------------------------------------------

eax = tE            : [B2033B77], 1672 ms [10x2MB],   11.96 MB/s

eax =        592 ticks(!) for table.

eax = Thomas1       : [B2033B77],  131 ms [10x2MB],  152.67 MB/s

eax =       112855 ticks(!) for table.

eax = Nico          : [B2033B77],  180 ms [10x2MB],  111.11 MB/s

eax =       222965 ticks(!) for table.

eax = Thomas2       : [B2033B77],  130 ms [10x2MB],  153.84 MB/s

eax =       81628 ticks(!) for table.



Pentium III - 550 MHz

------------------------------------------------------------------

eax = tE            : [B2033B77], 3966 ms [10x2MB],    5.04 MB/s

eax =        314 ticks(!) for table.

eax = Thomas1       : [B2033B77],  341 ms [10x2MB],   58.65 MB/s

eax =       158263 ticks(!) for table.

eax = Nico          : [B2033B77],  570 ms [10x2MB],   35.08 MB/s

eax =       202842 ticks(!) for table.

eax = Thomas2       : [B2033B77],  591 ms [10x2MB],   33.84 MB/s

eax =       463400 ticks(!) for table.

bits 32



global init_crc

global update_crc



segment code public align=4 use32 class=code



; Initializes the crc_table, call this first

init_crc:

   xor eax, eax

   xor edx, edx



.loop:

   mov ecx, eax

   mov edx, 8

.inloop:

   test ecx, 1

   jz .clear

   shr ecx, 1

   xor ecx, 0xedb88320

   jmp short .set

.clear:

   shr ecx, 1

.set:

   dec edx

   jnz .inloop



   mov [crc_table + eax*4], ecx

   inc eax

   cmp eax, 256

   jl .loop



   retn



; update_crc: Updates a running crc with bytes buf[0..len-1] and returns the crc

; Takes 3 parameters, (DWORD crc,LPBYTE buf,DWORD len)

; crc: The current crc value

; buf: Pointer to the buffer to update crc

; len: length of the buffer

align 4

update_crc:

   push ebp

   mov ebp, esp



; PARAMS

%define crc ebp + 8

%define buf ebp + 12

%define len ebp + 16



   push edi



   mov eax, [crc]

   xor eax, 0xFFFFFFFF



   mov edi, [buf]

   xor ecx, ecx



   cmp [len], dword 0

   je .done

.loop:

   mov edx, eax

   xor edx, [edi + ecx]

   and edx, 0xFF

   shr eax, 8

   xor eax, [crc_table + edx*4]



   inc ecx

   cmp ecx, [len]

   jl .loop

.done:

   xor eax, 0xFFFFFFFF



   pop edi



   leave

   retn 12



segment bss public align=4 use32 class=bss



crc_table resd 256

proc Nexo_ct uses ebx esi edi

	lea	edi,[CRCtable]

	xor	ebx,ebx

	mov	edx,0EDB88320h

@@lp:	mov	eax,ebx

	mov	ecx,8

@@:	xor	esi,esi

	shr	eax,1

	cmovc	esi,edx

	xor	eax,esi

	dec	ecx

	jne	@B

	mov	[edi],eax

	add	edi,4

	inc	bl

	jne	@@lp

	ret

endp



macro CRC

	movzx edx,al

	shr eax,8

	xor eax,[edi+4*edx]

endm



proc Nexo uses esi edi, lpData:DWORD,DataSize:DWORD

	mov ecx,[DataSize]

	or eax,-1

	mov esi,[lpData]

	mov edi,offset CRCtable

	sub ecx,4

	jl @@b

@@:	xor eax,[esi]

	add esi,4

	CRC

	CRC

	CRC

	CRC

	sub ecx,4

	jge @B

@@b:	mov edx,[tblmsk+4*(ecx+4)]

	and edx,[esi]

	xor eax,edx

	lea esi,[esi+4+ecx]

	jmp [tblunr+4*(ecx+4)]

align 8

tblmsk	dd 0,0FFh,0FFFFh,0FFFFFFh

u_delta = unr_d-unr

tblunr	dd unr+3*u_delta,unr+2*u_delta,unr+1*u_delta,unr



unr:	CRC

unr_d:	CRC

	CRC

	not eax

	ret

endp

CRC MACRO

	movzx edx,al

	shr eax,8

	xor eax,[edi+4*edx]

ENDM



CACHELINE EQU 64

DO_LINES EQU 2



NexoBit PROC uses esi edi ebx, lpData:DWORD,DataSize:DWORD

	mov esi,[lpData]

	mov edi,offset CRCtable

	mov ebx,[DataSize]

	and [DataSize],3

	and ebx,-4

	or eax,-1

	sub ebx,CACHELINE * DO_LINES

	jl j9



j1:

	add esi,CACHELINE * DO_LINES       ; bytes ahead

	mov ecx,0-(CACHELINE*DO_LINES)/4   ; DWORDS



	i=0

	WHILE i NE DO_LINES

		i=i+1

		prefetchnta [esi + CACHELINE * (i-DO_LINES+2)]

	ENDM



j2:	xor eax,[esi+ecx*4]

	CRC

	CRC

	CRC

	CRC

	inc ecx

	jne j2



	sub ebx,CACHELINE * DO_LINES

	jge j1

j9:

	add ebx,CACHELINE * DO_LINES

	add esi,ebx

	sub ecx,ebx

	and ebx,0

	sar ecx,2

	jne j2



	mov ecx,[DataSize]

	mov edx,[tblmsk + 4*ecx]

	and edx,[esi]

	xor eax,edx

	lea esi,[esi+4+ecx]

	jmp [tblunr + 4*ecx]

	align 8 ; should be align 64

unr::

	CRC

unr_d::

	CRC

	CRC

	not eax

	ret

.data

	align 8 ; should be align 32

tblmsk	dd 0,0FFh,0FFFFh,0FFFFFFh

u_delta = unr_d-unr

tblunr	dd unr+3*u_delta,unr+2*u_delta,unr+1*u_delta,unr

.code

NexoBit ENDP

	mov	ebx,[DataSize]

	or	eax,-1

	mov	esi,[lpData]

	mov	edi,offset CRCtable

	cmp	ebx,4

	jl	@@b

	mov	ecx,ebx

	and     ecx,-4

	add	esi,ecx

	sub	ebx,ecx		

	neg	ecx

@@Loop:

	xor	eax,[esi+ecx]

	CRC

	CRC

	CRC

	CRC

	add	ecx,4

	jl	@@Loop

@@b:

	;test	ebx, ebx

	;jz	exit

	mov	edx,[tblmsk+4*ebx]

	and	edx,[esi]

	xor	eax,edx

	jmp	[tblunr+4*ebx]

align 8

tblmsk  dd 0, 0FFh, 0FFFFh, 0FFFFFFh

u_delta = unr_d-unr

tblunr  dd unr+3*u_delta, unr+2*u_delta, unr+1*u_delta, unr



	unr:	CRC

	unr_d:	CRC

		CRC

        ;exit:

		not eax

		ret

eax = Nexo           : [88ABBE8A],  842 ms [64x2MB],  152.01 MB/s

eax = NexoBit        : [88ABBE8A],  571 ms [64x2MB],  224.16 MB/s



eax = Nexo           : [88ABBE8A], 3294 ms [256x2MB],  155.43 MB/s

eax = NexoBit        : [88ABBE8A], 2203 ms [256x2MB],  232.41 MB/s

eax = NexoBit        : [88ABBE8A], 2203 ms [256x2MB],  232.41 MB/s

eax = NexoBit        : [88ABBE8A], 2203 ms [256x2MB],  232.41 MB/s

Thomas1        : [7E2CDFAB],  531 ms [64x2MB],  241.05 MB/s

Thomas2        : [7E2CDFAB],  594 ms [64x2MB],  215.48 MB/s

Adam Stanislav : [7E2CDFAB],  922 ms [64x2MB],  138.82 MB/s

Jay            : [7E2CDFAB],  734 ms [64x2MB],  174.38 MB/s

Nexo           : [7E2CDFAB],  531 ms [64x2MB],  241.05 MB/s

NexoBit        : [7E2CDFAB],  532 ms [64x2MB],  240.60 MB/s

Thomas1        : [7E2CDFAB], 2172 ms [256x2MB],  235.72 MB/s

Thomas2        : [7E2CDFAB], 2328 ms [256x2MB],  219.93 MB/s

Adam Stanislav : [7E2CDFAB], 3735 ms [256x2MB],  137.08 MB/s

Jay            : [7E2CDFAB], 2985 ms [256x2MB],  171.52 MB/s

Nexo           : [7E2CDFAB], 2203 ms [256x2MB],  232.41 MB/s

NexoBit        : [7E2CDFAB], 2203 ms [256x2MB],  232.41 MB/s