Filling 64 bit numpy array in Cython slower than 32 bit array

Question

I am trying to understand why filling a 64 bit array is slower than filling a 32 bit array.

Here are the examples:

@cython.boundscheck(False)
@cython.wraparound(False)
def test32(long long int size):
   cdef np.ndarray[np.int32_t,ndim=1] index = np.zeros(size, np.int32)
   cdef Py_ssize_t i

   for i in range(size):
       index[i] = i

   return indx

@cython.boundscheck(False)
@cython.wraparound(False)
def test64(long long int size):
   cdef np.ndarray[np.int64_t,ndim=1] index = np.zeros(size, np.int64)
   cdef Py_ssize_t i

   for i in range(size):
       index[i] = i

   return indx

The timings:

In [4]: %timeit test32(1000000)
1000 loops, best of 3: 1.13 ms over loop

In [5]: %timeit test64(1000000)
100 loops, best of 3: 2.04 ms per loop

I am using a 64 bit computer and the Visual C++ for Python (9.0) compiler.

Edit:

Initializing a 64bit array and a 32bit array seems to be taking the same amount of time, which means the time difference is due to the filling process.

In [8]: %timeit np.zeros(1000000,'int32')
100000 loops, best of 3: 2.49 μs per loop

In [9]: %timeit np.zeros(1000000,'int64')
100000 loops, best of 3: 2.49 μs per loop

Edit2:

As DavidW points out, this behavior can be replicated with np.arange, which means that this is expected:

In [7]: %timeit np.arange(1000000,dtype='int32')
10 loops, best of 3: 1.22 ms per loop

In [8]: %timeit np.arange(1000000,dtype='int64')
10 loops, best of 3: 2.03 ms per loop

Answer 1

A quick set of measurements (which I initially posted in the comments) suggests that you see very similar behaviour (64 bits taking twice as long as 32 bits) for np.full, np.ones and np.arange, with all three showing similar times to each other (arange being about 10% slower than the other 2 for me).

I believe this suggests that this is expected behaviour and just the time it takes to fill the memory. (64 bits obviously has twice as much memory as 32 bits).

The interesting question is then why np.zeros is so uniform (and fast) - a complete answer is probably given in this C-based question but the basic summary is that allocating zeros (as done by the C function calloc) can be done lazily - i.e. it doesn't actually allocate or fill much until you actually try to write to the memory.