multimap | This is a multimap implementation for Rust | Hashing library

You need to do this in the Reduce of the index:

Use valarray

Demo: https://wandbox.org/permlink/SAnHNKNZ0UufqZsN

Put it shortly, the benchmark is flawed.

perform multiple experiments to determine the minimum access time of each thread

The term "minimum access time" is unclear here. I assume you mean "latency". The thing is your benchmark does not measure the latency. volatile tell to the compiler to read store data from the memory hierarchy. The processor is free to store the value in its cache and x86-64 processors actually do that (like almost all modern processors).

How do OMP_PLACES and OMP_PROC_BIND work?

You can find the documentation of both here and there. Put it shortly, I strongly advise you to set OMP_PROC_BIND=TRUE and OMP_PLACES="{0},{1},{2},..." based on the values retrieved from hw-loc. More specifically, you can get this from hwloc-calc which is a really great tool (consider using --li --po, and PU, not CORE because this is what OpenMP runtimes expect). For example you can query the PU identifiers of a given NUMA node. Note that some machines have very weird non-linear OS PU numbering and OpenMP runtimes sometimes fail to map the threads correctly. IOMP (OpenMP runtime of ICC) should use hw-loc internally but I found some bugs in the past related to that. To check the mapping is correct, I advise you to use hwloc-ps. Note that OMP_PLACES=cores does not guarantee that threads are not migrating from one core to another (even one on a different NUMA node) except if OMP_PROC_BIND=TRUE is set (or a similar setting). Note that you can also use numactl so to control the NUMA policies of your process. For example, you can tell to the OS not to use a given NUMA node or to interleave the allocations. The first touch policy is not the only one and may not be the default one on all platforms (on some Linux platforms, the OS can move the pages between the NUMA nodes so to improve locality).

Why is the above happening?

The code takes 4.38 ms to read 50 MiB in memory in each threads. This means 1200 MiB read from the node 0 assuming the first touch policy is applied. Thus the throughout should be about 267 GiB/s. While this seems fine at first glance, this is a pretty big throughput for such a processor especially assuming only 1 NUMA node is used. This is certainly because part of the fetches are done from the L3 cache and not the RAM. Indeed, the cache can partially hold a part of the array and certainly does resulting in faster fetches thanks to the cache associativity and good cache policy. This is especially true as the cache lines are not invalidated since the array is only read. I advise you to use a significantly bigger array to prevent this complex effect happening.

You certainly expect one NUMA node to have a smaller throughput due to remote NUMA memory access. This is not always true in practice. In fact, this is often wrong on modern 2-socket systems since the socket interconnect is often not a limiting factor (this is the main source of throughput slowdown on NUMA systems).

NUMA effect arise on modern platform because of unbalanced NUMA memory node saturation and non-uniform latency. The former is not a problem in your application since all the PUs use the same NUMA memory node. The later is not a problem either because of the linear memory access pattern, CPU caches and hardware prefetchers : the latency should be completely hidden.

Even more puzzling are the following environments and their outputs

Using 26 threads on a 24 core machine means that 4 threads have to be executed on two cores. The thing is hyper-threading should not help much in such a case. As a result, multiple threads sharing the same core will be slowed down. Because IOMP certainly pin thread to cores and the unbalanced workload, 4 threads will be about twice slower.

Having 48 threads cause all the threads to be slower because of a twice bigger workload.

Thanks everyone for the replies. I got it solved with help from fCaponetto.

TypeScript doesn't have variadic generics, so there's no way to write something like MultiMap<...K, V> meaning that there is some arbitrary number of key type parameters and one value type parameter. But, as you note, there are tuple types which can hold an arbitrary ordered list of types, so you might be satisfied with MultiMap where the K is a tuple. So instead of MultiMap you'd write MultiMap<[Coat, Pie, Date], Location>. It's just a few more characters anyway.

As for making MultiMap<[Coat, Pie, Date], Location> resolve to Map>>, we can do that by defining MultiMap as a recursive conditional type where we use variadic tuple types to pull apart the K tuple into its first element F and the rest of the tuple R:

Like others said, you're

• missing a hash implementation
• using a pretty inefficient key type

I'd simplify on both accounts:

Live On Compiler Explorer

Use the Map view:

all the _id columns have the same index there. Is there a chance to do something here?

Yes, use unique column names e.g.

UPDATE

You're using an old version of that library. Use v0.6.1 or higher: https://github.com/nekipelov/redisclient/pull/53

All executor interfaces have been upgraded a (long) while ago.

Strands used to be nested typedefs (and there is still one for "legacy" compatibility in io_service if that is enabled).

However, the new type succeeding is is boost::asio::strand (so e.g. boost::asio::io_context::executor_type). You can easily make a strand for any executor, e.g.: