Multithreading python

Fermé
arthur - Modifié le 7 mars 2022 à 16:43
mamiemando Messages postés 33093 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 4 mai 2024 - 7 mars 2022 à 17:22
Bonjour
,
Je veux écrire un programme python qui me permet de calculer Pi mais lors de l'exécution du programme je m'aperçois que seulement 10% du processeur et utiliser.

En me renseignant sur différents forums, j'ai vu que python n'exécutait pas les programmes sur plusieurs cœurs.
Je voulais donc savoir comment faire pour utiliser les 12 cœurs du processeur afin de gagner du temps lors de l'exécution du programme.

J'ai déjà essayé de regarder sur des forums, mais je ne suis pas parvenu à résoudre le problème. Je voulais que par exemple le 1er cœur face les 10 millions de 1ère boucles et qu'en même temps le 2ème cœur face les 10 millions de 2ème boucles...
et qu'à la fin ils additionnent les 12 résultats et me le retourne dans la console.

Voici le programme:

def test(X):
    P = 0
    v = 1
    for k in range(X):
        P = P + (4 / v) - (4 / (v + 2))
        v = v + 4
    print(P)


Auriez-vous une solution ?

Bonne journée.

6 réponses

yg_be Messages postés 22756 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 5 mai 2024 1 480
6 mars 2022 à 10:24
bonjour, as-tu essayé de faire une recherche internet avec le titre de la discussion?
0
yg_be Messages postés 22756 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 5 mai 2024 1 480
6 mars 2022 à 11:44
Je pense que tu souhaites faire du multiprocessing, pas du multithreading.
0
Oui j'ai déjà essayé et j'arrive sur plusieurs pages qui en parle mais je ne comprend pas grand chose.
0
Oui effectivement je me suis trompé de mots.
0
yg_be Messages postés 22756 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 5 mai 2024 1 480
6 mars 2022 à 12:35
ceci fonctionne chez toi?
import time
import pandas as pd
import multiprocessing


results = []

def processData(df):  
    """Does some compute intensive operation on the data frame.
       Returns a list."""
       
    for i in range(100000):
        df = df * 1.0
    return df.values.tolist()

def collect_results(result):
    """Uses apply_async's callback to setup up a separate Queue for each process"""
    results.extend(result)
    
if __name__ == "__main__":
    start_time = time.time()  
    
    # Repeats the compute intensive operation on 10 data frames concurrently
    pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
    for i in range(2): 
        pool.apply_async(processData, args=(123, ), callback=collect_results)
    pool.close()
    pool.join()
    
    # Converts list of lists to a data frame
    df = pd.DataFrame(results)
    print(df.shape)
    print("--- %s seconds ---" % (time.time() - start_time))
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
yg_be Messages postés 22756 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 5 mai 2024 1 480
6 mars 2022 à 14:11
un exemple:
import time
import multiprocessing

def processData(D,F):
    print("d:",D, F)
    P=0
    v=1+4*D
    for k in range(D,F):
        P=P+(4/v)-(4/(v+2))
        v=v+4
    print("f:",D,F)
    return P

def collect_results(result):
    """Uses apply_async's callback to setup up a separate Queue for each process"""
    global results
    print(result)
    results+=result

if __name__ == "__main__":
    results = 0
    start_time = time.time()
    boucles=float(100000000)
    procs=4
    C=int(boucles/procs)
    pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
    for i in range(procs):
        pool.apply_async(processData, args=(i*C,(i+1)*C), callback=collect_results)
    pool.close()
    pool.join()
    print("total:",results)
    print("--- %s seconds ---" % (time.time() - start_time))
0
mamiemando Messages postés 33093 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 4 mai 2024 7 751
Modifié le 7 mars 2022 à 17:24
Bonjour,

Pour calculer
P
, tu fais moralement la somme infinie de des termes de
v_k
,
k
allant de
1
à l'infini avec un pas de
4
. Cela signifie qu'en faisant un peu de maths, tu peux directement écrire
P
comme une somme infini qui ne dépend que de
k
. Ensuite il suffit de faire un map / reduce...

import functools, multiprocessing

def p(k):
    return 4 / (4 * k + 1) - 4 / (4 * k + 3)

pool = multiprocessing.Pool(processes=multiprocessing.cpu_count())
with multiprocessing.Pool(multiprocessing.cpu_count()) as pool:
     pks = pool.map(p, range(10))
print(sum(pks))


Note enfin qu'entre ton code original, voir ta fonction
test()
, il peut y avoir des différences dans les dernières décimales. C'est parce que dans ton code, tu cumules les erreurs d'arrondis donc attention !

Bonne chance
0