New right trim algo.

jj2007 · June 14, 2014, 10:24:20 PM

Thanks. The performance of any rtrim() algo depends basically on
1. the cycles required to find the end of the string (len, Len, lstrlen, whatever)
2. the cycles required to find (backwards) the first char above Ascii 32

Once found, Masm32 inserts the zero delimiter there; MasmBasic Rtrim$() does not change the original but rather passes the pointer to the original plus the string len without spaces to the string engine.

LarryC · June 14, 2014, 11:54:31 PM

Allocating 589824 megabytes for testing
If it crashes due to lack of memory, reduce the allocation
size in the 'lpcount' equate above
94 milliseconds rtrim1
78 milliseconds rtrim2
78 milliseconds rtrim1
93 milliseconds rtrim2
78 milliseconds rtrim1
78 milliseconds rtrim2
78 milliseconds rtrim1
93 milliseconds rtrim2
Press any key to continue ...

dedndave · June 15, 2014, 01:29:48 AM

prescott w/htt @ 3 GHz

Code Select

171 milliseconds rtrim1
171 milliseconds rtrim2
172 milliseconds rtrim1
187 milliseconds rtrim2
171 milliseconds rtrim1
172 milliseconds rtrim2
172 milliseconds rtrim1
172 milliseconds rtrim2

may i suggest.....
seperate the functions
you want to work on the RTrim operation, not StrLen
and what about UNICODE aware ? :icon_eek:

hutch-- · June 15, 2014, 02:23:50 AM

Dave,

The two algos do not use a len operation, they are a single pass from left to right that determines the last non blank space then places a terminator after it. If I have it right the same speed of both algos is determined by the memory access and for a byte scan design it probably will not go any faster.

A unicode version would look very similar but would read WORD size characters, not byte.

nidud · June 15, 2014, 02:58:18 AM

deleted

Gunther · June 15, 2014, 03:04:41 AM

Hi nidud,

results from strtrim:

Code Select


Intel(R) Core(TM) i7-3770 CPU @ 3.40GHz (SSE4)
------------------------------------------------------
171741  cycles - 0: standard (scasb)
10004   cycles - 1: rtrim1
11408   cycles - 2: rtrim2
11234   cycles - 3: new strlen (AgnerFog)

71151   cycles - 0: standard (scasb)
9874    cycles - 1: rtrim1
26642   cycles - 2: rtrim2
27218   cycles - 3: new strlen (AgnerFog)

133009  cycles - 0: standard (scasb)
23452   cycles - 1: rtrim1
26731   cycles - 2: rtrim2
27158   cycles - 3: new strlen (AgnerFog)

--- ok ---

Gunther

hutch-- · June 15, 2014, 03:09:18 PM

Here is a version that also tests an algo that scans the length then back scans to find last acceptable character. It is substantially slower than the single pass versions. It uses Agner Fog's old StrLen algo unrolled by 4 then back scans the string to find that last character. It could be optimised some more but there is little gain in it as the back scanner only has a single memory access.

Allocating 589824 megabytes for testing
If it crashes due to lack of memory, reduce the allocation
size in the 'lpcount' equate above
94 milliseconds rtrim1
94 milliseconds rtrim2
125 milliseconds rtrim3
94 milliseconds rtrim1
93 milliseconds rtrim2
125 milliseconds rtrim3
94 milliseconds rtrim1
94 milliseconds rtrim2
125 milliseconds rtrim3
94 milliseconds rtrim1
94 milliseconds rtrim2
125 milliseconds rtrim3
Press any key to continue ...

This is the test piece.

IF 0 ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Build this template with "CONSOLE ASSEMBLE AND LINK"
ENDIF ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

include \masm32\include\masm32rt.inc

rtrim1 PROTO :DWORD ; first test algo
rtrim2 PROTO :DWORD ; second test algo
rtrim3 PROTO :DWORD ; third test algo

.data
item1 db "this is a test of rtrim algos ",0 ; 48 bytes total
item2 db " this is a test of rtrim algos ",0 ; 48 bytes total
item3 db " this is a test of rtrim algos ",0 ; 48 bytes total
item4 db " ",0 ; 48 bytes total

.code

start:

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

call main
inkey
exit

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

lpcount equ <1024*1024*12>

main proc

LOCAL txt :DWORD
LOCAL hArr :DWORD
LOCAL pArr :DWORD
LOCAL aInd :DWORD
LOCAL lcnt :DWORD
LOCAL icnt :DWORD

