Parallélisme chez Julia. Caractéristiques et limites

Dans leur article arXiv , les auteurs originaux de Julia mentionnent:

2.14 Parallelism . L’exécution parallèle est assurée par un système de traitement multi-processus implémenté dans Julia dans la bibliothèque standard. La conception du langage prend en charge l’implémentation de telles bibliothèques en fournissant des coroutines symésortingques, qui peuvent également être considérées comme des threads programmés en coopération. Cette fonctionnalité permet de masquer les communications asynchrones dans les bibliothèques, plutôt que de demander à l’utilisateur de configurer des rappels. Julia ne supporte pas actuellement les threads natifs, ce qui est une limitation, mais a l’avantage d’éviter les complexités liées à l’utilisation synchronisée de la mémoire partagée.

Que signifient-ils en disant que Julia ne supporte pas les threads natifs ? Qu’est-ce qu’un fil natif?

Est-ce que d’autres langages interprétés tels que Python ou R supportent ce type de parallélisme? Est-ce que Julia est seule dans ça?

Les «threads natifs» sont des contextes d’exécution distincts, gérés par le kernel du système d’exploitation, accédant à un espace mémoire partagé et pouvant être exécutés simultanément sur des cœurs distincts. Comparez cela avec des processus séparés, qui peuvent être exécutés simultanément sur plusieurs cœurs mais ont des espaces mémoire distincts. S’assurer que les processus interagissent bien est facile car ils ne peuvent communiquer que via le kernel. S’assurer que les threads n’interagissent pas de manière imprévisible, c’est très difficile, car ils peuvent lire et écrire dans la même mémoire sans ressortingction.

La situation R est assez simple: R n’est pas multithread . Python est un peu plus compliqué: Python supporte les threads, mais en raison du locking global de l’interpréteur (GIL) , aucune exécution simultanée du code Python n’est possible. Les autres langages dynamics open source les plus répandus sont différents en termes de threading natif (Ruby: no / kinda / yes ?; Node.js: non ), mais en général, la réponse est non, ils ne supportent pas les threads natifs totalement concurrents , alors Julia n’est pas la seule à faire ça.

Lorsque nous ajoutons un parallélisme de mémoire partagée à Julia, comme nous le prévoyons – que ce soit en utilisant des threads natifs ou plusieurs processus avec de la mémoire partagée – ce sera une véritable concurrence et il n’y aura pas de GIL empêchant l’exécution simultanée du code Julia. Cependant, il s’agit d’une fonctionnalité incroyablement délicate à append à une langue, comme en témoigne la prise en charge inexistante ou limitée dans d’autres langages dynamics matures très populaires. L’ajout d’un modèle de concurrence par mémoire partagée est techniquement difficile, mais le véritable problème consiste à concevoir un modèle de programmation qui permettra aux programmeurs d’utiliser efficacement la simultanéité matérielle de manière productive et sûre. Ce problème n’est généralement pas résolu et constitue un domaine de recherche et d’expérimentation très actif – il n’ya pas de «norme de référence» à copier. Nous pourrions simplement append 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 possède une excellente histoire de simultanéité, mais elle est conçue pour écrire des serveurs hautement concurrents, et non pour opérer simultanément sur des données volumineuses. Il n’est donc pas évident que copier simplement le modèle de Go est une bonne idée pour Julia.