contention de fil sur l'allocation dynamique de mémoire

Question

Je viens d'apprendre que la fonction de la langue malloc C est la question de discorde de fil lorsqu'il est utilisé dans une application multi-thread.

En C ++ ne souffre operator new du même problème? Si oui, quel tecnhique puis-je utiliser pour éviter ce qui sonne comme une grosse pénalité dans l'exécution de l'application?

Answer 1

Ce « problème » de discorde de fil dépend vraiment de la mise en œuvre. Certaines des mises en œuvre de malloc d'usage courant ont pas été conçus à l'origine avec multithreading à l'esprit. Mais une implémentation de malloc conçu pour les applications multithread ne doit pas souffrir de conflits dans des circonstances normales.

À titre d'exemple d'implémentation de malloc conçu avec multithreading à l'esprit, regardez jemalloc .

Answer 2

En fonction des mises en œuvre de nouvelles, mais comme il est généralement basé malloc oui. Voici quelques chose que vous pouvez faire:

• Utilisez un profileur pour compter le nombre d'appels à malloc() (et peut-être brk()) par seconde, assurez-vous que vous avez un problème de contention avec malloc().
• Essayez de travailler avec un allocateur de mémoire parallèle (ie. thésauriser)
• Utilisez la pile chaque fois qu'il est possible: ne pas appeler de nouveau quand vous n'avez pas besoin. Rappelez-vous aussi que les petites copies sont généralement plus convivial que le cache des pointeurs et des données partagées entre les threads.

Answer 3

  

En C ++ ne l'opérateur nouveau souffre du même problème?

Oui, dans la plupart des implémentations, il fait.

Si vous êtes en C ++ déjà, Threading Building Blocks est une bibliothèque de modèle de C ++ qui devrait convenir vos besoins. Il a, allocateurs évolutive des structures de données, un site et plus ...

Answer 4

Le problème avec les conflits de fil dans malloc se résume simplement que le tas doit être protégé par un mutex de dispositif similaire à chaque fois qu'il est mis à jour. Si deux fils sont mis à jour en même temps le tas, vous aurez une condition de course. Le même problème s'applique à nouveau donc il n'y a pas de raison fondamentale pour laquelle on devrait avoir moins affirmation que les autres.

Cela dit, il y a un certain nombre de trucs pour minimiser les conflits. La première consiste à briser le tas vers le haut dans Arenas séparés. Chaque Arena a sa propre serrure. Si un thread tente d'allouer de la mémoire et celle Arena est verrouillé, il essaie juste d'allouer de la prochaine Arena.

Libère devra accéder à la même arène qui a été utilisé pour une malloc. Cela peut également être optimisée par lieu le pointeur d'être libéré sur une liste libre. Cela peut être fait atomiquement. La prochaine fois que l'Arena devient déverrouillé, tous les pointeurs sur la liste libre vont se libérer correctement.

Ces techniques aident à prévenir, mais ne pas les contentieux qui moyen dans un modèle de thread producteur-consommateur, vous pouvez être mieux d'avoir les pointeurs de passage des consommateurs au producteur où ils peuvent être réutilisés ou supprimées.