numba | numba provides functions to convert integers | Code Quality library

There are several problems to handle: first, you've commented out the @jit decorator of your first function, stopF_w.

If you uncomment it, you'll resolve your current error. Unfortunately, you will immediately run into several other errors. if your numba version is up to date, you'll see an error pertaining to "reflected lists".

Basically, your inputs b_wi and f_wi are lists of variable length lists, which cannot be converted into uniform numpy arrays. E.g.: if instead of [[1,2,3,4],[6,7,8,9,10,11]], if b_wi was something like [[1,2,3, 4, 6], [7, 8, 9, 10, 11]] (easily convertible to an array of shape (2, 5) then it would work without any problems. To get your variable length lists to work with numba, you need to rely on a Typed List, which is a bit cumbersome.

I solved the issue by modifiying the code by Jacques Gaudin in https://stackoverflow.com/a/49732825/3925704 to:

Flawr is correct. B[..., k] returns a np.view() into B, but does not actually copy any data. In memory, two neighbouring elements of the view have a distance of B.strides[1], which evaluates to B.shape[-1]*B.itemsize and is greater than B.itemsize. Consequentially, your array is not contiguous.

The best optimization is to vectorize the dotplus loop and write

Conditionals are slow. You should avoid them as much as possible. Also Numpy vectorization and Numba JIT help to speed up such a code by a large margin. Here is an untested example:

There are a few things missing to get the SIMD vectorization working. For maximum performance it is also necessary to avoid costly temporary arrays, which may not be optimized away if you use a partly vectorized function.

• Function calls have to be inlined
• The memory access pattern must be known at compile time. In the following example this is done with assert vectors.shape[2]==2. Generally the shape of the last array could also be larger than two, which would be much more complicated to SIMD-vectorize.
• Division by zero checks can also avoid SIMD-vectorization, and are slow if they are not optimized away. I do this manually by calculating div_pi=1/np.pi once and than a simple multiplication inside the loop. If a repeated division is not avoidable you can use error_model="numpy" to avoid the division by zero check.

Example

The biggest issue is the fact that you are measuring the first execution of build_params_numba, which includes the compilation (it is compiled Just-In-Time, just as you requested). This is like measuring the time-to-dinner between a classic meal and a microwave meal, but you're including the time to buy and install a microwave oven as part of the latter. Measure the second invocation of build_params_numba, when the compilation has been already completed, to see how the compiled function performs.

The second issue is that numba might not be of much help with your code. AFAIK it is designed to speed up numerical algorithms and numpy code. By necessity, namedtuple and dict are Python data structures and numba has to treat them as such; so even though you requested nopython mode, Numba cannot oblige, as it only works when a native data type can be detected for all values in your code (I think — not 100% sure on this point though).

What is the complexity of your algorithm of finding the longest increasing subsequence?

This article provides an algorithm with the complexity of O(n log n). Upd: doesn't work. You don't even need to modify the code, because in python comparison works for tuples: assert (1, 2) < (3, 4)

The error you get has nothing to do with None and typing. It is due to self.sources in the member function sources not being declared nor initialized while self._sources is and should be used instead.

Note Numba actually supports None values using optional types. You can find more information in the Numba documentation.

You are correct that those slice operators are not supported on the device in Numba. The underlying problem is that slice operation requires an intermediate array construction and the Numba compiler currently can't do that.

There are probably two alternative ways to do this:

1. Use a single thread to copy a row of the data between the source and destination (numba_gpu1 shown below)
2. Use a single block to copy a row of the data between the source and destination. This can exploit a strided loop design pattern which improves memory coalescing and cache coherency and should perform better at non-trivial sizes (numba_gpu2 shown below for row major ordered data).

In from numba import cuda import numpy as np