Discussion :

[gasche]

Je suis passé voir la réponse de la FAQ à ce sujet.

En l'état des choses, le multi-coeur n'est pas exploitable en OCaml.

Ça n'est pas vrai. Les threads caml ne peuvent pas tourner à plusieurs simultanément, mais les processus, créés avec fork, sont gérés par le système d'exploitations et sont donc souvent répartis sur les différents processeurs/coeurs de la machine.

Des tests avaient été faits, et pour des tâches qui se prêtent bien au parallélisme, fork est redoutablement efficace : si on a 4 coeur, le programme va effectivement 4 fois plus vite que sur un seul coeur (et pas 2 fois ou 3 fois comme avec certaines technologies qui ajoutent beaucoup en complexité, et donc masquent un peu le gain de performances).

[SpiceGuid]

Ma réponse reste quand même valable sous Windows où j'ai un message "Unix.fork not implemented".

Peut être sous Linux alors:

Code :

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

1
2
3
4
# #load "unix.cma";;
# Unix.fork ();;
- : int = 0
# - : int = 5760

Mais je ne peux pas vérifier: mon noyau est compilé avec SMP=no

Vu que fork est dépendant de l'OS je propose de scinder la question:

1. Comment utiliser le double-coeur/multi-coeur (multithreading) sous Windows ?
2. Comment utiliser le double-coeur/multi-coeur (multithreading) sous Unix/Linux ?

Par contre je n'ai pas les connaissances pour la réponse à la seconde question.
Si quelqu'un pouvait poster une source minimaliste dans Page code source, avec un Unix.fork qui faut chauffer deux coeurs, ça serait un geste apprécié.

[gasche]

D'une part, la version Cygwin supporte fork. D'autre part create_process est implémenté dans les versions MinGW et Visual-pouet, et apporte la fonctionnalité (en un peu plus lourd à utiliser).

[InOCamlWeTrust]

On en a déjà discuté des milliers de fois dans le forum Caml.

La seule réponse vraiment sensée est "******", pour plusieurs raisons :

- c'est pas géré par OCaml
- la Caml Team a déjà dit plusieurs fois qu'ils ne l'implanteraient pas, jamais, never, nunca, mai, niekagda (pa ruski...)
- le faire par fork demande que :
- l'OS sache le faire
- que l'algorithme s'y prête
- que les processus ne communiquent pas trop entre eux, car dans le cas contraire, le gain de temps serait annulé par la perte occasionnée à gérer les communications et les blocages entre processus

... et l'argument massu :

- c'est pas portable

Donc bon...

[smatador]

Tiens, je serai curieux de savoir comment les autres langages fonctionnels prennent en charge ces questions de multithreading/processeurs multi-coeurs.

PS: Je crois qu'il y a une faute dans le titre : Généralités sur les langages fonctionnelles

[LLB]

Tiens, je serai curieux de savoir comment les autres langages fonctionnels prennent en charge ces questions de multithreading/processeurs multi-coeurs.

En F#, c'est facile (certains trouveront tout un tas d'inconvénients, passant par le GC multithread, mais au moins c'est — semble-t-il — portable). Il existe un certain nombre de fonctions pour gérer ça. Pour les entrées/sorties asynchrones, on passe souvent par une monade, qui gère tous les callbacks toute seule.

Pour lancer un calcul en parrallèle, il y a un type AsyncFuture. Il est exécuté dans un autre thread (un autre coeur, si possible). Et quand le thread principal essaie d'accéder à sa valeur, il attend la fin du calcul. Ca permet de faire une parrallélisation simple, mais qui est insuffisante quand on a de nombreux coeurs.

Il y a aussi une fonction pour lancer en parrallèle des calculs et qui renvoie un tableau avec tous les résultats. Ca passe par la threadpool de .Net, tout se fait tout seul et tous tes coeurs sont utilisés.

Ensuite, il existe aussi une mailbox pour gérer les messages entre threads. C'est inspiré du système d'Erlang, à ce qu'il parait. Il y a aussi des bibliothèques .Net qui ne sont pas spécifiques à F#. Je les connais peu.


Dans les autres langages fonctionnels, Erlang s'en sort assez bien, évidemment. Le reste, je connais mal.