Weird behavior of Intel's MKL and Python (Ubuntu 16.04, Conda 4.3.30)

Question

I am trying to improve the performance of NumPy in Python 3.6 using Intel's MKL. With a fresh anaconda installation i created a MKL environment using:

conda create -n idp intelpython3_core python=3

As written in this article, it seems that the MKL has internal thresholds to decide whether to use threading or not. It seems one of these thresholds is given by the vector size used in the calculations (kind of obvious). This threshold is set to a vector size of 8192 (at least for my machine). When vectors exceed this size, i can observe my python scripts using 4 threads (i have 2 cores with hyper threading) for calculations like:

import numpy as np
x = np.random.rand(8193)
y = np.sin(x)

So far everything is working as intended.

Beside the threading part, MKL "Features highly optimized, threaded, and vectorized math functions that maximize performance on each processor family" (read here). Since the problems i'm usually working on do not exceed the vector size threshold, i'm not interested in the performance increase which is obtained by threading, but more in the optimized math functions of MKL. Unfortunately it seems like those are only used, when the vector size is above the threshold.

I've written a sample code to measure the performance of the sine operation on vectors with different sizes:

from timeit import default_timer as timer
import mkl
import numpy as np

mkl.set_num_threads(1)
print("MKL threads:%i" % mkl.get_max_threads())

np.random.seed(0)
Nop = int(1e4)

def func(x):    
    return np.sin(x)  

def measure(x):
    t1 = timer()
    for i in range(0, Nop):
        func(x)    
    t2 = timer()
    diff = (t2 - t1)*1000.0
    print("vec size: %i:" % len(x), end="")
    print("\t time needed: %f ms" % diff)


x0 = np.random.rand(20000)

measure(np.array(x0[:8192]))
measure(np.array(x0[:8193]))
measure(np.array(x0[:8192]))

These lines:

import mkl
mkl.set_num_threads(1)
print("MKL threads:%i" % mkl.get_max_threads())

are just there to make sure, that the increase in performance is not due to threading (i also checked the CPU usage, it is indeed only using one thread)

I get these results:

vec size: 8192:  time needed: 8185.900477 ms
vec size: 8193:  time needed: 436.843237 ms
vec size: 8192:  time needed: 1777.306942 ms

As you can see, the 8193-vector runs roughly 20x faster than the 8192-vector. What is even more confusing is the fact, that the second run of the 8193-vector is 4x faster then before, after doing the calculation on the bigger vector.

Now my questions:

Am i doing anything obviously wrong, which i am not aware of, which leads to these results?
Can anyone reproduce these results or is it just my installation/my machine behaving like this
Is the increase in performance really due to the optimized implementation of sine?
Is it possible to enforce always using the optimized version of sine independent of the vector size?

PS: I actually tried the following in the simulation i'm running for my master thesis, which involve a lot of sine and cosine function calls: Just added this line before anything else is calculated:

np.sin(np.zeros(8193))

And now everything runs 50% faster.

Weird behavior of Intel's MKL and Python (Ubuntu 16.04, Conda 4.3.30)

0 Answers0