LineProfiler | Line-based Python profiling plugin for Sublime Text | Code Editor library

In fact it's likely impossible to really improve the performance of your current algorithm without changing the approach itself.

Your N array contains roughly 1 billion objects (1001 * 1001 * 1001). You need to set each element, so you have at least one billion operations. To get a lower bound let's assume that setting one array element takes one nanosecond (in reality it will take more time). 1 billion operations, each taking 1 nanosecond means it takes 1 second to complete. As I said it will likely take a bit longer than 1 nanosecond for each operation, so let's assume it takes 10 nanoseconds (probably a bit high but more realistic than 1 nanosecond) that means we have 10 seconds total for the algorithm.

So the expected run-time with your inputs will be between 1 second and 10 seconds. So if your Python version takes 10 seconds it's probably already at the limit of what can be achieved with your chosen approach and no tool will (significantly) improve that run-time.

One thing that could make it a bit faster is using np.zeros instead of np.full:

The best answer comes from schwobaseggl: "Have you tried lp_wrapper = lp(obj.method)"

It turns out that this is the way you wrap methods.

This is an issue of CUDA kernel queue.

See the following:

• https://github.com/cupy/cupy/issues/1294
• https://github.com/cupy/cupy/issues/1765

The short execution observed in your code was fake, because cupy returns immediately when the queue is not filled.

The actual performance was the last line.

Note: This was NOT an issue of memory allocation — as I originally suggested in my initial answer — but I include the original answer for the record here.

Original (incorrect) answer

May be due to the reallocation.

When you import cupy, cupy allocates "some mount of" GPU memory. When cupy used all of them, it have to allocate more memory. This increases the execution time.

I missed adding function name after %lprun.The proper answer is