In comparing the performance of Numba and ISPC for a particular function, it becomes evident that Numba usually results in faster execution times. This difference mainly arises due to function call overhead and potentially sub-optimal compilation flags used in ISPC, leading to higher latency per call.
Overview of the Performance Comparison
A recent test conducted on an Intel Core CPU comparing Numba and ISPC produced interesting results regarding execution times. The tested function implementations were:
import numpy as np
import timeit as ti
import numba as nb
import ctypes
lib = ctypes.CDLL("./ispc0.so")
lib.ispc0.argtypes = [np.ctypeslib.ndpointer(dtype=np.uint8, ndim=1, flags="C_CONTIGUOUS"), np.ctypeslib.ndpointer(dtype=np.bool, ndim=1, flags="C_CONTIGUOUS"), ctypes.c_int]
lib.ispc0.restype = None
def ispc0(a, b):
lib.ispc0(a, b, a.size)
@nb.njit(fastmath=True)
def numba0(a, b):
rp2 = b[2:-2]
am2 = a
am1 = a[1:]
a0 = a[2:]
ap1 = a[3:]
ap2 = a[4:]
for i in range(a.size-4):
rp2[i] = ((am1[i] == a0[i]) & (am2[i] < am1[i]) | (am1[i] < a0[i])) & \
((ap1[i] == a0[i]) & (ap2[i] < ap1[i]) | (ap1[i] < a0[i]))
return None
Analysis of Execution Times
In the performance test, Numbaโs execution time was consistently lower than that of ISPC:
Numba execution: minimum, median, maximum times in microseconds: 12.708, 14.473, 40.796
ISPC execution: minimum, median, maximum times in microseconds: 16.089, 18.239, 216.175
This significant difference suggests that the function call overhead related to the ISPC implementation is a primary factor in the slower performance. Specifically, the use of ctypes and the libffi interface to call ISPC functions introduces additional overhead that does not exist in the direct Numba JIT-compiled function call.
Possible Reasons for Slower ISPC Performance
- Function Call Overhead: The use of ctypes could introduce delays in function calls, unlike Numba’s more direct execution model.
- Compilation Flags: The flags used when compiling the ISPC code may not be optimized for this specific function, resulting in less efficient machine code.
- Runtime Conditions: The context in which ISPC runs may not take full advantage of available CPU architectures or optimizations such as SIMD (Single Instruction, Multiple Data).
Conclusion
For Python developers and performance engineers, these results highlight the importance of understanding both the implementation method and the compilation options used in performance-critical applications. By analyzing function call overhead along with optimizing compilation flags, significant speed improvements can often be achieved. More detailed benchmarks and potential configurations should be considered when performance is a key requirement.
Original source (not independent verification of every claim)
Sources and evidence
Based on supplied source material. Discussion posts reflect participant reports; no independent product testing is claimed.