push esi
push edi

print "Allocating "
print ustr$(lpcount*48 / 1024)," megabytes for testing",13,10
print "If it crashes due to lack of memory, reduce the allocation",13,10
print "size in the 'lpcount' equate above",13,10

invoke SetPriorityClass,rv(GetCurrentProcess),HIGH_PRIORITY_CLASS

mov icnt, 4
tlp:

; ******************************************
; write an array of strings
; ------------------------------------------
mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov pArr, rv(create_array,lpcount,48) ; pointer array handle
mov hArr, ecx ; main array memory handle
mov edi, pArr

larr1:
cst [edi], OFFSET item1
cst [edi+4], OFFSET item2
cst [edi+8], OFFSET item3
cst [edi+12], OFFSET item4
add edi, 4
sub lcnt, 1
jnz larr1
; ------------------------------------------

invoke GetTickCount
push eax

mov eax, lpcount
shr eax, 2
mov lcnt, eax

tarr1:
mov txt, rv(rtrim1,[edi])
mov txt, rv(rtrim1,[edi+4])
mov txt, rv(rtrim1,[edi+8])
mov txt, rv(rtrim1,[edi+12])
add edi, 4
sub lcnt, 1
jnz tarr1

free pArr
free hArr

invoke GetTickCount
pop ecx
sub eax, ecx

print ustr$(eax)," milliseconds rtrim1",13,10

; ******************************************
; write an array of strings
; ------------------------------------------
mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov pArr, rv(create_array,lpcount,48) ; pointer array handle
mov hArr, ecx ; main array memory handle
mov edi, pArr

larr2:
cst [edi], OFFSET item1
cst [edi+4], OFFSET item2
cst [edi+8], OFFSET item3
cst [edi+12], OFFSET item4
add edi, 4
sub lcnt, 1
jnz larr2
; ------------------------------------------

invoke GetTickCount
push eax

mov eax, lpcount
shr eax, 2
mov lcnt, eax

tarr2:
mov txt, rv(rtrim2,[edi])
mov txt, rv(rtrim2,[edi+4])
mov txt, rv(rtrim2,[edi+8])
mov txt, rv(rtrim2,[edi+12])
add edi, 4
sub lcnt, 1
jnz tarr2

free pArr
free hArr

invoke GetTickCount
pop ecx
sub eax, ecx

print ustr$(eax)," milliseconds rtrim2",13,10

; ------------------------------------------
mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov pArr, rv(create_array,lpcount,48) ; pointer array handle
mov hArr, ecx ; main array memory handle
mov edi, pArr

larr3:
cst [edi], OFFSET item1
cst [edi+4], OFFSET item2
cst [edi+8], OFFSET item3
cst [edi+12], OFFSET item4
add edi, 4
sub lcnt, 1
jnz larr3

; ------------------------------------------

invoke GetTickCount
push eax

mov eax, lpcount
shr eax, 2
mov lcnt, eax

tarr3:
mov txt, rv(rtrim3,[edi])
mov txt, rv(rtrim3,[edi+4])
mov txt, rv(rtrim3,[edi+8])
mov txt, rv(rtrim3,[edi+12])
add edi, 4
sub lcnt, 1
jnz tarr3

free pArr
free hArr

invoke GetTickCount
pop ecx
sub eax, ecx

print ustr$(eax)," milliseconds rtrim3",13,10

; ******************************************

sub icnt, 1
jnz tlp

invoke SetPriorityClass,rv(GetCurrentProcess),NORMAL_PRIORITY_CLASS

pop edi
pop esi

ret

main endp

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE

rtrim1 proc ptxt:DWORD

; ------------------------------------------------
; one pass left to right to determine last valid
; character then terminate it after that character
; ------------------------------------------------

mov edx, [esp+4] ; load address into EDX
mov ecx, edx ; store that address in ECX
sub edx, 1

lpst:
add edx, 1
movzx eax, BYTE PTR [edx] ; zero extend byte into EAX
test eax, eax ; test for zero terminator
jz lpout ; exit loop on zero
cmp eax, 32 ; test if space character or lower
jbe lpst ; jump back if below or equal
mov ecx, edx ; store updated last character location in ECX
jmp lpst ; jump back to loop start

lpout:
cmp ecx, [esp+4] ; if ECX has not been modified (empty string)
je nxt ; jump to NXT label
add ecx, 1 ; add 1 to ECX to write terminator past last character
nxt:
mov BYTE PTR [ecx], 0 ; write the terminator

