ASM Community

hii .. .
i need the fastest way to check if a byte is a letter , i mean if he between A to Z or a to z
i'm sure there is a faster way than just cmp both cases


thanks
bye

eko

EDIT:
;two ways based on maverick algo

lea             ebx,[ecx-'A']

cmp             ebx,'Z'-'A'

jc              label

lea             ebx,[ecx-'a']

cmp             ebx,'z'-'a'

jc              label

lea             ebx,[ecx-'A']

cmp             ebx,'z'-'A'

jc              label

lea             ebx,[ecx-'a'-1]

cmp             ebx,'a'-1-'Z'+1

jnc              label

.data

letmask dd 00000000h, 00000000h, 07FFFFFEh, 07FFFFFEh, 00000000h, 00000000h, 00000000h, 00000000h

.code

	bt letmask,ecx 

	jnc not letter

btw: on the board the algo you mentioned above was firstly submitted by Nexo.

Check out BitStrings utility.
It creates for you control blocks for 2^256 different condition cases.
Disign to work easily with symbols (both OEM consol and ANSI) and numbers.
I just putted your conditions inside it and copy paste result into the post.

My technical data doesn't use words "fast" or "slow" regarding speed of instructions, it uses numbers :)
And it says that it is 4 to 8 clocks for bt in <=PMMX
(depends on memory or register used)
and 1mops to 1+6+1mops for > PMMX.

Then to calculate deviation of two methods we need analyze what data would be passed to it. In different
cases bt might be from 7 clocks per iteration slower to 37 clocks per iteration faster.

Alex,

This is Agner Fog's comments on BT in his optimisation manual.

26.4 Bit test (all processors)

BT, BTC, BTR, and BTS instructions should preferably be replaced by instructions like TEST, AND, OR, XOR, or shifts on PPlain and PMMX. On PPro, PII and PIII, bit tests with a memory operand should be avoided.

Regards,

hutch@movsd.com

Oh yeah, and would a sub be faster than a cmp? I have no idea.
Also, maybe it would be more efficient to use ecx instead of eax since the first op destroys ecx anyway.

Maybe something like this:

	and cl, 0DFh

	sub cl, 41h

	sub cl, 1Ah

	jc _isAlpha

Eko,

I ran a test using QueryPerformanceCounter setting process and thread priorities to REAL_TIME, and the speeds varied depending on what char was in ecx...

For non-alphas, Svin's algo performed differently than with alphas. Non-alphas took on average twice as long to process for some reason. Anybody know why? The other algo wasn't affected.

Regarding alignment, Svin's algo performed at greatly different speeds depending on whether or not the code and the Letter Mask was aligned. This didn't happen with the other algo. At optimal alignment, Svin's algo performed slightly better than the other one, but only for some letters. The algo I posted was the most stable across the board.

This was on an AMD 1.4ghz, I'm sure timings will be different on different processors. Both algos seem to be pretty damn fast though.

Maybe?

sar al,7 ; OR shr al,7
jna Printable

I tried to find a way to use shl al,1 but could not in a couple minutes.

chorus, thanks, I was too quick to reply.

How about

bt      eax, 7

jnc     __bit8isoff

;bit 8 is on

*Might* be fast on newer processors. :)

/me, making myself look like an idiot. :grin: