ktrianta/jacobi-svd-evd

jacobi-svd-evd's Issues

Experiment with different input sizes

Currently we measure the performance of our codes on input sizes that are powers of 2.

Experiment with a bigger variety of input sizes. Block size (in blocking codes) should be set accordingly, i.e. such that the input size is a multiple of the block size.

Intel intrinsics scatter and gather operations

These operations could prove beneficial in cases where we load/store elements from/to non-contiguous memory addresses. AVX2 supports gather (but not scatter) instructions.

More information:
Gather operations in Intel intrinsics guide
Stackoverflow: What do you do without fast gather and scatter in AVX2 instructions?

SVD Blocking without copying

We can try to implement the blocked version of SVD without explicitly creating the intermediate matrices, thereby reducing the overall data movement and possibly increasing the performance.

Experiment with different compilers

Currently we are compiling our code with gcc. Experiment by using icc and clang.
Another area of experimentation could be to try different optimization flags.

Autotuning

Create an autotuning infrastructure that aids us in finding the optimal block size for our codes and benchmarks.

Use -Werror and fix all compiler warnings

Lots of compiler warnings are emitted during compilation. To make sure we address these, we can use -Werror to fail the compilation until all of them are fixed.

Use aligned memory allocator functions for EVD and SVD

https://stackoverflow.com/questions/8456236/how-is-a-vectors-data-aligned/45833474#45833474

Git hooks

We need to incorporate git hooks into the project to automatically format the committed codes, and possibly lint the code (maybe cpplint ?).

Highly optimized block matrix multiplication

Blocked algorithms employ block matrix multiplications. To get the highest performance, we need to optimize the block matrix multiplication algorithms as much as possible. Furthermore, block based algorithms also do block matrix additions. We probably need to create a separate version of block matrix multiplication that performs C = C + AB. Consequently, we need two algorithms

• block matrix multiplication that performs C = AB
• block matrix multiplication that performs C = C + AB.

The code for both should be pretty much the same.

Runtime Profiling of blocked and vectorized algorithms with gprof

Performance analysis - Roofline model

Create roofline models for our codes and compare the expected performance with the one actually achieved.

Vectorizing Frobineus norm, transpose function, etc.

Try to unroll and vectorize all possible remanining auxiliary operations