Discussion :

[stalacta]

Bonjour à tous !

Je viens ici poser une question non pas d'aide pour un projet en particulier, mais un peu ouverte. Elle s'applique notamment au Python, du fait qu'il ne soit pas une bête de course, mais pas que.
J'ai remarqué que quand j'ouvre un programme, n'importe lequel, il met quelques secondes à s'ouvrir (par exemple une dizaine pour Firefox) alors que seuls 20% de la capacité de mes processeurs sont utilisés. On peut se dire qu'il y aurait moyen d'accélérer fortement la vitesse d'ouverture du programme... Cela s'explique par le fait que la mémoire vive ne s'écrit pas instantanément, mais je ne pense pas que ce soit la seule raison ; je me disais également que cela peut venir de l'ordre dans lequel s'exécutent les opérations logiques dans les processeurs... Je m'explique : quand nous écrivons un programme basique, c'est une suite d'instructions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
nom=input('Entrez votre nom : ')
print("Vous vous appelez :",nom)

Dans ce cas, on ne peut pas changer l'ordre des actions, puisque print utilise une variable qui dépend d'une commande qui doit être antérieure. Mais maintenant, regardez ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
image_origine=capture()#on imagine que cela renvoi l'image de la webcam (en 256 couleurs) sous forme de bytes
image_sortie=[]
#notez qu'il serait tout à fait possible d'exécuter ces 2 premières lignes en parallèle sans compromettre les résultats du programme
for pixel in image_origine :
    image_sortie.append(255-pixel)#met l'image en négatif
image_sortie=bytes(image_sortie)

C'est le genre de traitement qui demande du temps. Mais ici les pixels sont traités les uns à la suite des autres, on doit donc attendre que le pixel n soit fini d'être traité (ce qui prend assez peu de puissance) pour traiter le pixel n+1. C'est une perte de temps énorme ! On pourrait tout traiter en parallèle (un premier thread s'occupe des 100 premiers octets, un 2e qui fait les 100 suivants...). C'est d'ailleurs pour ça que les cartes graphiques ont été imaginées : pour traiter un maximum de choses en parallèle. Je me demande si on pouvait également utiliser de simples processeurs de cette manière au maximum de leurs capacités, car je vois rarement un programme python, même lorsqu'il tourne à fond, faire dépasser les 50% du CPU utilisés. Alors si mes connaissances dans le domaine restent limités et très théoriques, je me posais quelques questions :
- Est-ce qu'il est utile de considérer cela quand on programme (les gains de temps sont-ils substantiels ?) ?
- Si oui, comment utiliser la capacité maximale des processeurs pour réduire le temps de calcul (est-ce que programmer avec le module Thread suffirait par exemple ?) ?

Merci d'avance de vos réponses !

EDIT : J'ai trouvé cet article qui parle brièvement de ce genre de notions, ce qui n'enlève pas l'intérêt de la discussion

[Tryph]

Salut,

pour l'exemple de Firefox qui met quelques secondes à s'ouvrir, tu as oublié une opération qui doit être plutôt longue: la lecture des fichiers de Firefox depuis le disque dur.
effectivement, le chargement en RAM du programme n'est pas instantanné mais c'est rien comparé aux temps d'accès au disque dur. si tu fais la même expérience avec un SSD au lieu d'un disque dur, je pense que tu seras surpris de voir à quel point ça va plus vite.

ensuite, un processeur exécute les instructions dans l'ordre ou on lui demande de les exécuter, par contre il n'exécute pas d'instructions Python mais des instruction de son jeu d'instruction uniquement (qui sont très très basiques). pour Python, c'est l'interpreteur qui va "convertir" les instruction Python en instruction processeur. Du coup, vouloir impacter l'ordre dans lequel sont exécutées les instruction au niveau du processeur, ça revient à réécrire l'interpreteur Python.

Ensuite tu parles de parallélisation de traitement, ce qui n'est pas une mauvaise idée en soit, mais qui n'est pas applicable dans tous les cas.
en gros la parallélisation de taches est utile quand au moins une des taches passe du temps à attendre sans rien faire qu'un évènement se produise.
par exemple, quand un programme chercher à écrire sur le disque dur, il en fait la "demande" et il attend que ça soit fait pour continuer à s'exécuter. ça peut ne prendre que quelques miliseconde, mais du point de vue (d'un coeur) du processeur, ce sont des millions de cycle passés à ne rien faire en attendant que l'écriture soit terminée. dans un cas comme celui-ci effectivement si on avait pu paralléliser un autre traitement, on aurait gagné du temps.
par contre si tu fais un traitement qui utilise du processeur et qui attend très peu de ressources impliquant des temps d'attente, la parallélisation peut avoir un intérêt proche de zéro.
ça c'est pour la parallélisation sur un seul coeur de processeur.

en réalité, aujourd'hui, toutes les machines ou presque sont dotées de processeurs à plusieurs coeurs et on peut paralléliser efficacement même des taches sans temps d'attentes en les faisant s'exécuter sur plusieurs coeurs.
mais Python souffre d'aun défaut à ce niveau là: le Global Interpreter Lock (ou GIL, je te laisserai chercher si tu veux plus d'info).
le GIL en question est un méchanisme qui a son utilité mais qui empèche un même interpéteur Python de dispacher plusieurs thread sur plusieurs coeurs. en gros un intepréteur Python ne peut utiliser qu'un seul coeur et tous les thread exécutés par cet interpréteur s'exécutent donc aussi sur le même coeur.
(après je suis pas un expert de genre de problématique, y a peut être des subtilités que j'ai mal compris, on me corrigera si c'est le cas).


pour conclure, je dirai que la première tache d'un processeur quel qu'il soit, c'est d'attendre... tu peux avoir l'impression d'un gaspillage mais ça s'explique très bien: les besoin en puissance de calcul d'un ordi au repos sont plutôt faible. mais quand on lui demande certaine taches, elles explosent.
le but de processeur est de fournir une puissance suffisante pour qu'on n'aie pas à attendre 3 minutes à chaque fois qu'on fait un clic, la contrepartie c'est que la plupart du temps cette puissance ne sert à rien.

EDIT: sametmax est un très bon blog pour ce qui est de Python.

[stalacta]

Merci pour cette réponse très complète. J'ai vu que multiprocessing permettrait de faire du calcul parallèle justement.