Python performance ?

hello

Je mînteresse aux python et donc je cherche a évaluer les performance. j’ai constater que:

1.-simple a apprendre, de nombreuse fonction disponible.
1:-inconvenian majeure:
N’utilisera qu’un seul core, ce qui veux dire que le mec qui a un quadcore sa ne lui servira a rien.
Ceci été eté confirmer pas un teste simple, et ce même avec un tread. il faut espérer que sa ce corrige d’ici peux car le C/C++ prend vraiment le dessus coter performances.
Oui un cpu qui bosse a 50% (dualcore) 15% si c est un quad (supposition j’ai que le dualcore))) sa fait une énorme différence:

pour les séptique:

from Tkinter import *
import threading
print "benchmarck 0.0.1"

def bouclewhile(n):
    if testelif(n) == "true":
        while n <100000000000000000 :
            n = n+1
        return n
    elif  testelif(n) == "false":
        return "plage incorrect"

def testelif(a):
    if a > 100000000000000000 :
         return "false"
    elif a <= 100000000000000000 :
        return "true"
    else:
        return "false"

t = threading.Thread(target=bouclewhile,args=[1])
t.start()
print bouclewhile(1)

ensuite avec htop ou autre vous pouvez voir qu’a aucun moment les 2 core son charger a 100% en même temps

si quelqu’un y parviens je suis avidement intéresser :smt003

Il y a deux types de parallélisation :
[ul]
[li]créer des processus « lourds », c’est ce que fait la fonction fork. On obtient une duplication du processus ;[/li]
[li]les threads sont des processus légers il existe deux types de threads :
[list]
[]les threads visibles par le systèmes. Le noyau pouvant les voir ceux-ci bénéficient de l’ordonnancement du noyau ;[/li]
[li]les threads internes au processus. Là l’ensemble des threads se partages les ressources d’un processus.[/li][/ul][/
:m][/list:u]

Je crois bien ne pas me planter.

[quote=“MisterFreez”]Il y a deux types de parallélisation :
[ul]
[li]créer des processus « lourds », c’est ce que fait la fonction fork. On obtient une duplication du processus ;[/li]
[li]les threads sont des processus légers il existe deux types de threads :
[list]
[]les threads visibles par le systèmes. Le noyau pouvant les voir ceux-ci bénéficient de l’ordonnancement du noyau ;[/li]
[li]les threads internes au processus. Là l’ensemble des threads se partages les ressources d’un processus.[/li][/ul][/
:m][/list:u]

Je crois bien ne pas me planter.[/quote]

donc le code cque j’ai mis : Cela serait le cas ou le tread ce partage les ressource du processus ?
mai comment ou avec qu’elle code en python je peux faire un processus lourd ?

Merci pour ta réponse :astonished:

Je sais pas si python possède une fonction fork, mais il peut utiliser du C via swig.

myelin.co.nz/post/2003/3/13/

euh j’ai pas compris le truc. ou du moins je ne suis pas arriver a faire ce que je voulait.
en gros sa donne

pipe:

si la pipe a un n° de pid
lire le resuta:
sinon
ecrire ?

donc il fait -->ecrire puis remonte et fait -->lire le resulta mai je voit pas ou sa permet d’écrire sur 2 core puis qu’il fait l’un après l’autre ???

Effectivement, tu n’as pas compris.
Aprés le fork, tu obtient deux processus qui sont à priori identiques (le pipe n’est jamais que le canal de communication entre les deux, il n’a pas d’importance pour la compréhension de ce qui se passe) et ils executent le même code.
Ils sont tous les deux dans leur execution juste aprés la ligne pid = os.fork(), et ils sont prets à continuer en parallèle l’execution du même script.
Mais il y en a un qui est le père (celui qui a reçu un pid non nul lors du fork), et un qui est le fils (le pid reçu est nul dans son cas).
Dans l’exemple, le père qui voit qu’il a un pid non nul lit alors ce qui arrive dans le pipe, puis attend que le fils se termine (partie du code if pid:).
De son coté, le fils execute de son coté la parie “else” de ce if.

Comme tu vois, c’est un choix pour cet exemple là que de ne faire que lire et d’attendre la fin du fils, mais le père peut aussi faire autre chose, et créer d’autres fils de la même manière, et n’attendre que tout à la fin, quand il a fini de faire tout ce qu’il veut, que tous ses fils aient fini.

Pour ce qui est du parallèlisme, tu n’as pas à t’en préoccuper: tu crées des processus différents avec tes forks, et c’est l’ordonnanceur, en voyant qu’il a plusieurs processus à traiter et plusieurs processeurs (ou coeurs, c’est idem) et qui décide ensuite de répartir là ou il veut les tâches. Tu n’as rien à spécifier.

ben j’ai demander a pas mal de gens et personne y est arriver a le faire tourner en parallèle. pour l’instant sa tourne l’un après l’autre.
a mon avis sa sa marche c est un coup de chance. en plus comme i on le meme pid sa me parait peux probable.
Donc si t’a un bout de code qui le fait je suis preneur

Ceux à qui tu as demandé son nuls, car c’est un minimum en programmation multitâche que de savoir utiliser correctement un fork. Ou alors, ce que tu fais avant le fork dans le code du père oblige pour une raison ou pour une autre (variables register en C, par exemple) à rester sur le même processeur.
Une autre raison possible pour que tout s’execute sur le même processeur est que le temps du code executé soit plus court que la tranche minimale de processeur pour lequel l’ordonnanceur décide d’allouer le processeur. Dans ce cas, l’ordonnanceur peut juger que ce n’est pas la peine de lancer le nouveau process sur un autre processeur.

