Trouver boost :: références cycliques shared_ptr

Question

Y at-il des conseils / astuces pour trouver des références cycliques années shared_ptr?

Ceci est un exmaple de ce que je suis en train de trouver -. Semblent malheureusement je ne peux pas trouver la boucle dans mon code

struct A
{
  boost::shared_ptr<C> anC;
};

struct B
{
  boost::shared_ptr<A> anA;
};

struct C
{
  boost::shared_ptr<B> anB;
};

Answer 1

J'ai utilisé une combinaison des postes ci-dessus. J'ai utilisé une mémoire profileur, venu avec quelques cycles suspects et cassé en utilisant ceux des années weak_ptr.

Je l'ai utilisé le construit dans la détection des fuites de mémoire CRT avant, mais malheureusement, dans mon cas il y a plusieurs singletons statiques qui n'obtiennent désallouée jusqu'à Déchargement du module qui je crois est après le cycle de vie des détecteurs CRT. Fondamentalement, il donne beaucoup de crachent qui sont faux positifs.

Answer 2

Je vous recommande d'utiliser Valgrind . Lorsque vous arrêtez le processus, il vous montrera toute la mémoire fuite. À moins que votre arrêt casse en quelque sorte le cycle, les cycles doivent apparaître comme fuite de mémoire et Valgrind vous dire où dans votre code la mémoire a été allouée à partir.

Answer 3

J'étais responsable de la conception d'un système de risque de crédit une fois (en C ++, bien que ce soit pas pertinent). Ces choses sont des graphiques très gros avec le risque attribués aux noeuds. Nous avons eu une heuristique simple à trouver si nous étions dans un cycle - si nous avons traversé plus de 500 fois (j'oublie le chiffre exact - il était configurable), la réponse est oui. La plupart des systèmes de détection de cycle reposent sur des heuristiques comme celui-ci.

Answer 4

J'ai eu des problèmes similaires dans le passé -. Fuites de mémoire en raison de shared_ptr références cycliques qui est passée inaperçue pendant des mois

Méfiez-vous des "caches". J'ai un objet (appelons-le « Factory ») qui a traité des éléments ( « Widget »). Widgets a la propriété d'être A) Immuable et B) avait un shared_ptr<Factory> à son créateur (parfois créé d'autres widgets, etc.). Tout fonctionnait bien, jusqu'à ce que j'ajouté un cache Widget Factory - puisque les Widgets étaient immuables, il était logique de les mettre en cache, de restituer le même widget à chaque fois il a été demandé. Mon cache était un cache de shared_ptr<Widget>, fuite silencieuse si instantanée. Les corrections sont évidentes, je ne vais pas aller en eux.

En fin de compte j'ai pu appuyer sur la plate-forme que j'utilisais pour détecter les fuites de mémoire du CRT. CRT Visual Studio a la détection de fuite de mémoire et des rapports que je permis à mon programme de test pour éviter les régressions:

int main()
{
    // code code code
    // code code code

#ifdef _MSC_VER
    _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
    _CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );
    _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
    _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDOUT );
    _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
    _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDOUT );
    _CrtDumpMemoryLeaks();
#endif
}

GCC a probablement des rapports de fuite de base similaire, mais je ne sais pas ce qu'elle est.

Answer 5

Je suppose que la réponse la plus simple est qu'il n'y a que tant des pointeurs intelligents peuvent faire pour vous:

Je suggère l'enregistrement chaque fois que vous make une boucle, (facile si vous créez les trois objets à la fois, sinon plus délicat ...), puis vérifier que le dossier où vous supprimez des objets / Délier, ou juste périodiquement si cela est impossible.

Answer 6

Vous pouvez mettre en œuvre une sorte d'interface de débogage qui retourne une liste de shared_ptrs appartenant à cet objet. Vous auriez besoin de le faire pour toutes les classes stockées dans une shared_ptr. Maintenant, vous avez un graphique générique que vous pouvez parcourir, et peut utiliser des algorithmes de détection de cycle sur elle. Je crois que algorithme de composante fortement connexe de Tarjan pourrait fonctionner pour cela, mais la théorie des graphes n'est pas mon point fort.