bitwise | Erlang NIF examples for showing Erlang scheduler issues | Authentication library

Despite appearances, bitand(d, e) is not invoking a function named bitand and passing it the arguments d and e. bitand is just another way of spelling &.

So your code is actually identical to &(d, e). & isn't a function, so what's the comma doing here? It is the lesser-known built-in comma operator. It evaluates and discards the first argument, then evaluates and returns the second argument. So (d, e) is the same as e, and your code boils down to &e.

So despite the code saying bitand, there's no bitwise and happening here. It's acting as the unary address-of operator and returning a pointer that points to e. That's why you have to dereference it with unary *, and why the value after dereferencing is 37 not 4.

As an aside, if you're using clang or gcc, if you enable -Wunused (which is included in -Wall), the compiler will issue a warning that you're discarding a value with no effect, like so:

I have 6 sets of code for 16, 32, 64 bit crc, non-reflected and reflected here. The code is setup for Visual Studio. Comments have been added to the constants which were missing from Intel's github site.

https://github.com/jeffareid/crc

32 bit non-relfected is here:

https://github.com/jeffareid/crc/tree/master/crc32f

You'll need to change the polynomial in crc32fg.cpp, which generates the constants. The polynomial you want is actually:

Code readability, short-circuiting and it is not guaranteed that Ord will always outperform a || operand. Computer systems are more complicated than expected, even though they are man-made.

There was a case where a for loop with a much more complicated condition ran faster on an IBM. The CPU didn't cool and thus instructions were executed faster, that was a possible reason. What I am trying to say, focus on other areas to improve code than fighting small-cases which will differ depending on the CPU and the boolean evaluation (compiler optimizations).

You can cleverly combine a vpcmpeqq with a vptest:

These kinds of questions can be solved by considering each bit separately.

For each bit, let n0 be the number of array elements that have that bit set to 0, and let n1 be the number of elements that have that bit set to 1.

Then it's easy to determine whether or not that bit is set in the answer:

• The number of pairs i,j such that the bit is set in A[i]|A[j] is n1*n1 + n1*n0*2
• The number of triplets i,j,k with that bit set in F(i,j,k) is then n1*(n1*n1 + n1*n0*2)
• Since all the F's are XORed together, the result will have the bit set if it's set in an odd number of triplets, i.e., if the above expression evaluates to an odd number.

At this point, we could easily solve the problem by counting the 1s and 0s for each bit, but notice that n1*(n1*n1 + n1*n0*2) evaluates to an odd number exactly when n1 is odd, i.e., when the bit appears an odd number of times in the array. To get a number with each bit set if it's set an odd number of times in the array...

just XOR all the array elements together.

Just use the loop one ordinarily uses with compare-and-exchange, but instead of looping until the (new) expected value matches, loop either until it matches (and the store happens) or it equals the value in your != expected condition, since that’s the case in which you needn’t do anything. (Obviously don’t make the initial value be that “unless” value so that you can’t “succeed” the first time.)

AVX implies availability of SSE4.1 pcmpeqq is available, in that case you should just use _mm_cmpeq_epi64.

FP compares treat NaN != NaN, and -0.0 == +0.0, and if DAZ is set in MXCSR, treat any small integer as zero. (Because exponent = 0 means it represents a denormal, and Denormals-Are-Zero mode treats them as exactly zero on input to avoid possible speed penalties for any operations on any microarchitecture, including for compares. IIRC, modern microarchitectures don't have a penalty for subnormal inputs to compares, but do still for some other operations. In any case, programs built with -ffast-math set FTZ and DAZ for the main thread on startup.)

So FP compares are not really usable for integers unless you know that some but not all of bits [62:52] (inclusive) will be set.

It's much to use pcmpeqd (_mm_cmpeq_epi32) than to hack up some FP bit-manipulation. (Although @chtz suggested in comments you could do 42.0 == (42.0 ^ (a^b)) with xorpd, as long as the compiler doesn't optimize away the constant and compare against 0.0. That's a GCC bug without -ffast-math).

If you want a condition like at-least-one-match then you need to make sure both halves of a 64-bit element matched, like mask & (mask<<1) on a movmskps result, which can compile to lea / test. (You could mask & (mask<<4) on a pmovmskb result, but that's slightly less efficient because LEA copy-and-shift can only shift by 0..3.)

Of course "all-matched" doesn't care about element sizes so you can just use _mm_movemask_epi8 on any compare result, and check it against 0xFFFF.

If you want to use it for a blend with and/andnot/or, you can pshufd / pand to swap halves within 64-bit elements. (If you were feeding pblendvb or blendvpd, that would mean SSE4.1 was available so you should have used pcmpeqq.)

The more expensive one to emulate is SSE4.2 pcmpgtq, although I think GCC and/or clang do know how to emulate it when auto-vectorizing.

Split the enum class into an enum and a class (or struct for convenience).

Try with sum and clip: