Comment allouer de la puissance de calcul a un calcul deja lance

[SAKAROV]

En partant du postulat que le programme soit dépendant des premiers éléments de recherche trouvés, et ceci en boucle. Donc que l'on ne peut scinder le travail en plusieurs morceaux.

(cela est relatif au système (et au réseau), mais je le pose ici car faut bien le programmer)

[fred]

Beaucoup de langages ne peuvent travailler que sur un seul coeur CPU, soit 25% (pour 4 coeurs) des capacités de la puissance de calcul, afin d'éviter les block out de l'OS

En python par exemple la solution est l'IPC (inter process communication) via multiprocessing ou celery

Par contre faire du calcul avec python ou un langage de script, reste limité, peut-être faut-il choisir de l'interfaçage C/Python, du C, voir C++ (ce dernier me semble le plus probable).

En ce qui concerne le réseau, bien évidemment, il me semble que cela dépendra du serveur, totalement indépendant de ta volonté.

[SAKAROV]

Je connais le multi-threading / multi-processing mais ma question autre. Ce n'est pas "comment utiliser plus de puissance pour un programme" mais "comment allouer plus de puissance à un programme en cours".

Il ne s'agirait pas là de rajouter un core déjà présent physiquement sur l'ordi à son programme mais d'allouer réellement beaucoup plus de puissance de calcul (par exemple, connecter le calcul à un gros cluster), mais ma question je le répète ne repose pas sur la faisabilité d'utiliser une certaine puissance à un calcul mais vraiment comment peut-on faire (en programmation) pour ne pas avoir à stopper puis relancer le calcul à partir de zéro.

Admettons qu'on a une puissance de calcul de X et que le calcul tourne depuis déjà 10 jours et qu'il reste, à puissance égale 10 jours pour obtenir les résultats et qu'on doive rendre les résultats de ce calcul dans 1 jour impérativement en ayant une possibilité de calcul de 9X supplémentaire à disposition. Si l'on reprend de zéro, le calcul à puissance 10X (X+9X) mettra 2 jours (en admettant que la puissance/temps soit toujours égal) donc on ne pourra pas se permettre de relancer le calcul : il faut impérativement reprendre le calcul "en cours de processus" en allouant 9X de puissance le soir même, afin qu'il ne reste qu'une journée de calcul et donc donner les résultats à temps.

Comment gérer ça (quel type de code) ? (qu'importe le langage, c'est théorique).

[fred]

Hum ok, j'avais pas compris, donc en fait c'est pas possible... Tu as un algorithme avec une certaine efficacité, on ne peut pas améliorer le temps de but en blanc comme cela, à moins que par exemple tu fasses du python et que tu compiles ton code python à l'aide de cython, dans ce cas tu gagnerais 4 à 40 fois de la vitesse de calcul.

Mais si tu fais du C ou du C++, il n'y aurait pas d'autres moyens que de changer d'algorithme.

La seule différence visible sera donc dans le cas où tu passes d'un langage interprété à un langage compilé, ou un changement d'algorithme

Pour les autres cas, je ne connais pas, mais je dirais que si tu partages le travail sur plusieurs ordinateurs, là en effet, le travail sera multiplié par le nombre d'ordinateurs participant au travail

EDIT:

comment peut-on faire (en programmation) pour ne pas avoir à stopper puis relancer le calcul à partir de zéro.

En faisant de la sérialisation, enregistrement d'une variable en brut dans un fichier, rechercher cette variable pour continuer le boulot de la veille dans ce même fichier

[SAKAROV]

En fait, t'as toujours pas saisi

C'est peut-être moi qui m'exprime mal !

Est-ce que quelqu'un m'a compris ?

Je ne vais pas me répéter j'arriverai pas à être plus clair (j'ai pourtant mis un exemple dans le 2eme post !)

[DreAmuS]

Je pense avoir compris le truc SAKAROV mais comme Fred à part lui administrer de nouveaux calculateurs ou machines je ne vois pas comment faire. Je pense que la tu tape à un niveau élevé de connaissance car la plupart te donneront la même réponse que Fred à savoir ajouter du RAM ou des PC Pour aider le programme déjà lancé.

Si tu utilise comme tu dis n-1 de départ tu n'alloue pas toute la puissance à ton calcul donc tu pourrais programmer en C pour que le calcul s'échelonne au fur et à mesure de manière croissante : Genre n-3, n-2, n-1 puis n.

Mais si tu utilise déjà la pleine puissance de ton calculateur comment veux-tu alors en rajouter avec un simple programme ? Un programme donne des instructions il ne peut faire dépasser la mémoire déjà utilisé sans planter notre PC.

Faudrait être magicien ? Personnellement cela me dépasse complètement. Je vois ce que tu veux mais le réaliser sans ajout extérieur juste avec un programme je pense juste que cela est irréalisable ou en dehors de mes compétences (si jugé que j'en ai un peu ).

[TorTukiTu]

En admettant que tu aies d'autres calculs en cours sur le cluster, tu peux monter la priorité de ton process.

Sinon, tu peux faire du scaling horizontal et vertical, mais ça nécessite que ton programme ait été conçu pour ça, ou que l'utilisation des ressources matérielles soit suffisamment abstraite (en utilisant un cluster kerrighed par exemple).

Tu peux aussi peut être bricoler un truc avec OpenVZ qui gère les checkpoints et l’allocation dynamique de ressources matérielles il me semble. À toi de voir, je connais très mal ce projet, mais c'est une autre piste à explorer.

Impossible de te répondre précisément, il faudrait que tu précises un peu plus la situation.

PS: Certaines cartes mères supportent plusieurs sockets CPU, et certaines distribs GNU/Linux supportent le montage de cpu à chaud (J'ai petit un cluster dont plusieurs nodes sont équipés avec ce type de carte mère chez moi). Après, j'ai jamais essayé le cpu hotpluging, je ne sais pas ce que ça vaut d'un point de vue stabilité.

Comment gérer ça (quel type de code) ? (qu'importe le langage, c'est théorique).

Ta problématique ne se situe pas vraiment côté code (bien que ton programme doive forcément savoir paralléliser le calcul, donc faire du multithreading), c'est plus un problème d'architecture. C'est l'OS qui gère l'attribution des ressources, pas ton programme (enfin, la plupart du temps...), peu importe le langage.

Après, si tu as déjà lancé ton calcul critique sans réfléchir à l'archi et sans estimer la durée du calcul théoriquement ou empiriquement à partir d'un jeu test (faut être un peu con pour le coup...) effectivement, tu as de bonnes chances d'être chocolat.

[SAKAROV]

@Dreamus: t'as pas vraiment saisi non plus^^
@Tortu: toi t'as saisi ! *Et la lumière fut*

- cmd renice (ou équivalent) :
- scaling : non applicable dans le cas que je soumets (en effet, faut y penser avant). Cela dit j'ai jeté un oeil à Kerrighed, je ne connaissais pas et ça me paraît somme toute très intéressant !
- openVZ : je vois pas vraiment l'intérêt de la virtualisation dans le cas exposé.

~~~~~

- cpu hotpluging :

certaines distribs GNU/Linux supportent le montage de cpu à chaud"

Lesquelles ?

Bien sûr, ma question repose sur le fait que le programme n'ait pas été conçu pour du multithreading.

D'où la problématique !

[TorTukiTu]

- openVZ : je vois pas vraiment l'intérêt de la virtualisation dans le cas exposé

C'est liée à l'abstraction matérielle. L'ídée c'est que si ton programme tourne dans une machine virtuelle, tu peux faire une image (pour limiter le risque de tout péter...), et peut être rajouter à chaud des CPU virtuels en ajoutant des CPU physiques sur des machines physiquement distinctes. Mais d'après ce que tu viens de dire, ça n'est pas une solution.

Une autre solution est de recharger ton image sur une machine qui a un CPU bien plus costaud.

Je me souviens avoir eu une discussion avec un expert VMWare il y a quelques années, si je me souviens correctement, le type m'avait dit qu'il pouvait snapshoter une machine physique pour en faire une image vmware. Si c'est le cas, tu aurais juste à recharger l'image sur un ESX ayant un processeur plus rapide.

certaines distribs GNU/Linux supportent le montage de cpu à chaud"
Lesquelles ?

Je crois que c'est à partir du kernel 3.8 Donc toutes les distribs qui supportent 3.8 et supérieur, ca devrait pouvoir le faire. Il me semble que ca dépends aussi des marques de CPU (Les procs Intel récents le supportent je crois). Je n'en sais pas beaucoup plus, à toi de creuser si tu le souhaites, et n'hésite pas à partager tes infos !

Bien sûr, ma question repose sur le fait que le programme n'ait pas été conçu pour du multithreading.

Compliqué... Pour la simple raison que c'est un travail qui n'est pas parallélisable par la machine. La seule solution (hormis le coup du snapshot de VM) que je vois est de changer ou d'overclocker le proc (tu peux envisager de le refroidir à l'azote liquide pour avoir un gain significatif). Après c'est du bricolage, ça va donc être bien casse-gueule mais ça n'est pas impossible...

[SAKAROV]

Oui mais l'OC ne ferait jamais gagner 10x + de puissance.

Bon, donc a priori la meilleure solution serait de hotplug des cpu au cluster (si la motherboard &/o le kernel le permettent) puis de renice le pid du programme.

Même si le programme n'a pas été prévu pour le multithreading ?

[TorTukiTu]

Bon, donc a priori la meilleure solution serait de hotplug des cpu au cluster (si la motherboard &/o le kernel le permettent) puis de renice le pid du programme.

Même si le programme n'a pas été prévu pour le multithreading ?

Bah non... Tu peux juste renice, OC, utiliser la virtualisation pour changer de machine ou changer de CPU.

De nouveaux CPUs seront exposés par l'OS comme de nouveaux coeurs à un unique CPU virtuel. Si c'est pas multithreadé, c'est pas parallélisable, ajouter des CPUs ne servira à rien.

Oui mais l'OC ne ferait jamais gagner 10x + de puissance.

C'est sur, tu peux peut être faire du x2 ou x3 dans le meilleur des cas.

[SAKAROV]

On est donc d'accord. Merci j'ai la réponse à ma question : c'est pas possible.

[reader117]

Comment gérer ça (quel type de code) ?

Je vais peut être sortir une énorme connerie, mais de ce que j'en ai compris il s'agirait de reprendre un calcul en cours sur un dispositif plus puissant non ?

Parce que dans ce cas, c'est possible normalement, avec un algorithme récursif (du style calcul de puissance d'un nombre), si ton code est bien structuré tu peux le lancer à partir d'un résultat intermédiaire. A ce niveau là il te suffit d'avoir prévu un système qui écrit le résultat en fin de boucle dans un fichier ou autre. Si ton programme est installé aussi sur ta machine qui va x9 plus vite tu as juste à le lancer avec ce résultat intermédiaire et il reprendra tranquillement son cours je pense.

Bon le problème c'est qu'il faut avoir prévu le coup à la création du programme.

[SAKAROV]

Bon le problème c'est qu'il faut avoir prévu le coup à la création du programme.

T'as tout dit, Trudy.

[fred]

A ce niveau là il te suffit d'avoir prévu un système qui écrit le résultat en fin de boucle dans un fichier ou autre.

Ça s'appelle de la sérialisation, c'est ce que j'ai dis plus haut...