Mais manifestement, tu n’as toujours pas compris le fonctionnement de ce bout de code: il >est< parallèle.

Quel que soit le language, c’est toujours la même algorithmique:

pid=Fais_Un_Fork si pid=0 (on est dans le père) fais_ce_que_doit_faire_le_père attends_la_fin_du_ou_des_fils(pid) sinon (on est dans le fils) executes_le_code_du_fils fin_si
Bon, tu me crois ou pas, mais je n’ai rien à te dire de plus.

Dernière tentative :

[code]#!/usr/bin/env python

-- coding: utf8 --

import os, sys
import time

print “On commence”

r, w = os.pipe()

pid = os.fork()
if pid:
os.close(w)
r = os.fdopen®
print "Je suis le père. Mon pid est " + str(os.getpid())
time.sleep(1)
print “Je suis toujours le père. (” + str(os.getpid()) + ")"
txt = r.read()
r.close()
os.waitpid(pid, 0) # make sure the child process gets cleaned up
else:
os.close®
w = os.fdopen(w, ‘w’)
print "Je suis le fils. Mon PID c’est " + str(os.getpid())
time.sleep(1)
print “Je suis toujours le fils. (” + str(os.getpid()) + ")"
w.write(“Père je vais mourir”)
w.close()
sys.exit(0)

print "Le fils est mort"
print "Ces dernières paroles étaient : " + txt[/code]

j’ai tester, code fonctionnel mai ne tourne que sure 1 seul core. :unamused:

je vai encore essayer avec ceci pypi.python.org/pypi/processing/0.52 mai si avec sa sa marche pas je laisse tomber.

[quote=“panthere”]j’ai tester, code fonctionnel mai ne tourne que sure 1 seul core. :unamused: [/quote] Comment fais tu pour le vérifier ?

aptitude install htop
il faut que le code s’exécute donc, et les 2 core doive en meme temps bosser a plus de 60%
img179.imageshack.us/my.php?imag … e46ou6.png
(champ 1 et 2 en dessu de mem)

sinon je me mélange les pinceau avec le nouveaux code: je voit pas ou exécuter la 2eme boucle en parallèle.

#!/usr/bin/env python
# -*- coding: utf-8 -*
from Tkinter import *
import threading
import os, sys
from processing import Process, Queue
from processing import Condition
from processing import Manager
from processing import Pool

print "benchmarck 0.0.1 code de super débutant :D"
bcl = 1000000
result = ""

def bouclewhile(n):
    while n <bcl :
        n = n+1
        print n
    return n + 1
        
def f(q):
    q.put('hello world')

if __name__ == '__main__':
    q = Queue()
    p = Process(target=bouclewhile, args=[1])
    p.start()
    print q.get()
    p.join()


 

c = Condition()
print c
c.acquire()
True
print c
manager = Manager()
l = manager.list(range(200))
l.reverse()
print l
print repr(l)

def f(x): return x*x
p = Pool(4)
result = p.mapAsync(f, range(200))
print result.get(timeout=1)

[quote=“panthere”]aptitude install htop
il faut que le code s’exécute donc, et les 2 core doive en meme temps bosser a plus de 60%[/quote]
A bon et pourquoi ?
C’est un code parallèle pas synchronisé. C’est à l’ordonnanceur de définir comment mettre en ordre tout ça. Tu n’a pas que c’est deux processus en court d’exécution. Le fais qu’il y ai deux PID prouve que tu te retrouve avec deux processus, ensuite la manière dont cela va s’exécuter c’est pas à toi de temps occuper mais à l’ordonnanceur.

Ensuite dans le cas de communication entre processus à l’aide de pipe, l’un est obligatoirement endormie pendant que l’autre écris. En effet pour pouvoir lire dans le pipe, il faut attendre que le premier processus ai écris quelque chose dedans.

Je n’ai qu’un seul core mais tu devrais faire quelque chose comme ça pour voir :

[quote]
pif = fork()
if pid :
#boucle de bien longue (une ou deux seconde sans sleep)
else
#boucle de bien longue (une ou deux seconde sans sleep)[/quote]

quote="MisterFreez"
ensuite la manière dont cela va s’exécuter c’est pas à toi de temps occuper mais à l’ordonnanceur.
(…)[/quote] Je me tue à lui expliquer !

Même si c’est en fait faux, et si on peut donner des ordres à l’ordonnanceur, et affecter les processus à un proco, dans des cas d’utilisation trés trés pointue en environnement massivement parallèle, mais faut vraiment en avoir l’usage, et je ne l’ai jamais vu faire, juste entendu en parler.

J’ai du louper ces fonctions dans l’API de linux. Sachant que j’imagine bien la portabilité du truc (et donc son wrapping en python).

Je ne sais pas si ça ne nécessite pas des noyaux patchés, ou ce genre de subtilités, remarque.

ben pourquoi sa marche avec gcc ? l’ordonanceur je connait.

qu’est ce qui marche ?

[quote=“mattotop”][quote=“themorice”]matt avait dis ça :

[quote]
soit tu mets CONCURRENCY_LEVEL = 3 dans /etc/kernel-img.conf
le parallèlisme doit être fixé à (nb de processeurs +1) pour être optimal.[/quote][/quote] J’avais dit une connerie, parceque c’est kernel-pkg.conf ou il faut le rajouter (il y a une page de man pour les deux fichiers).[/quote]