Aujourd'hui, je faisais l'exercice de la bague de fil du livre Erlang et googlé pour d'autres solutions à comparer. J'ai constaté que la fusillade de la langue a exactement le même problème qu'un Benchmark . J'ai eu l'impression que c'est une zone où Erlang devrait être rapide, mais s'avère que c et C ++ sont à nouveau sur le dessus. Mon soupçon est que les programmes C / C ++ ne suivent pas les règles qui disent "passent le jeton du thread à thread". Après les avoir lu, il semble que les deux manipulent certaines de la mémoire partagée et des variables mondiales différentes du code Erlang, mais je pourrais me tromper.
Ma question est la suivante: font-ils la même chose ou le code C / C ++ est conceptuellement différent (et plus rapide) de l'Erlang One?
Et une autre question: Pourquoi Haskell est-il plus rapide que Erlang lorsque les solutions sont très similaires?
7 Réponses :
La version C utilise LWP, que je pense est une bibliothèque de filetage de l'espace utilisateur. Dans quelle mesure cela est "injuste", c'est à la recherche de débats: je regarderais des choses comme si elle prend en charge la vraie concurrence préventive en ce sens que vous pouvez faire des appels de système de blocage dans un fil sans bloquer tous les autres threads (vous pouvez Faites cela à Haskell, pouvez-vous à Erlang?).
Les threads de Haskell sont légèrement plus légers que ceux d'Erlang, car comme je le comprends, un thread Erlang est livré avec un tas local (dans la mise en œuvre standard), tandis que Haskell threads tous partagent le même tas.
Minimal. Vous pouvez créer des milliers de threads sans rencontrer de problèmes de mémoire.
Combien, comparer avec 300 octets d'Erlang?
Un thread de GHC est représenté par un objet State thread: Hackage .HASKELL.ORG / TRAC / GHC / Wiki / Commentaire / RTS / Stockage / ... . Vous pouvez faire les mathématiques vous-même en regardant la définition: Darcs.hakell. Org / GHC / Comprend / RTS / STOCKAGE / TSO.H
@DJV 68 octets sur une machine 32 bits, 112 octets sur une machine 64 bits (peut varier légèrement en fonction de la version de GHC). Plus la pile, qui est variable et étendue à la demande: par défaut, nous allouons des piles de 1k.
En fin de compte, la transmission de messages sur des machines modernes est mise en œuvre à l'aide d'une forme de mémoire partagée pour transmettre les messages (avec des verrous ou des instructions atomiques). Donc, toutes les implémentations C et C ++ font réellement incroyent la mise en œuvre de messages passant directement dans leur code. Un indice de référence similaire qui utilise une bibliothèque de messages rapides en C, également comparé contre Haskell et Erlang, peut être trouvé dans cet article: http://www.cs.kent.ac.uk/pubs/2009/2928/index.html (Section 5.1)
La vitesse des différentes approches est vraiment déterminée par les systèmes d'exécution concurrents impliqués. Haskell a eu beaucoup de bon travail dans cette région, ce qui le laisse devant Erlang. Bien entendu, la vitesse de mesure des micro-repères est souvent erronée et laisse des facteurs importants comme la lisibilité du code. Une question à garder à l'esprit pourrait être: laquelle des solutions dans la fusillade seriez-vous heureux de maintenir?
dépend de lequel on gagne plus d'argent :)
>> Bien entendu, la vitesse de mesure sur les micro-repères est souvent erronée et laisse des facteurs importants comme la lisibilité du code. << Quelle est l'une des raisons pour lesquelles le jeu de référence montre le code source du programme ;-)
Je ne pense pas que j'appellerais ça tricher. La différence principale et fondamentale entre plusieurs threads et plusieurs processus est que plusieurs threads partagent un espace d'adresses unique. En tant que tel, spécifier de multiples threads (plutôt que plusieurs processus) me semble que la permission tacite profite de l'espace d'adresses partagé (au moins en l'absence d'une définition très spécifique de «passage» qui l'interdisait).
Ce qu'il va, c'est que: Erlang n'a pas vraiment de threads, en tant que tels, il possède des processus avec des communications asynchrones. Les processus sont (intentionnellement) isolés les uns des autres dans une large mesure. D'une part, cela rend le développement considérablement plus facile - en particulier, un processus ne peut affecter que d'une autre via des canaux de communication spécifiques et bien définis. Sous la hotte, il utilise de nombreuses astuces (y compris une mémoire partagée presque certainement) pour optimiser ses processus et tirer parti de ce qui est possible dans une implémentation / une situation spécifique (telle que tous les processus exécutés dans un seul espace d'adresse partagé). Néanmoins, devoir garder toutes les astuces cachées empêche d'être aussi efficace que quelque chose comme la version C où les "astuces" sont toutes explicites et complètement exposées.
J'utiliserais une analogie réelle pour expliquer la différence. Pensez aux threads / processus en tant que personnes. Erlang applique une relation de travail professionnelle où les communications sont toutes soigneusement enregistrées dans les mémos. Les versions C et C ++ sont plus comme un mari et une femme qui pourraient communiquer avec un seul mot qui ne veut rien dire à personne d'autre, voire un seul coup d'œil rapide.
Ce dernier est extrêmement efficace quand il fonctionne - mais c'est beaucoup plus ouvert aux malentendus subtils et si les deux ont un combat, vous ne voulez probablement pas être dans la même pièce. Pour le responsable, les personnes dans des relations purement professionnelles sont beaucoup plus faciles à gérer même si leur efficacité maximale n'est pas assez élevée.
Certaines de ces comparaisons sont celles des pommes et des oranges. La raison en est que si vous voulez seulement que les choses puissent aller rond très rapide, alors bien sûr, vous pouvez le faire autant plus rapide en C et C ++. Le point IMHO est que Erlang gère beaucoup plus encore alors simplement "envoyer un jeton entre les processus" (ce sont des processus BTW non threads;)). J'ai écrit un article sur certaines des différences il y a un moment; Vérifiez la peine de choisir: forum.Trapexit.org/viewtopic.php?t=15194 et Trapexit.org/process_ring_across_nodes
C'est un bon exemple et la définition que vous donnez est quelque chose que je voudrais attendre de toutes les solutions. Quelqu'un a-t-il essayé de le réécrire dans une autre langue, des résultats? De plus, pouvez-vous penser à une référence à monoconque où Erlang pourrait exceller en termes de vitesse?
Le point Joe Armstrong faisait était simplement "le passage du message entre les processus de sommeil à Erlang est très rapide. ... Java est d'environ 5 à 10 fois plus lent." (Les programmeurs Java ont réduit cette différence.) [Mesures de performance des threads en Java et processus à Erlang 1998-11-02]