Comment implémenter le parallélisme en Python : libérer la puissance multicœur ?

Question : Adopter le parallélisme en Python

En C, OpenMP fournit un support robuste pour la programmation parallèle. Cependant, Python ne dispose pas de cet outil pratique. Comment pouvons-nous parvenir au parallélisme dans les programmes Python, en particulier dans les scénarios où des fonctions indépendantes nécessitent une parallélisation ?

Considérez la structure de code suivante :

<code class="python">solve1(A)
solve2(B)</code>

Où solve1 et solve2 sont des fonctions indépendantes. L'objectif est d'exécuter ce code en parallèle, en minimisant le temps d'exécution.

Explorons l'extrait de code fourni :

<code class="python">def solve(Q, G, n):
    i = 0
    tol = 10 ** -4

    while i < 1000:
        inneropt, partition, x = setinner(Q, G, n)
        outeropt = setouter(Q, G, n)

        if (outeropt - inneropt) / (1 + abs(outeropt) + abs(inneropt)) < tol:
            break
            
        node1 = partition[0]
        node2 = partition[1]
    
        G = updateGraph(G, node1, node2)

        if i == 999:
            print "Maximum iteration reaches"
    print inneropt</code>

Nous visons à paralléliser les fonctions setinner et setouter.

Réponse : Libérer la puissance parallèle avec le module multitraitement

Le module multitraitement offre une solution puissante pour la programmation parallèle en Python. Cela nous permet de générer plusieurs processus capables d'exécuter des tâches simultanément, en utilisant la puissance de traitement de plusieurs cœurs de processeur.

Pour le code fourni, un pool de traitement peut être utilisé. Voici comment procéder :

<code class="python">from multiprocessing import Pool

pool = Pool()
result1 = pool.apply_async(solve1, [A])    # evaluate "solve1(A)" asynchronously
result2 = pool.apply_async(solve2, [B])    # evaluate "solve2(B)" asynchronously
answer1 = result1.get(timeout=10)
answer2 = result2.get(timeout=10)</code>

Cet extrait de code crée un pool de processus qui exécuteront les fonctions solve1 et solve2 de manière asynchrone. Chaque cœur de processeur peut exécuter un processus simultanément, réduisant ainsi efficacement le temps d'exécution.

Une autre façon de paralléliser les tâches consiste à utiliser la fonction map :

<code class="python">args = [A, B]
results = pool.map(solve1, args)</code>

Cette approche applique la fonction solve1 à chaque élément de la liste args en parallèle.

Cependant, il est important de noter que les threads ne doivent pas être utilisés pour la programmation parallèle en Python. En effet, le GIL (Global Interpreter Lock) empêche plusieurs threads d'exécuter le bytecode Python simultanément, annulant ainsi tout avantage potentiel du parallélisme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!