[Python] Python Numba is not performing as expected

I have the following code in python3 and I am comparing the Numba JIT compiler performance with a regular code.

My OS is Ubuntu 22.04, pip3 install virtualenv and pip3 install numba numpy

benchmark.py

import warnings
warnings.filterwarnings("ignore") #https://github.com/numba/numba/issues/4553
import timeit
import numpy as np
from numba import jit

# https://numba.pydata.org/
print("Jit - Just in Time translation from Python to optimized C")
print("\n")

A = list(range(1,5000000,1))
# A = list(range(1,6,1))
# print(A)


# Algorithms to be tested

def makeSquareLoopFor(A):
result = []
for i,v in enumerate(A):
result.append(A**2)
return result

# print(makeSquareLoopFor(A))
makeSquareLoopForBenchmark= timeit.timeit("makeSquareLoopFor(A)", globals=globals(), number=1)
print("makeSquareLoopForBenchmark =",makeSquareLoopForBenchmark)

# Numba decorators to translates Python functions to optimized machine code at runtime - JustInTime
@jit(nopython=True)
def makeSquareLoopForJit(A):
result = []
for i,v in enumerate(A):
result.append(A**2)
return result

# print(makeSquareLoopForJit(A))
makeSquareLoopForBenchmarkJit = timeit.timeit("makeSquareLoopForJit(A)", globals=globals(), number=1)
print("makeSquareLoopForBenchmarkJit =",makeSquareLoopForBenchmarkJit)
print("\n")
# ==============================================================================

def makeSquareLoopWhile(A):
result = []
i=0
while i < len(A):
result.append(A**2)
i += 1
return result

# print(makeSquareLoopWhile(A))
makeSquareLoopWhileBenchmark = timeit.timeit("makeSquareLoopWhile(A)", globals=globals(), number=1)
print("makeSquareLoopWhileBenchmark =",makeSquareLoopWhileBenchmark)

# Numba decorators to translates Python functions to optimized machine code at runtime - JustInTime
@jit(nopython=True)
def makeSquareLoopWhileJit(A):
result = []
i=0
while i < len(A):
result.append(A**2)
i += 1
return result

# print(makeSquareLoopWhileJit(A))
makeSquareLoopWhileJitBenchmark = timeit.timeit("makeSquareLoopWhileJit(A)", globals=globals(), number=1)
print("makeSquareLoopWhileJitBenchmark =",makeSquareLoopWhileJitBenchmark)
print("\n")
# ==============================================================================

def makeSquareListComprehension(A):
return [v**2 for v in A]

# print(makeSquareListComprehension(A))
makeSquareListComprehensionBenchmark = timeit.timeit("makeSquareListComprehension(A)", globals=globals(), number=1)
print("makeSquareListComprehensionBenchmark =",makeSquareListComprehensionBenchmark)

# Numba decorators to translates Python functions to optimized machine code at runtime - JustInTime
@jit(nopython=True)
def makeSquareListComprehensionJit(A):
return [v**2 for v in A]

# print(makeSquareListComprehensionJit(A))
makeSquareListComprehensionJitBenchmark = timeit.timeit("makeSquareListComprehensionJit(A)", globals=globals(), number=1)
print("makeSquareListComprehensionJitBenchmark =",makeSquareListComprehensionJitBenchmark)
print("\n")
# ==============================================================================

def makeSquareMap(A):
return list(map(lambda v: v**2, A ))

# print(makeSquareMap(A))
makeSquareMapBenchmark = timeit.timeit("makeSquareMap(A)", globals=globals(), number=1)
print("makeSquareMapBenchmark =",makeSquareMapBenchmark)

# Numba decorators to translates Python functions to optimized machine code at runtime - JustInTime
@jit(nopython=True)
def makeSquareMapJit(A):
return list(map(lambda v: v**2, A ))

# print(makeSquareMapJit(A))
makeSquareMapJitBenchmark = timeit.timeit("makeSquareMapJit(A)", globals=globals(), number=1)
print("makeSquareMapJitBenchmark =",makeSquareMapJitBenchmark)
print("\n")
# ==============================================================================

def makeSquareNumpy(A):
return np.square(A)

# print(makeSquareNumpy(A))
makeSquareNumpyBenchmark = timeit.timeit("makeSquareNumpy(A)", globals=globals(), number=1)
print("makeSquareNumpyBenchmark =",makeSquareNumpyBenchmark)

# Numba decorators to translates Python functions to optimized machine code at runtime - JustInTime
# @jit(nopython=True)
def makeSquareNumpyJit(A):
return np.square(A)

# print(makeSquareNumpy(A))
makeSquareNumpyJitBenchmark = timeit.timeit("makeSquareNumpyJit(A)", globals=globals(), number=1)
print("makeSquareNumpyJitBenchmark =",makeSquareNumpyJitBenchmark)


As we can see in the following output the Numba Jit compiler is not performing as expected when compared with no numba code.

Jit - Just in Time translation from Python to optimized C


makeSquareLoopForBenchmark = 1.6181618960108608
makeSquareLoopForBenchmarkJit = 7.653679737006314


makeSquareLoopWhileBenchmark = 2.3787347140023485
makeSquareLoopWhileJitBenchmark = 7.815255765017355


makeSquareListComprehensionBenchmark = 2.4829419960151426
makeSquareListComprehensionJitBenchmark = 8.279022732982412


makeSquareMapBenchmark = 1.5203839530004188
makeSquareMapJitBenchmark = 7.935965497017605


makeSquareNumpyBenchmark = 0.43739607697352767
makeSquareNumpyJitBenchmark = 0.4406902039772831


What am I missing here? Why the numba is less performant than regular python?

Continue reading...