multithreading python

Question

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.

yg_be · Answer

bonjour, as-tu essayé de faire une recherche internet avec le titre de la discussion?

arthur · Answer

Oui j'ai déjà essayé et j'arrive sur plusieurs pages qui en parle mais je ne comprend pas grand chose.

arthur · Answer

Oui effectivement je me suis trompé de mots.

yg_be · Answer

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))

yg_be · Answer

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))

mamiemando · Answer

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

Multithreading python

6 réponses

Discussions similaires

Newsletters