www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - quick question, probably of little importance...

reply WhatMeWorry <kheaser gmail.com> writes:
I just need an even/odd functionality. Don't think D has a 
built-in operator.

// Found this C code online.

     int isEven(int num)
     {
         return !(num & 1);
     }

// found this in std.functional.unaryFun

alias isEven = unaryFun!("(a & 1) == 0");
assert(isEven(2) && !isEven(1));

If interested just in speed, is either one faster?
Apr 26 2023
parent reply "Richard (Rikki) Andrew Cattermole" <richard cattermole.co.nz> writes:
Don't forget ``num % 2 == 0``.

None should matter, pretty much all production compilers within the last 
30 years should recognize all forms of this and do the right thing.
Apr 26 2023
parent reply WhatMeWorry <kheaser gmail.com> writes:
On Wednesday, 26 April 2023 at 23:02:07 UTC, Richard (Rikki) 
Andrew Cattermole wrote:

 Don't forget ``num % 2 == 0``.

 None should matter, pretty much all production compilers within 
 the last 30 years should recognize all forms of this and do the 
 right thing.


Thanks. Fastest reply ever! And I believe across the world?   I 
suppose my examples required overhead of a function call. So 
maybe num % 2 == 0 is fastest?
Apr 26 2023
next sibling parent "H. S. Teoh" <hsteoh qfbox.info> writes:
On Wed, Apr 26, 2023 at 11:07:39PM +0000, WhatMeWorry via Digitalmars-d-learn
wrote:

 On Wednesday, 26 April 2023 at 23:02:07 UTC, Richard (Rikki) Andrew
 Cattermole wrote:

 Don't forget ``num % 2 == 0``.
 
 None should matter, pretty much all production compilers within the
 last 30 years should recognize all forms of this and do the right
 thing.


 
 Thanks. Fastest reply ever! And I believe across the world?   I
 suppose my examples required overhead of a function call. So maybe num
 % 2 == 0 is fastest?


If performance matters, you'd be using an optimizing compiler. And
unless you're hiding your function implementation behind a .di, almost
all optimizing compilers would inline it, so you shouldn't even be able
to tell the difference.


T

-- 
Without outlines, life would be pointless.
Apr 26 2023
prev sibling next sibling parent "Richard (Rikki) Andrew Cattermole" <richard cattermole.co.nz> writes:
On 27/04/2023 11:07 AM, WhatMeWorry wrote:

 On Wednesday, 26 April 2023 at 23:02:07 UTC, Richard (Rikki) Andrew 
 Cattermole wrote:

 Don't forget ``num % 2 == 0``.

 None should matter, pretty much all production compilers within the 
 last 30 years should recognize all forms of this and do the right thing.


 
 Thanks. Fastest reply ever! And I believe across the world?   I suppose 
 my examples required overhead of a function call. So maybe num % 2 == 0 
 is fastest?


Indeed, all the way from New Zealand.

I wouldn't bother timing this. A compiler will rewrite it and emit 
whatever instructions it thinks is best for a given cpu target that you 
select. This is one of those things that was solved 30 years ago :)
Apr 26 2023
prev sibling parent reply Cecil Ward <cecil cecilward.com> writes:
On Wednesday, 26 April 2023 at 23:07:39 UTC, WhatMeWorry wrote:

 On Wednesday, 26 April 2023 at 23:02:07 UTC, Richard (Rikki) 
 Andrew Cattermole wrote:

 Don't forget ``num % 2 == 0``.

 None should matter, pretty much all production compilers 
 within the last 30 years should recognize all forms of this 
 and do the right thing.


 Thanks. Fastest reply ever! And I believe across the world?   I 
 suppose my examples required overhead of a function call. So 
 maybe num % 2 == 0 is fastest?


I made a small change, making the retval a bool rather than an 
int. I got slightly better code generation with the int, as it 
seems that some of the compilers have not yet got all the good 
tricks they should be using when manipulating bool-typed 
expressions and also it can be one extra instruction converting 
values to bool strictly zero or one, not zero or any non-zero 
value. Here’s the D, enlarged a little so that we can see your 
routine in action, inlined. Your isEven boils down to two 
instructions with a seriously optimising compiler. I’ve included 
the x86-64 machine code generated by the GDC and LDC compilers so 
you can see how fast it is. GDC made a bit of a dog’s breakfast 
of my longer routine whereas LDC performed superbly. GDC 
generated twice as much code, but its excellent instruction 
scheduler and what looks like an awareness of ILP mean that the 
two streams of instructions will be carried out in parallel  so 
the two streams will only take three instruction times - ie 
whatever the total time is for those three instruction in the one 
stream - not six.

bool isEven( int num )
	{
	return ! ( num & 1 );
	}

bool AreBothEven( int a, int b )  // returns true if both 
arguments are even
	{
	return isEven( a )  &&  isEven( b );
	}

===
Compiler output:: GDC:: x86-64: -O3 -mcpu=native -frelease

bool isEven( int ):
	mov 	eax, edi
	not		eax
	and	        eax, 1
	ret

bool AreBothEven( int, int ):
	mov 	eax, edi
	not		esi
	not 	        eax
	and	        esi, 1
	and	        eax, 1
	cmovne  eax, esi
	ret

===
Compiler LDC: x86-64: -O3 -mcpu=native -release

bool isEven( int ):
	test	        dil, 1
	sete	al
	ret

bool AreBothEven( int, int ):
	or		edi, esi
	test	        dil, 1
	sete 	al
	ret
Apr 30 2023
parent Cecil Ward <cecil cecilward.com> writes:
On Monday, 1 May 2023 at 03:53:24 UTC, Cecil Ward wrote:

 On Wednesday, 26 April 2023 at 23:07:39 UTC, WhatMeWorry wrote:

 [...]




Correction: I can’t count. There are only two instructions in 
parallel with another pair running alongside, not three. The 
first reg, reg move counts as zero cycles, so the total time is 
just the sum of the following three instructions’ times, ignoring 
the other parallel stream.
Apr 30 2023