ATLAS via Cython vs. numpy: how is numpy faster? - arrays

Question

I am programming a function in Cython which will be called many times. The majority of my code is "Cython" syntax C with the numerical operations performed using the GNU Scientific Library (GSL).
One thing that has interested me is there that is one particular operation which I am incapable of matching numpy's speed on. Please note that the performance gain here is not that important, rather the reason why numpy appears to be faster is interesting me.
The particular operation I refer to is this (the random numbers are dummy variables - I do not anticipate they make a difference):
import numpy as np
x = np.array([1.,2.])
Q = np.random.random((1000))
W = np.random.random((1000,2))
b = np.random.random((1000))
Q.dot(np.cos(W.dot(x) + b))
Timing the last line:
%timeit Q.dot(np.cos(W.dot(x) + b))
10000 loops, best of 3: 27 µs per loop
Numpy's speed here does not surprise me particularly. What I am curious about is why my cython version is almost twice as slow. Assuming variables are similarly initialised outside of the function, I perform the calculation in cython as follows (edit: full working example at the end of this post - removed some of the code here for tidiness):
gsl_blas_dgemv(CblasNoTrans,1,W,x,1,b)
for 0 <= i < n:
b.data[i*step] = cos(b.data[i*step])
gsl_blas_ddot(Q,b,&result)
Producing:
10000 loops, best of 3: 52.8 µs per loop
When I run that part of the function in isolation.
Cython should be linked with Atlas (I am doing my testing in a notebook with -L/usr/lib64/atlas -ltatlas as flags after the cell magic %%cython), and has an -O3 optimisation flag.
My questions are as follows:
Is my problem algorithmic? To the best of my knowledge the loop over the dot product between W and x to compute the cosine of the elements is necessary.
Should row or column major ordering of the arrays make a significant difference in this case?
Is numpy that much faster simply due to a more efficient back-end for these kind of operations, and if so, how does it accomplish this?
Am I naive to think this is a good measure of performance?
Is my Cython version simply poorly coded?
I'm very interested in learning where the speed difference comes from in this case.
Edit 1: Complete example of cython code
%%cython -lgsl -L/usr/lib64/atlas -ltatlas -lm
import Cython.Compiler.Options as CO
CO.extra_compile_args = ["-f",'-O3',"-ffast-math","-march=native"]
from libc.string cimport memcpy
from libc.math cimport cos
from cython_gsl cimport *
cimport cython
cdef gsl_vector * gsl_vector_create(double[:] v, int n):
cdef gsl_vector *u = gsl_vector_alloc(n)
u.data = &v[0]
return u
cdef gsl_matrix * gsl_matrix_create(double[:,:] A, int n, int m):
cdef gsl_matrix * B = gsl_matrix_alloc(n,m)
B.data = &A[0,0]
return B
#cython.boundscheck(False)
#cython.wraparound(False)
#cython.cdivision(True)
#cython.nonecheck(False)
def test(double [:] x_, double[:] Q_, double[:,:] W_, double[:] b_, int d, int n):
cdef:
gsl_vector * x = gsl_vector_create(x_,d)
gsl_vector * Q = gsl_vector_create(Q_,n)
gsl_matrix * W = gsl_matrix_create(W_,n,d)
gsl_vector * b = gsl_vector_create(b_,n)
int i
gsl_blas_dgemv(CblasNoTrans,1,W,x,1,b)
cdef size_t step = b.stride
for 0 <= i < n:
b.data[i*step] = cos(b.data[i*step])
cdef double result
gsl_blas_ddot(Q,b,&result)
return result
Then in python:
x = np.array([1.,2.])
Q = np.random.random((1000))
W = np.random.random((1000,2))
b = np.random.random((1000))
%timeit Q.dot(np.cos(W.dot(x) + b))
%timeit test(x,Q,W,b,1000,2)
Edit 2
For the sake of completeness I have also tried compiling my cython function against GSL's Cblas. This is exactly the same as the above only with the cell magic flags
%%cython -lgsl -lgslcblas -lm
This is almost twice as slow as when compiled against atlas: 10000 loops, best of 3: 109 µs per loop.