Pourquoi la parallélisation d'un calcul de moyenne mobile Go avec des Goroutines a-t-elle entraîné une dégradation des performances ?

Contexte

Ce problème consiste à optimiser une fonction Go pour calculer la moyenne mobile d'une tranche. La fonction est intrinsèquement parallèle et embarrassante, ce qui signifie qu'elle peut être facilement divisée en tâches indépendantes qui peuvent être exécutées simultanément.

Tentatives d'optimisation et résultats

Le développeur a tenté de paralléliser la fonction à l'aide de goroutines en deux façons :

• Moving_avg_concurrent2 : La tranche a été divisée en morceaux plus petits, et chaque morceau a été traité par une goroutine distincte.
• Moving_avg_concurrent3 : Le paradigme maître/travailleur a été adopté, où une goroutine maître a engendré plusieurs goroutines de travail pour calculer la moyenne mobile de différentes fenêtres de la tranche d'entrée.

Les benchmarks ont montré que les deux approches concurrentes fonctionnaient moins bien que la fonction série d'origine moving_avg_serial4.

Pourquoi moving_avg_concurrent2 ne s'adapte-t-il pas ?

La raison pour laquelle moving_avg_concurrent2 ne s'adapte pas est que les frais généraux liés à la création et à la gestion des goroutines l'emportent sur les avantages du parallélisme. Dans ce cas, les frais généraux incluent le temps consacré à la création et à la planification des goroutines, ainsi que le temps consacré à la communication et à la synchronisation entre les goroutines.

Pourquoi moving_avg_concurrent3 est-il beaucoup plus lent que moving_avg_serial4 ?

Le paradigme maître/ouvrier introduit une surcharge supplémentaire par rapport à l'approche goroutine directe. Dans moving_avg_concurrent3, il est nécessaire de créer un canal de communication entre les goroutines maître et travailleur, et de gérer l'envoi et la réception des unités de travail. Cette surcharge dégrade encore davantage les performances de la fonction.

Est-il possible que la surcharge de goroutine génère autant de surcharge ?

Oui, il est possible que la surcharge de goroutine puisse avoir un impact significatif sur les performances d'un programme. Les Goroutines sont des threads légers, mais ils entraînent néanmoins une certaine surcharge associée à leur création, leur planification et leur synchronisation. Dans le cas de moving_avg_concurrent3, la surcharge liée à la gestion du canal et à la communication maître/travailleur s'ajoute au temps d'exécution de la fonction.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!