icpc | Using Java with IntelliJ IDEA

Do you see cxx11 in the linker errors? It looks like your libcall_ts_cpp is compiled in a way that expects the new C++11 ABI for std::string but perhaps the library where those functions are implemented was compiled with the old ABI. Here's a PyTorch forum post about the same problem: https://discuss.pytorch.org/t/issues-linking-with-libtorch-c-11-abi/29510/11

The solution is to download a new copy of the PyTorch libraries built with the new C++11 ABI.

My question is whether it is always a good practice to remove sizes on inlining and inline as much as possible?

No, it is not always a good pratice to remove size limits on inlining nor to inline as much as possible.

Ideally, inlining should be done only when it improves performance.

Are there situations at all where imposing an inlining limit is useful?

If a function is very large, and it is called from many contexts, then inlining such function to all of those contexts will bloat the executable. If the executable itself is let's say several gigabytes because of inlining, then loading the program from the disk may become the bottleneck.

In less pathological cases, the trade-offs are more subtle. The way to find out optimal limits is measurement. Profile guided optimisation can give the optimiser more useful heuristics than simple hard limits.

I can't see where your code goes wrong, but I can suggest a few improvements to improve clarity (and speed).

First, you are using a single list argument where the content has a rather peculiar form: either it's [maximum, rest in ascending order ...] or [minimum, rest in descending order ...]. This makes the code a bit hard to read, and I would suggest to split the maximum/minimum into a separate argument.

Second, you should always start coding a function by writing the intended type. If you don't, and make a mistake, GHC will often infer a type which you did not expect. This will cause type errors much later on in the code, making them hard to fix, or produce error messages which are harder to understand.

Third, you are reversing the list too many times. Reversing is an O(n) operation, so we should try to avoid using it frequently. Fortunately, we can just reverse once in the whole program.

I believe you are looking for these warning flags:

-Wconversion -Warith-conversion

Run the command in the Terminal

In

The problem is not related to a compiler but to the implementation of the C++ Standard Library it works with. For instance, on Linux systems, Intel icpc typically uses system-installed libstdc++. Note that the support for std::void_t was added into libstdc++ in version 6.1.

While icpc on Godbold uses libstdc++ version 8, your system likely have some older version installed without the support for std::void_t.

The line schedule(dynamic, num_threads) is likely to cause scalability issues.

Indeed, with a matrix of size 1700 and 64 threads, the chunk size of the dynamic schedule policy is 64. Thus, the number of chunks is floor(1700/64) = 26 which is far too small to feed the 64 threads! Even with 32 threads, the work balancing is not very good. I think it is important to have at least 3-4 chunk per thread.

Increasing the granularity with the number of thread is weird. It is probably more relevant to set a granularity based on the input size. I advise to use either the schedule(guided) or schedule(dynamic,chunksize) with chunksize set to something like max(F_matrix_A.size() / (num_threads * 4), 1) (although using schedule(dynamic,1) should not be so bad if you do not add the collapse).

Alternatively, you can use task and taskloops directives.

Also note that if you work on a machine with multiple NUMA nodes (this is probably the case since there are 64 cores), you should be very careful with a dynamic scheduling because threads may access to remote NUMA memory nodes decreasing significantly the performances (this is clearly something you do not want in your memory-bound code).

Update: you can work on the two vertical side of the array simultaneously to significantly reduce the variability of the inner-loop computation time. The result would be something like that:

I think you should write: