Je ne sais pas si le jeu en vaut la chandelle, tout dépend du but, mais en tout cas il est exigeant. Le sujet est intéressant, mais si on veut faire bien les choses, je pense que déjà, la question doit être précisée parce qu'on ne sait pas trop ce qu'on cherche :
que mesure-t-on ?
que compare-t-on ?
quelle définition de green threads utilise-t-on ? (est-ce qu'on prend en compte tous les styles de threads en espace utilisateur possibles, en incluant des choses du style des go-routines, réparties efficacement sur plusieurs threads systèmes, ou se limite-t-on aux green threads de Java, tournant tous sur le même thread système abandonnés dans le début des années 2000 vues les limitations ?)
sur quel genre de charge de travail ? (les résultats seront probablement différent si on fait de l'I/O, des opérations bloquantes ou du calcul pur)
Et ensuite, il faudrait le jouer complètement avec des mesures et une démarche rigoureuse convaincante. J'ai été un peu sévère en jugeant tes mesures, et ce n'est pas pour être pénible, c'est juste qu'il y a mille et une manière de foirer ses mesures sur ce genre de chose. Je le sais, j'ai fait des études dans un domaine relatif à ce genre de questions, puis travaillé dans une équipe de recherche et été entouré de gens travaillant sur des questions de perf. C'est compliqué à faire correctement. Ce n'est pas ma spécialité, mais je vais avoir du mal à trouver les résultats fiables sans ça.
Ton script illustre que de l'asynchrone sur 1 thread pour faire 3 opérations d'I/O probablement bloquantes "suffisamment longues" est plus lent que 3 threads pour faire ces opérations en parallèle. Ok, en fait, l'inverse m'aurait étonné. C'est super d'avoir fait l'effort de mesurer et en plus de publier le script, ça permet une discussion concrète (et ça expose à la critique). Il a d'ailleurs permis de préciser les choses. Mais pour moi ça ne répond pas vraiment au problème qu'on a du mal à poser : est-ce que les green threads* sont plus efficaces que les threads natifs ? et dans quels cas ? (je m'attends à des résultats variés selon la charge de travail). En même temps, la question est vaste en fait !
C'est beaucoup de travail, c'est presque de la recherche. Il faut clairement poser le problème, éventuellement faire un état de l'art (des mesures existantes, types de charges de travail typiques, des techniques d'ordonnancement des threads système et en espace utilisateur), proposer un protocole expérimental rigoureux, l'appliquer et exploiter les résultats. Ça peut être fun et des gens adorent faire ça, mais clairement, je n'ai pas prévu de le faire maintenant xD. Il y a probablement des papiers là dessus, je n'ai malheureusement rien trouvé de récent après une recherche rapide. Il y a peut-être des choses intéressantes à ce sujet du côté de Go ou Haskell mais une recherche rapide n'a rien donné non plus. Il y a peut-être des articles de blog détaillés sur le sujet :-)
* disons, les threads en espace utilisateur, je suis assez persuadé que les greens threads limités de Java il y a 20 ans n'étaient pas vraiment performants - ce n'était d'ailleurs pas vraiment leur objectif, leur objectif c'était il me semble surtout de ne pas trop dépendre des spécificités de chaque système d'exploitation pour avoir un mécanisme plus ou moins concurrent.
[^] # Re: Des bonnes idées
Posté par raphj (site web personnel) . En réponse à la dépêche Les nouvelles fonctionnalités de PHP 8. Évalué à 2. Dernière modification le 06 décembre 2020 à 23:25.
Je ne sais pas si le jeu en vaut la chandelle, tout dépend du but, mais en tout cas il est exigeant. Le sujet est intéressant, mais si on veut faire bien les choses, je pense que déjà, la question doit être précisée parce qu'on ne sait pas trop ce qu'on cherche :
Et ensuite, il faudrait le jouer complètement avec des mesures et une démarche rigoureuse convaincante. J'ai été un peu sévère en jugeant tes mesures, et ce n'est pas pour être pénible, c'est juste qu'il y a mille et une manière de foirer ses mesures sur ce genre de chose. Je le sais, j'ai fait des études dans un domaine relatif à ce genre de questions, puis travaillé dans une équipe de recherche et été entouré de gens travaillant sur des questions de perf. C'est compliqué à faire correctement. Ce n'est pas ma spécialité, mais je vais avoir du mal à trouver les résultats fiables sans ça.
Ton script illustre que de l'asynchrone sur 1 thread pour faire 3 opérations d'I/O probablement bloquantes "suffisamment longues" est plus lent que 3 threads pour faire ces opérations en parallèle. Ok, en fait, l'inverse m'aurait étonné. C'est super d'avoir fait l'effort de mesurer et en plus de publier le script, ça permet une discussion concrète (et ça expose à la critique). Il a d'ailleurs permis de préciser les choses. Mais pour moi ça ne répond pas vraiment au problème qu'on a du mal à poser : est-ce que les green threads* sont plus efficaces que les threads natifs ? et dans quels cas ? (je m'attends à des résultats variés selon la charge de travail). En même temps, la question est vaste en fait !
C'est beaucoup de travail, c'est presque de la recherche. Il faut clairement poser le problème, éventuellement faire un état de l'art (des mesures existantes, types de charges de travail typiques, des techniques d'ordonnancement des threads système et en espace utilisateur), proposer un protocole expérimental rigoureux, l'appliquer et exploiter les résultats. Ça peut être fun et des gens adorent faire ça, mais clairement, je n'ai pas prévu de le faire maintenant xD. Il y a probablement des papiers là dessus, je n'ai malheureusement rien trouvé de récent après une recherche rapide. Il y a peut-être des choses intéressantes à ce sujet du côté de Go ou Haskell mais une recherche rapide n'a rien donné non plus. Il y a peut-être des articles de blog détaillés sur le sujet :-)
*disons, les threads en espace utilisateur, je suis assez persuadé que les greens threads limités de Java il y a 20 ans n'étaient pas vraiment performants - ce n'était d'ailleurs pas vraiment leur objectif, leur objectif c'était il me semble surtout de ne pas trop dépendre des spécificités de chaque système d'exploitation pour avoir un mécanisme plus ou moins concurrent.