El_Choni wrote:Weird, it should work... Could you check where the crash occurs precisely?
), so I can't really have a closer look right now but the crash
).Code: Select all
Procedure CopyMemoryAMD(*src, *dst, size)
#CACHEBLOCK = $80
#CACHEBLOCKPREFETCH = #CACHEBLOCK/2
#CACHEBLOCKTOP = #CACHEBLOCK*64
#UNCACHED_COPY = 197*1024
#UNCACHED_COPYPREFETCH = #UNCACHED_COPY/64
#TINY_BLOCK_COPY = 64
#IN_CACHE_COPY = 64*1024
#IN_CACHE_COPYBIG = #IN_CACHE_COPY/64
len = size/8
MOV esi, *src ; source array
MOV edi, *dst ; destination array
MOV ecx, len ; number of QWORDS (8 bytes)
MOV ebx, ecx ; keep a copy of count
CLD
CMP ecx, #TINY_BLOCK_COPY
JB l_memcpy_ic_3 ; tiny? skip mmx copy
CMP ecx, 32*1024 ; don't align between 32k-64k because
JBE l_memcpy_do_align ; it appears to be slower
CMP ecx, 64*1024
JBE l_memcpy_align_done
memcpy_do_align:
MOV ecx, 8 ; a trick that's faster than rep movsb...
SUB ecx, edi ; align destination to qword
AND ecx, 7 ; 111b ; get the low bits
SUB ebx, ecx ; update copy count
NEG ecx ; set up to jump into the array
ADD ecx, l_memcpy_align_done
JMP ecx ; jump to array of movsb's
;!align 4
!movsb
!movsb
!movsb
!movsb
!movsb
!movsb
!movsb
!movsb
memcpy_align_done: ; destination is dword aligned
MOV ecx, ebx ; number of bytes left to copy
SHR ecx, 6 ; get 64-byte block count
JZ l_memcpy_ic_2 ; finish the last few bytes
CMP ecx, #IN_CACHE_COPYBIG ; too big 4 cache? use uncached copy
JAE l_memcpy_uc_test
; !align 16
memcpy_ic_1: ; 64-byte block copies, in-cache copy
;!prefetchnta [esi+(200*64/34+192)] ; start reading ahead
!movq mm0, [esi+0] ; read 64 bits
!movq mm1, [esi+8]
!movq [edi+0], mm0 ; write 64 bits
!movq [edi+8], mm1 ; note: the normal !movq writes the
!movq mm2, [esi+16] ; data to cache; a cache line will be
!movq mm3, [esi+24] ; allocated as needed, to store the data
!movq [edi+16], mm2
!movq [edi+24], mm3
!movq mm0, [esi+32]
!movq mm1, [esi+40]
!movq [edi+32], mm0
!movq [edi+40], mm1
!movq mm2, [esi+48]
!movq mm3, [esi+56]
!movq [edi+48], mm2
!movq [edi+56], mm3
ADD esi, 64 ; update source pointer
ADD edi, 64 ; update destination pointer
DEC ecx ; count down
JNZ l_memcpy_ic_1 ; last 64-byte block?
memcpy_ic_2:
MOV ecx, ebx ; has valid low 6 bits of the byte count
memcpy_ic_3:
SHR ecx, 2 ; dword count
AND ecx, 31 ; %1111 ; only look at the "remainder" bits
NEG ecx ; set up to jump into the array
ADD ecx, l_memcpy_last_few
JMP ecx ; jump to array of movsd's
memcpy_uc_test:
CMP ecx, #UNCACHED_COPYPREFETCH ; big enough? use block prefetch copy
JAE l_memcpy_bp_1
memcpy_64_test:
OR ecx, ecx ; tail end of block prefetch will jump here
JZ l_memcpy_ic_2 ; no more 64-byte blocks left
memcpy_uc_1: ; 64-byte blocks, uncached copy
;!prefetchnta [esi+(200*64/34+192)] ; start reading ahead
!movq mm0, [esi+0] ; read 64 bits
ADD edi, 64 ; update destination pointer
!movq mm1, [esi+8]
ADD esi, 64 ; update source pointer
!movq mm2, [esi-48]
!movq [edi-64], mm0 ; write 64 bits, bypassing the cache
!movq mm0, [esi-40] ; note: !movq also prevents the CPU
!movq [edi-56], mm1 ; from READING the destination address
!movq mm1, [esi-32] ; into the cache, only to be over-written
!movq [edi-48], mm2 ; so that also helps performance
!movq mm2, [esi-24]
!movq [edi-40], mm0
!movq mm0, [esi-16]
!movq [edi-32], mm1
!movq mm1, [esi-8]
!movq [edi-24], mm2
!movq [edi-16], mm0
DEC ecx
!movq [edi-8], mm1
JNZ l_memcpy_uc_1 ; last 64-byte block?
JMP l_memcpy_ic_2 ; almost done
memcpy_bp_1: ; large blocks, block prefetch copy
CMP ecx, #CACHEBLOCK ; big enough to run another prefetch loop?
JL l_memcpy_64_test ; no, back to regular uncached copy
MOV eax, #CACHEBLOCKPREFETCH ; block prefetch loop, unrolled 2X
ADD esi, #CACHEBLOCKTOP ; move to the top of the block
; !align 16
memcpy_bp_2:
MOV edx, [esi-64] ; grab one address per cache line
MOV edx, [esi-128] ; grab one address per cache line
SUB esi, 128 ; go reverse order
DEC eax ; count down the cache lines
JNZ l_memcpy_bp_2 ; keep grabbing more lines into cache
MOV eax, #CACHEBLOCK ; now that it's in cache, do the copy
; !align 16
memcpy_bp_3:
!movq mm0, [esi] ; read 64 bits
!movq mm1, [esi+ 8]
!movq mm2, [esi+16]
!movq mm3, [esi+24]
!movq mm4, [esi+32]
!movq mm5, [esi+40]
!movq mm6, [esi+48]
!movq mm7, [esi+56]
ADD esi, 64 ; update source pointer
!movq [edi], mm0 ; write 64 bits, bypassing cache
!movq [edi+ 8], mm1 ; note: !movq also prevents the CPU
!movq [edi+16], mm2 ; from READING the destination address
!movq [edi+24], mm3 ; into the cache, only to be over-written,
!movq [edi+32], mm4 ; so that also helps performance
!movq [edi+40], mm5
!movq [edi+48], mm6
!movq [edi+56], mm7
ADD edi, 64 ; update dest pointer
DEC eax ; count down
JNZ l_memcpy_bp_3 ; keep copying
SUB ecx, #CACHEBLOCK ; update the 64-byte block count
JMP l_memcpy_bp_1 ; keep processing chunks
;The smallest copy uses the X86 "!movsd" instruction, in an optimized
;form which is an "unrolled loop". Then it handles the last few bytes.
; !align 4
!movsd
!movsd ; perform last 1-15 dword copies
!movsd
!movsd
!movsd
!movsd
!movsd
!movsd
!movsd
!movsd ; perform last 1-7 dword copies
!movsd
!movsd
!movsd
!movsd
!movsd
!movsd
memcpy_last_few: ; dword aligned from before !movsd's
MOV ecx, ebx ; has valid low 2 bits of the byte count
AND ecx, 3 ; %11 ; the last few cows must come home
JZ l_memcpy_final ; no more, let's leave
REP movsb ; the last 1, 2, or 3 bytes
memcpy_final:
!emms ; clean up the state
;!sfence ; flush the write buffer
EndProcedure
manyk = Pow(2, 26)
source = AllocateMemory(manyk)
destination = AllocateMemory(manyk)
If source And destination
time = ElapsedMilliseconds()
For a=1 To 10
CopyMemoryAMD(source, destination, manyk)
Next
manyk_AMD.s = Str((ElapsedMilliseconds()-time))
time = ElapsedMilliseconds()
For a=1 To 10
CopyMemory(source, destination, manyk)
Next
manyk_PB.s = Str((ElapsedMilliseconds()-time))
FreeMemory(source)
FreeMemory(destination)
source = 0
destination = 0
manyk_times = Val(manyk_PB)/Val(manyk_AMD)
Else
MessageRequester("Error", "Could not allocate two "+Str(manyk/1024)+" KB blocks.")
EndIf
ameg = Pow(2, 20)
source = AllocateMemory(ameg)
destination = AllocateMemory(ameg)
If source And destination
time = ElapsedMilliseconds()
For a=1 To 10000
CopyMemoryAMD(source, destination, ameg)
Next
onek_AMD.s = Str((ElapsedMilliseconds()-time))
time = ElapsedMilliseconds()
For a=1 To 10000
CopyMemory(source, destination, ameg)
Next
onek_PB.s = Str((ElapsedMilliseconds()-time))
FreeMemory(source)
FreeMemory(destination)
source = 0
destination = 0
onek_times = Val(onek_PB)/Val(onek_AMD)
Else
MessageRequester("Error", "Could not allocate two "+Str(ameg/1024)+" KB blocks.")
EndIf
hk = 1024*100
source = AllocateMemory(hk)
destination = AllocateMemory(hk)
If source And destination
time = ElapsedMilliseconds()
For a=1 To 10000
CopyMemoryAMD(source, destination, hk)
Next
hundredk_AMD.s = Str((ElapsedMilliseconds()-time))
time = ElapsedMilliseconds()
For a=1 To 10000
CopyMemory(source, destination, hk)
Next
hundredk_PB.s = Str((ElapsedMilliseconds()-time))
FreeMemory(source)
FreeMemory(destination)
source = 0
destination = 0
hundredk_times = Val(hundredk_PB)/Val(hundredk_AMD)
Else
MessageRequester("Error", "Could not allocate two "+Str(hk/1024)+" KB blocks.")
EndIf
results.s="--- 64 MB tranfer test ---"+#LFCR$
results.s+"AMD Function : "+ manyk_AMD +#LFCR$
results.s+"Pure Function : "+ manyk_PB +#LFCR$
results.s+"AMD Function is "+Str(manyk_times)+" times faster."+#LFCR$
results.s+#LFCR$
results.s+"--- 1 MB tranfer test ---"+#LFCR$
results.s+"AMD Function : "+ onek_AMD +#LFCR$
results.s+"Pure Function : "+ onek_PB +#LFCR$
results.s+"AMD Function is "+Str(onek_times)+" times faster."+#LFCR$
results.s+#LFCR$
results.s+"--- 100kb tranfer test ---"+#LFCR$
results.s+"AMD Function : "+ hundredk_AMD +#LFCR$
results.s+"Pure Function : "+ hundredk_PB +#LFCR$
results.s+"AMD Function is "+Str(hundredk_times)+" times faster."+#LFCR$
MessageRequester("Test Results", results.s)
Same result.El_Choni wrote:@traumatic, could you try this code (when you can) in your Pentium 2?
Code: Select all
--- 64 MB tranfer test ---
AMD Function : 109
Pure Function : 1719
AMD Function is 15 times faster.
--- 1 MB tranfer test ---
AMD Function : 656
Pure Function : 30687
AMD Function is 46 times faster.
--- 100kb tranfer test ---
AMD Function : 16
Pure Function : 594
AMD Function is 37 times faster.
Code: Select all
--- 64 MB tranfer test ---
AMD Function : 100
Pure Function : 2293
AMD Function is 22 times faster.
--- 1 MB tranfer test ---
AMD Function : 701
Pure Function : 39457
AMD Function is 56 times faster.
--- 100kb tranfer test ---
AMD Function : 10
Pure Function : 400
AMD Function is 40 times faster.
Intel Pentium 4 Prescott Processor 3.2GHz
* New .09 micron "Strained SI" manufacturing process
* Improved Hyperthreading Technology
* 1MB on chip, Full Speed L2 Cache
* Increased 16KB L1 Data Cache
* Streaming SIMD Extensions - SSE2 and 13 new SSE3 Instructions
* 31 stage "Hyper Pipelined" Technology for extremely high clock speeds
* 800MHz "Quad Pumped" Front Side Bus
* Rapid Execution Engine - ALU clocked at 2X frequency of core
* 128bit Floating Point/Multimedia unit
* Intel "NetBurst" micro-architecture
* Supported by the Intel i875P and i865G chipsets, with Hyperthreading support
* Intel MMX media enhancement technology
* Memory cacheability up to 4 GB of addressable memory space and system memory scalability up to 64 GB of physical memory
* 1.25 - 1.4V operating voltage range
* 89 - 103 Watts max power dissipation
* Transistor count: 125 million
* Die size: 112 mm2
--- 64 MB test ---
AMD function: 125
Pure function: 2016
AMD function is 16 times faster
--- 1 MB test ---
AMD function: 750
Pure function: 30156
AMD function is 40 times faster
--- 100kb MB test ---
AMD function: 16
Pure function: 468
AMD function is 29 times faster
Looks like it is big difference between a AthlonXp 2400 and 2500. I have only 512MB, cheap memory. Here is my results:GeoTrail wrote:Here's my result with my homebuilt box running AMD Athlon XP +2400 with 1 GB RAM (Kingston power)--- 64 MB test ---
AMD function: 125
Pure function: 2016
AMD function is 16 times faster
--- 1 MB test ---
AMD function: 750
Pure function: 30156
AMD function is 40 times faster
--- 100kb MB test ---
AMD function: 16
Pure function: 468
AMD function is 29 times faster
