Multicœur et multithread sur Ipython Notebook

Vous pouvez utiliser multitraitement pour permettre à Python d'utilisation de plusieurs cœurs. Juste un, grand avertissement: toutes les données que vous transmettez entre Python séances doit être picklable ou transmises par le biais de l'héritage, et une nouvelle Python instance est créée sur Windows, alors que sur les systèmes Unix, il peut être déboursé plus. Cela a notabled les conséquences de performance sur un système Windows.

Une base exemple à l'aide de multitraitement est comme suit à partir de "Module Python de la Semaine":

import multiprocessing

def worker():
    """worker function"""
    print 'Worker'
    return

if __name__ == '__main__':
    jobs = []
    for i in range(5):
        p = multiprocessing.Process(target=worker)
        jobs.append(p)
        p.start()

Lorsqu'il est exécuté, il affiche:

Worker
Worker
Worker
Worker
Worker

Multitraitement vous permet de faire des calculs indépendants sur les différents cœurs, permettant le CPU des tâches avec peu de surcharge pour exécuter beaucoup plus rapidement qu'un processus traditionnel.

Vous devez aussi réaliser que le filetage en Python n'améliore pas les performances. Il existe pour des raisons de commodité (tels que le maintien de la réactivité d'une interface graphique pendant de longs calculs). La raison pour cela est ce ne sont pas des threads natifs en raison de Python Mondial de l'Interprète de Verrouillage, ou GIL.

Mise À Jour Février 2018

C'est toujours très bien applicables, et le seront dans un avenir prévisible. Le Disponible de la mise en œuvre utilise les suivants définition pour le comptage de référence:

typedef struct _object {
    _PyObject_HEAD_EXTRA
    Py_ssize_t ob_refcnt;
    struct _typeobject *ob_type;
} PyObject;

Notamment, c'est pas thread-safe, un global-interprète de verrouillage doit être mis en œuvre pour permettre à un seul thread d'exécution avec des objets Python pour éviter de données courses conduisant à des problèmes de mémoire.

Il existe de nombreux outils pour essayer de contourner le blocage de l'interpreteur global, en plus de multitraitement (ce qui nécessite une copie complète de l'interprète sur Windows, plutôt que d'une fourche, il est très lent et rebelles à toute amélioration de la performance).

Cython

Votre solution la plus simple est Cython. Simplement cdef une fonction, sans objets internes, et la libération de l'GIL avec la with nogil mot-clé.

Un exemple simple prise de la la documentation, qui vous montre comment à la libération, et temporairement re-activer le GIL:

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

À l'aide d'un autre Interprète

Disponible a un IG, tout en Jython et IronPython ne le font pas. Être prudent, car de nombreux C-bibliothèques pour le calcul de haute performance peut ne pas fonctionner avec IronPython ou Jython (SciPy flirté avec IronPython de soutien, mais il est passé il y a longtemps, et il ne fonctionnera pas sur un moderne version de Python).

À L'Aide De MPI4Py

MPI, ou Interface de Passage de Messages, est une haute performance de l'interface pour les langages comme le C et le C++. Il permet efficace des calculs parallèles, et MPI4Py crée des liaisons de MPI pour Python. Pour plus d'efficacité, vous devez utiliser uniquement MPI4Py avec des tableaux NumPy.

Un exemple de leur la documentation est:

from mpi4py import MPI
import numpy

def matvec(comm, A, x):
    m = A.shape[0] # local rows
    p = comm.Get_size()
    xg = numpy.zeros(m*p, dtype='d')
    comm.Allgather([x,  MPI.DOUBLE],
                   [xg, MPI.DOUBLE])
    y = numpy.dot(A, xg)
    return y

OriginalL'auteur Alexander Huszagh