srandom | FASTEST /dev/urandom PRNG | Runtime Evironment library

The key bottleneck is the load-use latency of cache misses while striding through tex[], as part of the dependency chain from old i to new i. Lookups from the small rand_array[] will hit in cache and just add about 5 cycles of L1d load-use latency to the loop-carried dependency chain, making it even more unlikely for anything other than latency through i to be relevant to the overall speed of the loop. (Jérôme Richard's answer on your previous question discusses that latency dep chain and the random stride increment.)

memcmp(tex+i, str, SLen) might be acting as prefetching if tex+i is near the end of a cache line. If you compiled with -O0, you're calling glibc memcmp so the SSE 16-byte or AVX2 32-byte load done in glibc memcmp crosses a cache-line boundary and pulls in the next line. (IIRC, glibc memcmp checks and avoids page crossing, but not cache-line splits, because those are relatively cheap on modern CPUs. Single-step into it to see. Into the 2nd call to avoid lazy dynamic linking, or compile with -fno-plt).

Possibly touching some cache lines that would have been skipped by the random stride helps HW prefetch be more aggressive and detect it as a sequential access pattern. A 32-byte AVX load is half a cache line, so it's fairly likely to cross into the next one.

So a more-predictable sequence of cache-line requests seen by the L2 cache is a plausible explanation for the memcmp version being faster. (Intel CPUs put the main prefetchers in the L2.)

If you compile with optimization, that 10-byte memcmp inlines and in the inner loop only touches 8 bytes. (If they match, then it jumps to another block where it checks the last 2. But it's exceedingly unlikely that ever happens).

This might be why -O0 is faster than -O3 on my system, with GCC11.1 on i7-6700k Skylake with DDR4-2666 DRAM, on Arch GNU/Linux. (Your question didn't bother to specify which compiler and options your numbers were from, or which hardware.)

There are a couple of things that could be causing this:

1. If you're timing your code, you should have:

Associative arrays allow arbitrary strings as indices. Here, I also took the liberty to change your 2nd loop to (( i=ug; i<=og; i++ )), which seemed more reasonable.

Your target may not have dedicated hardware for encryption, and you therefore may not have any openssl crypto-engine implementation available on your platform, nor a version of openssl compiled with support for crypto-engines.

You can check by executing ls: /usr/lib/engines-1.1, since this is the location specified in the output for the openssl version -a command you executed. If no dynamic libraries are present, or the directory does not exist, this is likely that you don't have any support for crypto-engines currently available on your system.

In this case, you will have to re-build mosquitto with the CFLAGS=-DOPENSSL_NO_ENGINE option, so that mosquitto will not attempt to load any (non-existing) openssl crypto-engine at startup.

RANDOM (16-bit) vs SRANDOM (32-bit); 32-bit => much bigger random numbers (ie, more random numbers).

As for the randomness of the 2x variables ...

Try running:

That block of script code sets the variable SHUF to the program you should use to shuffle a file. Either it will be the system's shuf program or your teacher's shuffle program.

After the code is done, you can use $SHUF to run whichever program was found.