Exemples convaincants de la coutume, C++ allocateurs?

Comme je le mentionne ici, j'ai vu Intel TBB personnalisé STL allocateur d'améliorer sensiblement les performances d'une application multithread, simplement en changeant un seul

std::vector<T>

à

std::vector<T,tbb::scalable_allocator<T> >

(c'est un moyen rapide et pratique de commutation de l'allocateur d'utiliser TBB est chouette thread-privé tas; voir à la page 7 de ce document)

Je suis en train de travailler sur un mmap-allocateur qui permet vecteurs pour utiliser la mémoire de
un fichier mappé en mémoire. Le but est d'avoir des vecteurs que l'utilisation de stockage que
sont directement dans la mémoire virtuelle obtenue par mmap. Notre problème est de
améliorer la lecture de gros fichiers (>10 GO) dans la mémoire avec aucune copie
les frais généraux, donc j'ai besoin de cet allocateur personnalisé.

Jusqu'à présent j'ai le squelette d'un allocateur personnalisé
(qui dérive de std::allocator), je pense que c'est un bon départ
point d'écrire propre allocateurs. N'hésitez pas à utiliser ce bout de code
quelle que soit la façon dont vous le souhaitez:

#include <memory>
#include <stdio.h>

namespace mmap_allocator_namespace
{
        //See StackOverflow replies to this answer for important commentary about inheriting from std::allocator before replicating this code.
        template <typename T>
        class mmap_allocator: public std::allocator<T>
        {
public:
                typedef size_t size_type;
                typedef T* pointer;
                typedef const T* const_pointer;

                template<typename _Tp1>
                struct rebind
                {
                        typedef mmap_allocator<_Tp1> other;
                };

                pointer allocate(size_type n, const void *hint=0)
                {
                        fprintf(stderr, "Alloc %d bytes.\n", n*sizeof(T));
                        return std::allocator<T>::allocate(n, hint);
                }

                void deallocate(pointer p, size_type n)
                {
                        fprintf(stderr, "Dealloc %d bytes (%p).\n", n*sizeof(T), p);
                        return std::allocator<T>::deallocate(p, n);
                }

                mmap_allocator() throw(): std::allocator<T>() { fprintf(stderr, "Hello allocator!\n"); }
                mmap_allocator(const mmap_allocator &a) throw(): std::allocator<T>(a) { }
                template <class U>                    
                mmap_allocator(const mmap_allocator<U> &a) throw(): std::allocator<T>(a) { }
                ~mmap_allocator() throw() { }
        };
}

Pour l'utiliser, déclarer un conteneur STL comme suit:

using namespace std;
using namespace mmap_allocator_namespace;

vector<int, mmap_allocator<int> > int_vec(1024, 0, mmap_allocator<int>());

Il peut être utilisé par exemple pour ouvrir une session chaque fois que la mémoire est allouée. Ce qui est nécessaire
est le relier struct, sinon le vecteur contenant utilise le super-classes allouer/désallouer
des méthodes.

Mise à jour: Le mappage de la mémoire de l'allocateur est maintenant disponible à https://github.com/johannesthoma/mmap_allocator et LGPL. N'hésitez pas à utiliser pour vos projets.

Il peut être utile d'utiliser des allocateurs de l'utilisation d'un pool de mémoire au lieu de le tas. C'est un exemple parmi beaucoup d'autres.

Pour la plupart des cas, c'est certainement une optimisation prématurée. Mais il peut être très utile dans certains contextes (périphériques intégrés, jeux, etc).

Lorsque l'on travaille avec des Gpu ou d'autres co-processeurs, il est quelquefois préférable d'allouer des structures de données dans la mémoire principale dans un manière spéciale. Cette manière spéciale de l'allocation de mémoire peuvent mises en œuvre dans un allocateur personnalisé dans une commode de la mode.

La raison pour laquelle l'allocation personnalisée grâce à l'accélérateur d'exécution peut être utile lors de l'utilisation des accélérateurs est la suivante:

1. par le biais de l'allocation personnalisée à l'accélérateur d'exécution ou le conducteur est informé du bloc de mémoire
2. en outre, le système d'exploitation peut assurez-vous que le bloc alloué de la mémoire est page verrouillée (certains appellent cela épinglé mémoire), c'est la mémoire virtuelle sous-système du système d'exploitation ne peut pas se déplacer ou supprimer la page à l'intérieur ou à partir de la mémoire
3. si 1. et 2. maintenez et un transfert de données entre une page verrouillée bloc de mémoire et un accélérateur est sollicité, le runtime peut accéder directement aux données dans la mémoire principale depuis qu'il sait où il est et il peut être sûr que le système d'exploitation n'a pas déplacer/supprimer
4. cela permet de gagner une copie de la mémoire qui pourraient se produire avec une mémoire qui a été allouée à un non-page verrouillée façon: les données doivent être copiées dans la mémoire principale pour une page verrouillée de la zone de transit de l'accélérateur permet d'initialiser le transfert de données (par DMA)

Je suis à l'aide d'un allocateur personnalisé pour compter le nombre d'allocations/deallocations dans une partie de mon programme et de mesurer combien de temps cela prend. Il y a d'autres façons cela pourrait être réalisé, mais cette méthode est très pratique pour moi. Il est particulièrement utile que je peux utiliser l'allocateur personnalisé pour seulement un sous-ensemble de mes conteneurs.

Un exemple de j'ai le temps, j'ai utilisé ces a été de travailler avec des ressources très limitées des systèmes embarqués. Disons que vous avez 2k de ram libre et votre programme doit utiliser une partie de la mémoire. Vous avez besoin de stocker dire 4-5 séquences quelque part qui n'est pas sur la pile, et de plus, vous devrez avoir accès précis sur l'endroit où ces choses sont stockés, c'est une situation où vous pourriez écrire votre propre allocateur. Les implémentations par défaut peut fragment de la mémoire, ce qui pourrait être inacceptable si vous n'avez pas assez de mémoire et ne peut pas redémarrer votre programme.

Un projet sur lequel je travaillais a l'aide de AVR-GCC sur certaines puces de faible puissance. Nous avons eu de stocker 8 séquences de longueur variable, mais avec un maximum. Le la bibliothèque standard de mise en œuvre de la gestion de la mémoire est une fine enveloppe de malloc/free qui garde la trace de l'endroit où placer les éléments avec en les préfixant chaque bloc alloué de la mémoire avec un pointeur à peine passé la fin de ce qui est prévu morceau de mémoire. Lors de l'attribution d'un nouveau morceau de la mémoire de l'allocateur standard doit marcher sur chacun des morceaux de la mémoire pour trouver le bloc suivant qui est disponible lorsque la taille demandée de mémoire de forme. Sur une plateforme de bureau, ce serait très rapide de ces quelques éléments, mais vous devez garder à l'esprit que certains de ces microcontrôleurs sont très lents et primitive dans la comparaison. En outre, la fragmentation de la mémoire problème était un problème de masse qui veut dire que nous avons vraiment eu d'autre choix que de prendre une approche différente.

Ce que nous avons fait a été de mettre en œuvre notre propre pool de mémoire. Chaque bloc de mémoire était assez grand pour s'adapter à la plus grande séquence nous aurions besoin. Cette fixes réparties de la taille des blocs de mémoire à l'avance et qui a marqué des blocs de mémoire sont actuellement en cours d'utilisation. Nous l'avons fait en gardant un entier à 8 bits où chaque bit représenté, si un bloc a été utilisé. Nous avons échangé hors de l'utilisation de la mémoire ici pour tenter de rendre l'ensemble du processus plus rapide, ce qui dans notre cas a été justifiée comme nous avancions ce microcontrôleur de la puce proche de son maximum de capacité de traitement.

Il y a un certain nombre d'autres fois je peux voir de la rédaction de votre propre allocateur personnalisé dans le contexte des systèmes embarqués, par exemple, si la mémoire de la séquence n'est pas dans la ram principale comme on peut souvent le cas sur les ces plates-formes.

Pour la mémoire partagée, il est essentiel que non seulement le conteneur tête, mais aussi les données qu'il contient sont stockées dans la mémoire partagée.

L'allocateur de Boost::Interprocessus est un bon exemple. Cependant, comme vous pouvez le lire ici ce allone ne suffit pas, pour rendre tous les conteneurs STL mémoire partagée compatible (en Raison de différents cartographie des décalages dans les différents processus, les pointeurs peut "casser").

Personnellement, j'utilise Loki::Allocator /SmallObject optimiser l'utilisation de mémoire pour les petits objets — il, montrent une bonne efficacité et des performances satisfaisantes si vous avez à travailler avec des quantités modérées de très petits objets (de 1 à 256 octets). Il peut être jusqu'à ~30 fois plus efficace que la norme C++ new/delete allocation si nous parlons de l'allocation de quantités modérées de petits objets de différentes tailles. Aussi, il y a un VC-solution spécifique appelé "QuickHeap", il apporte les meilleures performances possibles (allouer et de libérer les opérations de lecture et d'écriture de l'adresse du bloc alloué/retournés à tas, respectivement jusqu'à 99.(9)% des cas, dépend de paramètres et d'initialisation), mais à un coût d'un notable de la tête — il a besoin de deux pointeurs par mesure et une personne supplémentaire pour chaque nouveau bloc de mémoire. C'est plus rapide possible solution pour travailler avec de grands (10 000++) montants des objets créés et supprimés si vous n'avez pas besoin d'une grande variété d'objets de tailles (il crée une piscine individuelle pour chaque objet de la taille, de 1 à 1023 octets en œuvre, de sorte que l'initialisation des coûts peut rabaisser la performance globale boost, mais on peut aller de l'avant et d'allouer/désallouer mannequin objets avant l'application entre les performances de la phase critique(s)).

De la question avec le standard C++ new/delete mise en œuvre est qu'il est généralement juste un wrapper pour C malloc/free allocation, et il fonctionne bien, pour les plus grands blocs de la mémoire, comme 1024+ octets. Il a une remarquable généraux en termes de performance et, parfois, plus de mémoire utilisée pour la cartographie de trop. Ainsi, dans la plupart des cas, la coutume allocateurs sont mis en œuvre de manière à maximiser la performance et/ou de minimiser la quantité de mémoire nécessaire pour l'allocation de petite taille (≤à 1 024 octets) des objets.