Why is it faster to perform float by float matrix multiplication compared to int by int?

Question

Having two int matrices A and B, with more than 1000 rows and 10K columns, I often need to convert them to float matrices to gain speedup (4x or more).

I'm wondering why is this the case? I realize that there is a lot of optimization and vectorizations such as AVX, etc going on with float matrix multiplication. But yet, there are instructions such AVX2, for integers (if I'm not mistaken). And, can't one make use of SSE and AVX for integers?

Why isn't there a heuristic underneath matrix algebra libraries such as Numpy or Eigen to capture this and perform integer matrix multiplication faster just like float?

About accepted answer: While @sascha's answer is very informative and relevant, @chatz's answer is the actual reason why the int by int multiplication is slow irrespective of whether BLAS integer matrix operations exist.

Answer 1

If you compile these two simple functions which essentially just calculate a product (using the Eigen library)

#include <Eigen/Core>  int mult_int(const Eigen::MatrixXi& A, Eigen::MatrixXi& B) {     Eigen::MatrixXi C= A*B;     return C(0,0); }  int mult_float(const Eigen::MatrixXf& A, Eigen::MatrixXf& B) {     Eigen::MatrixXf C= A*B;     return C(0,0); } 

using the flags -mavx2 -S -O3 you will see very similar assembler code, for the integer and the float version. The main difference however is that vpmulld has 2-3 times the latency and just 1/2 or 1/4 the throughput of vmulps. (On recent Intel architectures)

Reference: Intel Intrinsics Guide, "Throughput" means the reciprocal throughput, i.e., how many clock-cycles are used per operation, if no latency happens (somewhat simplified).