«

On 2012-03-13, Kleuske <> wrote:
> On Tue, 13 Mar 2012 21:59:41 +0000, pembed2012 saw fit to publish the
>> int strcmp_fast(char* s,char* t){
>> uls=(unsigned long*)s;
>> ult=(unsigned long*)t;
>> if(*uls>*ult) return(1);
>> if(*uls<*ult) return(-1);
>> else return(strcmp(s,t));
>> }
>
> What if the strings are longer than an unsigned long and differ only in the
> last bit?

More importantly, what if they are shorter?

What if the compiler doesn't like the aliasing?

Also, this fails on x86 and elsewhere, because strings, if treated as numbers this way, are
big-endian.

"pembed2012" <> wrote in message
news:jjog0d$rcc$...

> int strcmp_fast(char* s,char* t){
> uls=(unsigned long*)s;
> ult=(unsigned long*)t;
> if(*uls>*ult) return(1);
> if(*uls<*ult) return(-1);
> else return(strcmp(s,t));
> }

That won't work well for various reasons already explained.

Try inventing a fast strcmp_eq() function instead; usually I only care about
equality, not whether one string is more or less than other.

That also means that endianness doesn't come into it so much. And if the
caller happens to have the string lengths already available, have a version
that makes use of that (which can be really fast when the lengths are
different).

However you'll have a job beating a good built-in strcmp(), unless you do
already have the lengths, to give you an edge.

--
Bartc

pembed2012 wrote:
> Dear friends
>
> I have created a more efficient strcmp function. However it only works on
> big endian architectures. I would like someone with same to run some
> timing tests to see how much is the speed up.
>
> Thank you
>
> int strcmp_fast(char* s,char* t){
> uls=(unsigned long*)s;
> ult=(unsigned long*)t;
> if(*uls>*ult) return(1);
> if(*uls<*ult) return(-1);
> else return(strcmp(s,t));
> }

This slightly modified version also works on a little-endian machine,
but I'm not sure if it's quite as fast as yours.

int strcmp_recursive(char* s,char* t){
if(!*s && *s==*t) return(0);
if(*s>*t) return(1);
if(*s<*t) return(-1);
return(strcmp_recursive(s+1,t+1));
}

On 03/14/2012 02:37 AM, Gareth Owen wrote:
> James Kuyper <> writes:
....
>> char strings[0] = "a\0a\0b";
>
> Typo:
>
> char strings[] = "a\0a\0b"; // mutable
> const char *strings = "a\0a\0b"; // immutable

Aiee! Where'd that first 0 come from? I don't remember typing it.
I meant my example to be mutable, since, for some reason, strcmp_fast()
takes char* arguments.
--
James Kuyper

On 13.03.2012 22:59, pembed2012 wrote:
> Dear friends
>
> I have created a more efficient strcmp function. However it only works on
> big endian architectures. I would like someone with same to run some
> timing tests to see how much is the speed up.
>
> Thank you
>
> int strcmp_fast(char* s,char* t){
> uls=(unsigned long*)s;
> ult=(unsigned long*)t;
> if(*uls>*ult) return(1);
> if(*uls<*ult) return(-1);
> else return(strcmp(s,t));
> }

A string (or at least a substring) may start at an odd address, and some
hardware architectures will fail if you try to cast this to a long...

Kaz Kylheku <> wrote:

> On 2012-03-13, pembed2012 <> wrote:
> > Dear friends
> >
> > I have created a more efficient strcmp function.
>
> Gee, thanks a lot.
>
> Now, you wouldn't happen to have a more efficient paper towel for wiping coffee
> spit from a monitor?

if your monitor is spitting coffee may i suggest perhaps your monitor is
actually a faulty coffee maker? in case it's not then microfiber rags work a
treat for that, ask me how i know

watching a dope get his arse handed to him by the pros here is one of the
best things about this newsgroup. high in content and amusement all at once.

On Tue, 13 Mar 2012 22:25:31 +0000, BartC saw fit to publish the
following:

> "Kleuske" <> wrote in message
> news:jjogv1$iqp$...
>> On Tue, 13 Mar 2012 21:59:41 +0000, pembed2012 saw fit to publish the
>> following:
>
>>> I have created a more efficient strcmp function. However it only works
>>> on big endian architectures. I would like someone with same to run
>>> some timing tests to see how much is the speed up.
>
>>> int strcmp_fast(char* s,char* t){
>>> uls=(unsigned long*)s;
>>> ult=(unsigned long*)t;
>>> if(*uls>*ult) return(1);
>>> if(*uls<*ult) return(-1);
>>> else return(strcmp(s,t));
>>> }
>>
>> What if the strings are longer than an unsigned long and differ only in
>> the
>> last bit?
>
> Or shorter.

Ouch!

.... I should have seen that ...

--
Murder is contrary to the laws of man and God.
-- M-5 Computer, "The Ultimate Computer", stardate 4731.3

Bl0ckeduser <> writes:

> pembed2012 wrote:
>> Dear friends
>>
>> I have created a more efficient strcmp function. However it only
>> works on big endian architectures. I would like someone with same to
>> run some timing tests to see how much is the speed up.
>>
>> Thank you
>>
>> int strcmp_fast(char* s,char* t){
>> uls=(unsigned long*)s;
>> ult=(unsigned long*)t;
>> if(*uls>*ult) return(1);
>> if(*uls<*ult) return(-1);
>> else return(strcmp(s,t));
>> }
>
> This slightly modified version also works on a little-endian machine,
> but I'm not sure if it's quite as fast as yours.
>
> int strcmp_recursive(char* s,char* t){
> if(!*s && *s==*t) return(0);
> if(*s>*t) return(1);
> if(*s<*t) return(-1);
> return(strcmp_recursive(s+1,t+1));
> }

You have made an important semantic change (not counting the
changes that allow termination and provide for returning 0
if the strings are equal). Do you see what it is? Hint:
this version of strcmp does not match the specification for
strcmp() in the standard library (even ignoring the 'const'
modifiers in strcmp()'s prototype).

By the way, 'return' statements don't need parentheses
around the return expression. The statements

return 0;
return strcmp_recursive( s+1, t+1 );

will work just fine.

Tim Rentsch wrote:
> You have made an important semantic change (not counting the
> changes that allow termination and provide for returning 0
> if the strings are equal). Do you see what it is? Hint:
> this version of strcmp does not match the specification for
> strcmp() in the standard library (even ignoring the 'const'
> modifiers in strcmp()'s prototype).

Hmm, I have to do the comparisons using the unsigned char type (or
perhaps another unsigned type, like the OP), right ?

> By the way, 'return' statements don't need parentheses
> around the return expression. The statements
>
> return 0;
> return strcmp_recursive( s+1, t+1 );
>
> will work just fine.

By the way, thanks for reviewing my code . As a hobbyist, it's always
a thrill to talk with experts.

On 14/03/12 3:29 AM, pembed2012 wrote:
> Dear friends
>
> I have created a more efficient strcmp function. However it only works on
> big endian architectures. I would like someone with same to run some
> timing tests to see how much is the speed up.
>
> Thank you
>
> int strcmp_fast(char* s,char* t){
> uls=(unsigned long*)s;
> ult=(unsigned long*)t;
> if(*uls>*ult) return(1);
> if(*uls<*ult) return(-1);
> else return(strcmp(s,t));
> }
Do you mean
int strcmp_fast(char* s,char* t){
unsigned long* uls=(unsigned long*)s;
unsigned long* ult=(unsigned long*)t;
if(*uls>*ult) return(1);
if(*uls<*ult) return(-1);
else return(strcmp(s,t));
}