mov eax, [esp+4] ; put original stack address in EAX as return address
ret 4 ; BYE !

rtrim1 endp

OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE

rtrim2 proc ptxt:DWORD

; ------------------------------------------------
; one pass left to right to determine last valid
; character then terminate it after that character
; ------------------------------------------------
mov edx, [esp+4] ; load address into EDX
mov ecx, edx ; store that address in ECX
jmp ji

pre:
mov ecx, edx ; store updated last character location in ECX
lpst:
add edx, 1
ji:
movzx eax, BYTE PTR [edx] ; zero extend byte into EAX
cmp eax, 32 ; test if space character or lower
ja pre
test eax, eax ; test for zero terminator
jnz lpst ; fall through on zero

lpout:
cmp ecx, [esp+4] ; if ECX has not been modified (empty string)
je nxt ; jump to NXT label
add ecx, 1 ; add 1 to ECX to write terminator past last character
nxt:
mov BYTE PTR [ecx], 0 ; write the terminator

mov eax, [esp+4] ; put original stack address in EAX as return address
ret 4 ; BYE !

rtrim2 endp

OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE

rtrim3 proc ptxt:DWORD

mov eax, [esp+4] ; get pointer to string
lea edx, [eax+3] ; pointer+3 used in the end
push esi
push edi
mov edi, 80808080h

@@:
REPEAT 3
mov esi, [eax] ; read first 4 bytes
add eax, 4 ; increment pointer
lea ecx, [esi-01010101h] ; subtract 1 from each byte
not esi ; invert all bytes
and ecx, esi ; and these two
and ecx, edi
jnz nxt
ENDM

mov esi, [eax] ; read first 4 bytes
add eax, 4 ; 4 increment DWORD pointer
lea ecx, [esi-01010101h] ; subtract 1 from each byte
not esi ; invert all bytes
and ecx, esi ; and these two
and ecx, edi
jz @B ; no zero bytes, continue loop

nxt:
test ecx, 00008080h ; test first two bytes
jnz @F
shr ecx, 16 ; not in the first 2 bytes
add eax, 2
@@:
shl cl, 1 ; use carry flag to avoid branch
sbb eax, edx ; compute length

; --------------------------------------
; set up for back scanning end of string
; --------------------------------------
mov esi, [esp+4][8] ; lower
mov edi, eax
add edi, esi ; higher
add edi, 1

bscn:
sub edi, 1
cmp esi, edi ; don't scan below start address
je bsout
cmp BYTE PTR [edi], 32 ; test if ascii 32 or less
jbe bscn ; loop back if unwanted character

add edi, 1 ; correct for string with characters

bsout:
mov BYTE PTR [edi], 0 ; terminate string
mov eax, esi ; copy start address into EAX

pop edi
pop esi

ret 4 ; BYE !

rtrim3 endp

OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

end start

nidud · June 15, 2014, 09:24:15 PM

deleted

dedndave · June 15, 2014, 09:24:57 PM

prescott w/htt @ 3.0 GHz

Code Select

Allocating 589824 megabytes for testing
If it crashes due to lack of memory, reduce the allocation
size in the 'lpcount' equate above
188 milliseconds rtrim1
172 milliseconds rtrim2
297 milliseconds rtrim3
172 milliseconds rtrim1
188 milliseconds rtrim2
297 milliseconds rtrim3
188 milliseconds rtrim1
187 milliseconds rtrim2
297 milliseconds rtrim3
188 milliseconds rtrim1
188 milliseconds rtrim2
297 milliseconds rtrim3

dedndave · June 15, 2014, 09:27:51 PM

prescott w/htt

Code Select

Intel(R) Pentium(R) 4 CPU 3.00GHz (SSE3)
------------------------------------------------------
31757   cycles - 0: standard (scasb)
27877   cycles - 1: rtrim1
17383   cycles - 2: rtrim2
12989   cycles - 3: new strlen (AgnerFog)
18351   cycles - 4: rtrimUltra (Masm32 len)
16126   cycles - 5: rtrim3
13127   cycles - 6: repeat 4 (AgnerFog)
13788   cycles - 7: rtrimUltra (MasmBasic Len) - SSE
8063    cycles - 8: strtrim unaligned - SSE

31439   cycles - 0: standard (scasb)
27853   cycles - 1: rtrim1
18167   cycles - 2: rtrim2
12934   cycles - 3: new strlen (AgnerFog)
18120   cycles - 4: rtrimUltra (Masm32 len)
15627   cycles - 5: rtrim3
13031   cycles - 6: repeat 4 (AgnerFog)
13014   cycles - 7: rtrimUltra (MasmBasic Len) - SSE
8047    cycles - 8: strtrim unaligned - SSE

33208   cycles - 0: standard (scasb)
27703   cycles - 1: rtrim1
17897   cycles - 2: rtrim2
15139   cycles - 3: new strlen (AgnerFog)
18173   cycles - 4: rtrimUltra (Masm32 len)
15778   cycles - 5: rtrim3
13135   cycles - 6: repeat 4 (AgnerFog)
10862   cycles - 7: rtrimUltra (MasmBasic Len) - SSE
10029   cycles - 8: strtrim unaligned - SSE

jj2007 · June 15, 2014, 09:40:41 PM

Quote from: nidud on June 15, 2014, 09:24:15 PM
Some new results including SSE functions.

Nice work :t
It seems your SSE2 version is a bit like Len() without the overhead.

But Hutch has created a testbed that identifies other champions, and I still have not fully understood why. No cache, of course, with hundreds of megabytes to process. And the trailing spaces are quite many (which makes the testbed a bit unrealistic 8)), but still, that doesn't explain why the one-pass should be faster than the len-plus-search-backwards strategy ::)

hutch-- · June 15, 2014, 10:12:59 PM

I did the data this way for a reason, small to large trailing spaces on a reasonable length string (48 bytes) to test the linear speed of the forward scan, something that should suit a DWORD scanner over a BYTE scanner but then taking extra time to back scan to find the last non character position. The very large sample was to get a duration long enough, I used to test on 100 meg but with faster processors its too small.

Testing on a very large linear source defeats loop and cache effects and you are left with processing time on always new data, not looped in cache data.

nidud · June 15, 2014, 11:07:34 PM

deleted

Gunther · June 15, 2014, 11:23:04 PM

Results strtrim3:

Code Select


Intel(R) Core(TM) i7-3770 CPU @ 3.40GHz (SSE4)
------------------------------------------------------
13273   cycles - 0: standard (scasb)
12690   cycles - 1: rtrim1
10177   cycles - 2: rtrim2
4261    cycles - 3: new strlen (AgnerFog)
5656    cycles - 4: rtrimUltra (Masm32 len)
3653    cycles - 5: rtrim3
3450    cycles - 6: repeat 4 (AgnerFog)
2589    cycles - 7: rtrimUltra (MasmBasic Len) - SSE
1501    cycles - 8: strtrim unaligned - SSE

13906   cycles - 0: standard (scasb)
32205   cycles - 1: rtrim1
24778   cycles - 2: rtrim2
11307   cycles - 3: new strlen (AgnerFog)
13530   cycles - 4: rtrimUltra (Masm32 len)
8814    cycles - 5: rtrim3
8101    cycles - 6: repeat 4 (AgnerFog)
5996    cycles - 7: rtrimUltra (MasmBasic Len) - SSE
4181    cycles - 8: strtrim unaligned - SSE

32142   cycles - 0: standard (scasb)
30590   cycles - 1: rtrim1
24709   cycles - 2: rtrim2
10966   cycles - 3: new strlen (AgnerFog)
13328   cycles - 4: rtrimUltra (Masm32 len)
8860    cycles - 5: rtrim3
8013    cycles - 6: repeat 4 (AgnerFog)
5974    cycles - 7: rtrimUltra (MasmBasic Len) - SSE
3501    cycles - 8: strtrim unaligned - SSE

--- ok ---

Gunther

hutch-- · June 16, 2014, 01:49:23 AM

