Linux C++: comment le profil de temps perdu en raison des défauts de cache?

Vous pouvez trouver un outil qui accède à la CPU compteurs de performance. Il y a probablement un registre dans chaque cœur qui compte L1, L2, etc rate. Alternativement Cachegrind effectue un cycle-par-cycle de simulation.

Cependant, je ne pense pas que ce serait perspicace. Votre proxy objets sont sans doute modifiées par leurs propres méthodes. Un classique profiler vous dire combien de temps ces méthodes sont en train de prendre. Aucun outil profil vous dira comment la performance ne s'améliore sans que la source de la pollution du cache. C'est une question de la réduction de la taille et de la structure du programme de travail de l'ensemble, qui n'est pas facile d'extrapoler.

Une rapide recherche sur Google tourné boost::intrusive_ptr qui pourraient vous intéresser. Il n'apparaît pas à l'appui de quelque chose comme weak_ptr, mais la conversion de votre programme est peut-être trivial, et ensuite, vous savez pour sûr, le coût de la non-intrusive réf compte.

Il dépend de l'OS et du PROCESSEUR que vous utilisez. E. g. pour Mac OS X et x86 ou ppc, Requin fera le cache de profilage. Idem pour Zoom sur Linux.

En continuant le long de la lignes de @Mike_Dunlavey réponse:

Tout d'abord, obtenir une heure selon profil, à l'aide de votre outil préféré: VTune ou PTU ou OProf.

Ensuite, obtenir un cache miss profil. L1 échecs de cache L2 cache, ou ...

I. e. le premier profil associe un "temps passé" avec chaque compteur de programme.
La seconde associe un "certain nombre de défauts de cache" valeur à chaque compteur de programme.

Note: j'ai souvent de "réduire" les données, en résumé par la fonction, ou (si j'ai de la technologie) en boucle. Ou en bacs, par exemple, à 64 octets. Comparer les programme de compteurs est souvent pas utile, parce que les compteurs de performance sont floue - l'endroit où vous pouvez voir un cache miss signalés est souvent de plusieurs instructions différentes de celles dans lesquelles il s'est réellement passé.

OK, alors maintenant, graphique ces deux profils afin de les comparer. Voici quelques graphiques que je trouve utile:

"Iceberg" graphiques: l'axe X est PC, axe Y positif temps, négatif Y accéder est de défauts de cache. Recherchez les endroits qui vont à la fois en haut et en bas.

("Entrelacé" cartes sont aussi utiles: même idée, l'axe X est l'ordinateur, de l'intrigue à la fois du temps et de cache misseson l'axe des Y, mais avec d'étroites lignes verticales de différentes couleurs, notamment le rouge et le bleu. Des endroits où c'est beaucoup de temps et de défauts de cache passé aurez finement entrelacés lignes rouges et bleues et presque à la recherche de pourpre. Cela s'étend aux L2 et L3 cache, tous sur le même graphique. Par la manière, vous voulez probablement à "normaliser" le nombre, soit de %age du total des temps ou les défauts de cache, ou, encore mieux, en %age du point de données maximal de temps ou de défauts de cache. Si vous obtenez l'échelle de mal, vous ne verrez rien.)

Graphiques XY: pour chaque échantillonnage bin (PC ou d'une fonction, ou d'une boucle, ou...) de la parcelle un point dont les coordonnée X est le normalisé de temps, et dont la coordonnée Y est normalisé cache. Si vous obtenez beaucoup de points de données dans le coin supérieur droit - large %de l'âge de l'heure ET de grandes %de l'âge de cache - qu'il est intéressant de preuve. Ou, oubliez le nombre de points - si la somme de tous les pourcentages dans le coin supérieur est grand...

Constater, hélas, que vous avez souvent à rouler ces analyses vous-même. Dernière, j'ai vérifié VTune ne pas le faire pour vous. J'ai utilisé gnuplot et Excel. (Avertissement: Excel meurt au-dessus de 64 milliers de points de données.)

---

Plus de conseils:

Si votre pointeur intelligent est incorporé, vous pouvez obtenir le compte tous sur la place. Dans un monde idéal, vous pourriez être en mesure de retracer le Pc à l'origine de la ligne de code source. Dans ce cas, vous pouvez reporter la réduction un peu: regardez tous les Ordinateurs individuels; carte de retour à des lignes de code source; et puis la carte de ceux que la fonction d'origine. De nombreux compilateurs, p. ex. la CGC, ont de la table des symboles des options qui vous permettent de faire cela.

Par la manière, je pense que votre problème n'est PAS avec le pointeur intelligent provoquant cache raclée. Sauf si vous faites de smart_ptr<int> tous sur la place. Si vous faites smart_ptr<Obj>, et sizeof(Obj) + est supérieure à dire, 4*sizeof(Obj*) (et si le smart_ptr lui-même n'est pas énorme), alors il n'est pas beaucoup.

Plus il est probable que le niveau supplémentaire d'indirection que le pointeur intelligent ne, qui est à l'origine de votre problème.

Hasard, je parlais à un gars au déjeuner qui a eu une référence compté pointeur intelligent qui a été à l'aide d'une poignée, c'est à dire un niveau d'indirection, quelque chose comme

template<typename T> class refcntptr {
    refcnt_handle<T> handle;
public:
    refcntptr(T*obj) {
        this->handle = new refcnt_handle<T>();
        this->handle->ptr = obj;
        this->handle->count = 1;
    }
};
template<typename T> class refcnt_handle {
    T* ptr;
    int count;
    friend refcnt_ptr<T>;
};

(Je n'aurais pas le code de cette façon, mais il sert pour l'exposition.)

La double indirection this->handle->ptr peut être un gros problème de performance. Ou même un triple indirection, this->handle->ptr->champ. Au moins, sur une machine avec 5 cycle de L1 cache, chaque this->handle->ptr->champ faudrait 10 cycles. Et beaucoup plus de difficultés à se chevauchent qu'un seul pointeur chase. Mais, pire encore, si chacun d'eux est un cache L1 de manquer, même si c'était seulement de 20 cycles pour la L2... eh bien, il est beaucoup plus difficile de cacher 2*20=40 cycles de cache miss latence, qu'un seul L1 manquer.

En général, il est de bon conseil pour éviter les niveaux d'indirection dans des pointeurs intelligents. Au lieu de pointer vers une poignée, que tous les pointeurs intelligents de pointe, qui lui-même les points de l'objet, vous pourriez faire le pointeur intelligent plus en le faisant pointer vers l'objet ainsi que la poignée. (Qui n'est alors plus de ce qui est communément appelé une poignée, mais il est plus comme un objet info.)

E. g.

template<typename T> class refcntptr {
    refcnt_info<T> info;
    T* ptr;
public:
    refcntptr(T*obj) {
        this->ptr = obj;
        this->info = new refcnt_handle<T>();
        this->info->count = 1;
    }
};
template<typename T> class refcnt_info {
    T* ptr; //perhaps not necessary, but useful.
    int count;
    friend refcnt_ptr<T>;
};

De toute façon - un profil de temps est votre meilleur ami.

---

Oh, oui - Intel EMON matériel peut également vous dire combien de cycles vous attendait à un PC. Qui peut distinguer un grand nombre de L1 manque d'un petit nombre de L2 manque.

Un autre outil pour le CPU compteur de performance basé sur le profilage est oprofile. Vous pouvez afficher les résultats à l'aide de kcachegrind.