Cython supports native parallelism through the
module. To use this kind of parallelism, the GIL must be released (see
Releasing the GIL
). It currently supports OpenMP, but later on more backends might be supported.
Functionality in this module may only be used from the main thread or parallel regions due to OpenMP restrictions.
prange( [start,] stop[, step][, nogil=False][, schedule=None[, chunksize=None]][, num_threads=None] ) ¶
This function can be used for parallel loops. OpenMP automatically starts a thread pool and distributes the work according to the schedule used.
Thread-locality and reductions are automatically inferred for variables.
If you assign to a variable in a prange block, it becomes lastprivate, meaning that the variable will contain the value from the last iteration. If you use an inplace operator on a variable, it becomes a reduction, meaning that the values from the thread-local copies of the variable will be reduced with the operator and assigned to the original variable after the loop. The index variable is always lastprivate. Variables assigned to in a parallel with block will be private and unusable after the block, as there is no concept of a sequentially last value.
Example with a reduction:
from cython.parallel import prange cdef int i cdef int n = 30 cdef int sum = 0 for i in prange(n, nogil=True): sum += i print(sum)
Example with a typed memoryview (e.g. a NumPy array):
from cython.parallel import prange def func(double[:] x, double alpha): cdef Py_ssize_t i for i in prange(x.shape): x[i] = alpha * x[i]
parallel( num_threads=None ) ¶
This directive can be used as part of a
statement to execute code sequences in parallel. This is currently useful to setup thread-local buffers used by a prange. A contained prange will be a worksharing loop that is not parallel, so any variable assigned to in the parallel section is also private to the prange. Variables that are private in the parallel block are unavailable after the parallel block.
Example with thread-local buffers:
from cython.parallel import parallel, prange from libc.stdlib cimport abort, malloc, free cdef Py_ssize_t idx, i, n = 100 cdef int * local_buf cdef size_t size = 10 with nogil, parallel(): local_buf = <int *> malloc(sizeof(int) * size) if local_buf is NULL: abort() # populate our local buffer in a sequential loop for i in xrange(size): local_buf[i] = i * 2 # share the work using the thread-local buffer(s) for i in prange(n, schedule='guided'): func(local_buf) free(local_buf)
Later on sections might be supported in parallel blocks, to distribute code sections of work among threads.
threadid( ) ¶
Returns the id of the thread. For n threads, the ids will range from 0 to n-1.
To actually use the OpenMP support, you need to tell the C or C++ compiler to enable OpenMP. For gcc this can be done as follows in a setup.py:
from distutils.core import setup from distutils.extension import Extension from Cython.Build import cythonize ext_modules = [ Extension( "hello", ["hello.pyx"], extra_compile_args=['-fopenmp'], extra_link_args=['-fopenmp'], ) ] setup( name='hello-parallel-world', ext_modules=cythonize(ext_modules), )
For Microsoft Visual C++ compiler, use
The parallel with and prange blocks support the statements break, continue and return in nogil mode. Additionally, it is valid to use a
block inside these blocks, and have exceptions propagate from them. However, because the blocks use OpenMP, they can not just be left, so the exiting procedure is best-effort. For prange() this means that the loop body is skipped after the first break, return or exception for any subsequent iteration in any thread. It is undefined which value shall be returned if multiple different values may be returned, as the iterations are in no particular order:
from cython.parallel import prange cdef int func(Py_ssize_t n): cdef Py_ssize_t i for i in prange(n, nogil=True): if i == 8: with gil: raise Exception() elif i == 4: break elif i == 2: return i
In the example above it is undefined whether an exception shall be raised, whether it will simply break or whether it will return 2.
OpenMP functions can be used by cimporting
# tag: openmp # You can ignore the previous line. # It's for internal testing of the Cython documentation. from cython.parallel cimport parallel cimport openmp cdef int num_threads openmp.omp_set_dynamic(1) with nogil, parallel(): num_threads = openmp.omp_get_num_threads() # ...