I suspected there was a stuffup in the benchmark I had used because it was not responding to code changes but I found the problem, I was not resetting EDI before each read block performing the rtrim function. Very different results which are now making sense. Once I got it working correctly I have unrolled the 3rd algo (Agner Fog's Strlen algo with back scanner) by a factor of 8 which is overdoing it for an algo of this type but on this old quad, its about 5 times faster than the one pass scanners. I also mis-aligned the data by 1 byte to reduce the effectiveness of aligned reads but it made no difference in timings.

391 milliseconds rtrim1
422 milliseconds rtrim2
78 milliseconds rtrim3
375 milliseconds rtrim1
406 milliseconds rtrim2
78 milliseconds rtrim3
390 milliseconds rtrim1
406 milliseconds rtrim2
78 milliseconds rtrim3
390 milliseconds rtrim1
406 milliseconds rtrim2
78 milliseconds rtrim3
Press any key to continue ...

The modified benchmark is as follows.

IF 0 ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤
Build this template with "CONSOLE ASSEMBLE AND LINK"
ENDIF ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

include \masm32\include\masm32rt.inc

rtrim1 PROTO :DWORD ; first test algo
rtrim2 PROTO :DWORD ; second test algo
rtrim3 PROTO :DWORD ; third test algo

.data
align 4
db 0
item1 db "this is a test of rtrim algos ",0 ; 48 bytes total

align 4
db 0
item2 db " this is a test of rtrim algos ",0 ; 48 bytes total

align 4
db 0
item3 db " this is a test of rtrim algos ",0 ; 48 bytes total

align 4
db 0
item4 db " ",0 ; 48 bytes total

.code

start:

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

call main
inkey
exit

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

lpcount equ <1024*1024*4>

main proc

LOCAL txt :DWORD
LOCAL hArr :DWORD
LOCAL pArr :DWORD
LOCAL aInd :DWORD
LOCAL lcnt :DWORD
LOCAL icnt :DWORD

push esi
push edi

invoke SetPriorityClass,rv(GetCurrentProcess),HIGH_PRIORITY_CLASS

mov icnt, 4
tlp:

; ******************************************
; write an array of strings
; ------------------------------------------
mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov pArr, rv(create_array,lpcount,48) ; pointer array handle
mov hArr, ecx ; main array memory handle
mov edi, pArr

larr1:
cst [edi], OFFSET item1
cst [edi+4], OFFSET item2
cst [edi+8], OFFSET item3
cst [edi+12], OFFSET item4
add edi, 4
sub lcnt, 1
jnz larr1
; ------------------------------------------

invoke GetTickCount
push eax

mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov edi, pArr

tarr1:
mov txt, rv(rtrim1,[edi])
mov txt, rv(rtrim1,[edi+4])
mov txt, rv(rtrim1,[edi+8])
mov txt, rv(rtrim1,[edi+12])
add edi, 4
sub lcnt, 1
jnz tarr1

free pArr
free hArr

invoke GetTickCount
pop ecx
sub eax, ecx

print ustr$(eax)," milliseconds rtrim1",13,10

; ******************************************
; write an array of strings
; ------------------------------------------
mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov pArr, rv(create_array,lpcount,48) ; pointer array handle
mov hArr, ecx ; main array memory handle
mov edi, pArr

larr2:
cst [edi], OFFSET item1
cst [edi+4], OFFSET item2
cst [edi+8], OFFSET item3
cst [edi+12], OFFSET item4
add edi, 4
sub lcnt, 1
jnz larr2
; ------------------------------------------

invoke GetTickCount
push eax

mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov edi, pArr

tarr2:
mov txt, rv(rtrim2,[edi])
mov txt, rv(rtrim2,[edi+4])
mov txt, rv(rtrim2,[edi+8])
mov txt, rv(rtrim2,[edi+12])
add edi, 4
sub lcnt, 1
jnz tarr2

free pArr
free hArr

invoke GetTickCount
pop ecx
sub eax, ecx

print ustr$(eax)," milliseconds rtrim2",13,10

; ------------------------------------------
mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov pArr, rv(create_array,lpcount,48) ; pointer array handle
mov hArr, ecx ; main array memory handle
mov edi, pArr

larr3:
cst [edi], OFFSET item1
cst [edi+4], OFFSET item2
cst [edi+8], OFFSET item3
cst [edi+12], OFFSET item4
add edi, 4
sub lcnt, 1
jnz larr3

; ------------------------------------------

invoke GetTickCount
push eax

mov eax, lpcount
shr eax, 2
mov lcnt, eax

mov edi, pArr

tarr3:
mov txt, rv(rtrim3,[edi])
mov txt, rv(rtrim3,[edi+4])
mov txt, rv(rtrim3,[edi+8])
mov txt, rv(rtrim3,[edi+12])
add edi, 4
sub lcnt, 1
jnz tarr3

free pArr
free hArr

invoke GetTickCount
pop ecx
sub eax, ecx

print ustr$(eax)," milliseconds rtrim3",13,10

; ******************************************

sub icnt, 1
jnz tlp

invoke SetPriorityClass,rv(GetCurrentProcess),NORMAL_PRIORITY_CLASS

pop edi
pop esi

ret

main endp

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE

rtrim1 proc ptxt:DWORD

; ------------------------------------------------
; one pass left to right to determine last valid
; character then terminate it after that character
; ------------------------------------------------

mov edx, [esp+4] ; load address into EDX
mov ecx, edx ; store that address in ECX
sub edx, 1

lpst:
add edx, 1
movzx eax, BYTE PTR [edx] ; zero extend byte into EAX
test eax, eax ; test for zero terminator
jz lpout ; exit loop on zero
cmp eax, 32 ; test if space character or lower
jbe lpst ; jump back if below or equal
mov ecx, edx ; store updated last character location in ECX
jmp lpst ; jump back to loop start

lpout:
cmp ecx, [esp+4] ; if ECX has not been modified (empty string)
je nxt ; jump to NXT label
add ecx, 1 ; add 1 to ECX to write terminator past last character
nxt:
mov BYTE PTR [ecx], 0 ; write the terminator

mov eax, [esp+4] ; put original stack address in EAX as return address
ret 4 ; BYE !

rtrim1 endp

OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE

rtrim2 proc ptxt:DWORD

; ------------------------------------------------
; one pass left to right to determine last valid
; character then terminate it after that character
; ------------------------------------------------
mov edx, [esp+4] ; load address into EDX
mov ecx, edx ; store that address in ECX
jmp ji

pre:
mov ecx, edx ; store updated last character location in ECX
lpst:
add edx, 1
ji:
movzx eax, BYTE PTR [edx] ; zero extend byte into EAX
cmp eax, 32 ; test if space character or lower
ja pre
test eax, eax ; test for zero terminator
jnz lpst ; fall through on zero

lpout:
cmp ecx, [esp+4] ; if ECX has not been modified (empty string)
je nxt ; jump to NXT label
add ecx, 1 ; add 1 to ECX to write terminator past last character
nxt:
mov BYTE PTR [ecx], 0 ; write the terminator

mov eax, [esp+4] ; put original stack address in EAX as return address
ret 4 ; BYE !

rtrim2 endp

OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

OPTION PROLOGUE:NONE
OPTION EPILOGUE:NONE

rtrim3 proc ptxt:DWORD

mov eax, [esp+4] ; get pointer to string
lea edx, [eax+3] ; pointer+3 used in the end
push esi
push edi
mov edi, 80808080h

@@:
REPEAT 7
mov esi, [eax] ; read first 4 bytes
add eax, 4 ; increment pointer
lea ecx, [esi-01010101h] ; subtract 1 from each byte
not esi ; invert all bytes
and ecx, esi ; and these two
and ecx, edi
jnz nxt
ENDM

mov esi, [eax] ; read first 4 bytes
add eax, 4 ; 4 increment DWORD pointer
lea ecx, [esi-01010101h] ; subtract 1 from each byte
not esi ; invert all bytes
and ecx, esi ; and these two
and ecx, edi
jz @B ; no zero bytes, continue loop

nxt:
test ecx, 00008080h ; test first two bytes
jnz @F
shr ecx, 16 ; not in the first 2 bytes
add eax, 2
@@:
shl cl, 1 ; use carry flag to avoid branch
sbb eax, edx ; compute length

; --------------------------------------
; set up for back scanning end of string
; --------------------------------------
mov esi, [esp+4][8] ; lower
mov edi, eax
add edi, esi ; higher
add edi, 1

bscn:
REPEAT 7
sub edi, 1
cmp esi, edi ; don't scan below start address
je bsout
cmp BYTE PTR [edi], 32 ; test if ascii 32 or less
ja bnxt ; loop back if unwanted character
ENDM

sub edi, 1
cmp esi, edi ; don't scan below start address
je bsout
cmp BYTE PTR [edi], 32 ; test if ascii 32 or less
jbe bscn ; loop back if unwanted character

bnxt:
add edi, 1 ; correct for string with characters

bsout:
mov BYTE PTR [edi], 0 ; terminate string
mov eax, esi ; copy start address into EAX

pop edi
pop esi

ret 4 ; BYE !

rtrim3 endp

OPTION PROLOGUE:PrologueDef
OPTION EPILOGUE:EpilogueDef

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤

end start

The MASM Forum

News: