unroll | a public transport route explorer | Map library

You should be able to do this using bitwise OR, XOR, shifts and integer multiplication. I assume your variables are all __s32 or __u32, cast them to __u64 before proceeding to avoid problems (otherwise cast every operand of the multiplications below to __u64).

Clearly a != b can become a ^ b. The && is a bit trickier, but can be translated into a multiplication (where if any operand is 0 the result is 0). The first part of your condition then becomes:

For concreteness and brevity I will specify your types slightly differently from in your external links:

HotSpot JVM can inline up to two different targets of a virtual call, for more receivers there will be a call via vtable/itable [1].

To force inlining of more receivers, you may try to devirtualize the call manually, e.g.

You can do this with a template, but you've got the wrong syntax. It should be:

You cannot define preprocessing directives the way you show in the question.

Yet you may be able to use the _Pragma operator for your purpose:

You might be sieving, but what about counting? And a upper limit, so one can compare? And OMP like primesieve?

You are stuck because you are not even counting or comparing, only with yourself.

I made a segmented sieve just with a 30Kb char array. At 2 billion, it takes quite exactly 3 times as long as primesieve, and works with OMP. So all your bit mapping and unrolling is not measurable.

It's auto-vectorizing as well as unrolling, which is a performance win for large arrays (or would be if clang had less overhead), at least on Intel CPUs where popcnt is 1/clock, so 64 bits per clock. (AMD Zen has 3 or 4/clock popcnt, so with add instructions taking an equal amount of the 4 scalar-integer ALU ports, it could sustain 2/clock uint64_t popcnt+load and add.) https://uops.info/

But vpshufb is also 1/clock on Intel (or 2/clock on Ice Lake), and if it's the bottleneck that's 128 bits of popcount work per clock. (Doing table lookups for the low 4 bits of each of 32 bytes.) But it's certainly not going to be that good, with all the extra shuffling it's doing inside the loop. :/

This vectorization loses on Zen1 where the SIMD ALUs are only 256 bits wide, but should be a significant win on Intel, and maybe a win on Zen2 and later.

But looks like clang widens to 32-bit counts inside the inner loop with vpsadbw, so it's not as good as it could be. 1024x uint64_t is 256 __m256i vectors of input data, and clang is unrolling by 4 so the max count in any one element is only 64, which can't overflow.

Clang is unrolling a surprising amount, given how much work it does. The vextracti128 and vpackusdw don't make much sense to me, IDK why it would do that inside the loop. The simple way to vectorize without overflow risk is just vpsadbw -> vpaddq or vpaddd, and it's already using vpsadbw for horizontal byte sums within 8-byte chunks. (A better way is to defer that until just before the byte elements could overflow, so do a few vpaddb. Like in How to count character occurrences using SIMD, although the byte counters are only incremented by 0 or 1 there, rather than 0 .. 8)

See Counting 1 bits (population count) on large data using AVX-512 or AVX-2, especially Wojciech Muła's big-array popcnt functions: https://github.com/WojciechMula/sse-popcount/ - clang is using the same strategy as popcnt_AVX2_lookup but with a much less efficient way to accumulate the results across iterations.

On GCC, ICC and Clang, omp simd impacts the auto-vectorization optimization step (by providing meta information to loops). However, the step is only enabled if optimization are enabled. Thus, the pragma annotation is simply ignored with -O0 for the three compiler. This is an expected behaviour. Here is the result you can get from the three compilers.

Some compilers enable the auto-vectorization in -O2 (ICC) while some does that in -O3 (GCC and probably Clang). Because -On (with n an integer) is just a set of well defined optimizations (which changes from one compiler to another). You can specify the optimization flags required to vectorize the loop (e.g. -ftree-vectorize for GCC). While this tends to be better if you use one specific compiler (more deterministic and finer grained control), this is not great for portability (options are not the same for all compilers and may change between versions).

Moreover, note that you should not forget to use the -fopenmp-simd for GCC/Clang and -qopenmp-simd for ICC. It is especially important for Clang. Note also that k_index = 0 is needed in the loop.

Finally, compilers tends not to use AVX, AVX2 and AVX-512 instructions on x86/x86-64 platforms by default because it is not available on all processors (instead old SSE instructions are used). Using for example -mavx/-mavx2 enable GCC/Clang to generate wider SIMD instruction (that are often faster). Using -march=native is better if you do plan not to distribute the generated binaries nor to execute them on another machine (otherwise the generated binary can simply crash if instructions are unsupported on the target machine). Alternatively you can specify a specific architecture like -march=skylake. ICC has similar options/flags.

With all of that, Clang, GCC and ICC are able to generate a proper SIMD implementation (see here for the generated code).

The SimpleRNN layer (same holds for the LSTM and GRU layers, and also using RNN along with the respective Cell classes) does not include an output transformation. You can actually kinda guess it by the fact that the summary lists an output shape of 128 units (the state size). It only computes the state sequence.

The number of parameters is thus simply 128*128 + 60*128 + 128 = 24192 (hidden-to-hidden matrix, input-to-hidden matrix, bias).