61 votes

Le parallélisme dans Julia. Caractéristiques et limites

Dans leur article arXiv les auteurs originaux de Julia mentionnent ce qui suit :

2.14 Parallelism . L'exécution parallèle est assurée par un système de multi-processing basé sur les messages, implémenté en Julia dans la bibliothèque standard. La conception du langage supporte l'implémentation de telles bibliothèques en bibliothèques en fournissant des coroutines symétriques, qui peuvent également être threads planifiés de manière coopérative. Cette caractéristique permet à la communication asynchrone communication asynchrone d'être cachée dans les bibliothèques, plutôt que d'obliger l'utilisateur de mettre en place des callbacks. Julia ne supporte pas actuellement les threads natifs. threads natifs, ce qui est une limitation, mais a l'avantage d'éviter les complexité de l'utilisation synchronisée de la mémoire partagée.

Que veulent-ils dire en disant que Julia ne supporte pas fils natifs ? Qu'est-ce qu'un fil natif ?

Les autres langages interprétés tels que Python ou R supporte ce type de parallélisme ? Julia est-elle seule dans ce cas ?

76voto

StefanKarpinski Points 4873

Les "threads natifs" sont des contextes d'exécution distincts, gérés par le noyau du système d'exploitation, accédant à un espace mémoire partagé et pouvant s'exécuter simultanément sur des cœurs distincts. Comparez cela aux processus distincts, qui peuvent s'exécuter simultanément sur plusieurs cœurs mais disposent d'espaces mémoire séparés. Il est facile de s'assurer que les processus interagissent bien puisqu'ils ne peuvent communiquer entre eux que par l'intermédiaire du noyau. S'assurer que les threads n'interagissent pas de manière imprévisible et boguée est très difficile, car ils peuvent lire et écrire dans la même mémoire de manière illimitée.

La situation de R est assez simple : R n'est pas multithreadé . Python est un peu plus compliqué : Python prend en charge le threading, mais en raison de l'utilisation de la fonction verrouillage global de l'interpréteur (GIL) Dans ce cas, aucune exécution simultanée du code Python n'est possible. D'autres langages dynamiques open source populaires se trouvent dans divers états mitigés en ce qui concerne le threading natif (Ruby : non/un peu/oui ? Node.js : pas de ), mais en général, la réponse est non, ils ne supportent pas le threading natif totalement concurrent, donc Julia n'est pas seule dans ce cas.

Quand nous ajouterons le parallélisme de la mémoire partagée à Julia, comme nous prévoyons de le faire - que l'on utilise des threads natifs ou des processus multiples avec mémoire partagée - il s'agira d'une véritable concurrence et il n'y aura pas de GIL empêchant l'exécution simultanée du code Julia. Cependant, c'est une fonctionnalité incroyablement délicate à ajouter à un langage, comme en témoigne le support inexistant ou limité dans d'autres langages dynamiques matures et très populaires. Ajouter un modèle de concurrence en mémoire partagée est techniquement difficile, mais le vrai problème est de concevoir un modèle de programmation qui permettra aux programmeurs d'utiliser efficacement la concurrence matérielle d'une manière productive et sûre. Ce problème n'est généralement pas résolu et constitue un domaine très actif de recherche et d'expérimentation - il n'y a pas de "norme d'excellence" à copier. Nous pourrions simplement ajouter le support des threads POSIX, mais ce modèle de programmation est généralement considéré comme dangereux et incroyablement difficile à utiliser correctement et efficacement. Go a une excellente histoire de concurrence, mais il est conçu pour écrire des serveurs hautement concurrents, pas pour opérer simultanément sur de grandes données, donc il n'est pas du tout clair que copier simplement le modèle de Go est une bonne idée pour Julia.

6 votes

Merci. Quand vous dites qu'avec Python "no actual concurrent execution of Python code is possible" vous voulez dire au sein du même processus, n'est-ce pas ? D'après ce que je comprends, Python déjà prend en charge le parallélisme en mémoire partagée en utilisant des sous-processus via le paquetage multiprocessing. En d'autres termes, lorsque vous avez dit "When we add [...] it will be true concurrency and there will be no GIL preventing simultaneous execution of Julia code." si vous vous référez au scénario où Julia fait cela avec fils natifs sinon Julia implémenterait le parallélisme en mémoire partagée comme le fait Python. Correct ?

6 votes

Oui, si c'est dans des processus séparés, alors nous ne parlons plus de threading. Il n'est pas clair à ce stade si la nature du parallélisme à mémoire partagée dans Julia sera basée sur des threads ou des processus avec mémoire partagée, et cette distinction est quelque chose de détail d'implémentation dans tous les cas. Le paquetage multiprocessing de Python semble faire une forme de parallélisme multi-processus à mémoire partagée, mais ce n'est pas aussi pratique ou naturel que je le voudrais pour une primitive au niveau du langage.

0 votes

Je dois également souligner que des travaux expérimentaux sur quelque chose comme le paquet multiprocesseur de Python ont été réalisés : groups.google.com/forum/?fromgroups=#!searchin/julia-users/ .

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X