Ajout d'un allocateur à un modèle de classe C++ pour la création d'objets en mémoire partagée

Question

En bref, ma question est: Si vous avez la classe MyClass<T>, comment pouvez-vous changer la définition de classe pour prendre en charge les cas où vous avez MyClass<T, Alloc>, similaire à comment, disons , Le vecteur STL fournit.

J'ai besoin de cette fonctionnalité pour prendre en charge un allocateur pour la mémoire partagée. Plus précisément, j'essaie d'implémenter un tampon circulaire dans la mémoire partagée. Actuellement, il a le cteur suivant:

template<typename ItemType> 
SharedMemoryBuffer<ItemType>::SharedMemoryBuffer(unsigned long capacity, std::string name) 

où ItemType est le type des données devant être placées dans chaque fente de la mémoire tampon.

Maintenant, cela fonctionne splendide lorsque je crée le tampon du programme principal ainsi

SharedMemoryBuffer<int>* sb; 
sb = new SharedMemoryBuffer<int>(BUFFER_CAPACITY + 1, sharedMemoryName); 

Cependant, dans ce cas, le tampon lui-même est pas créé dans la mémoire partagée et est donc pas accessible à d'autres processus. Ce que je veux faire est d'être en mesure de faire quelque chose comme

typedef allocator<int, managed_shared_memory::segment_manager> ShmemAllocator; 
typedef SharedMemoryBuffer<int, ShmemAllocator> MyBuffer; 

managed_shared_memory segment(create_only, "MySharedMemory", 65536); 
const ShmemAllocator alloc_inst (segment.get_segment_manager()); 
MyBuffer *mybuf = segment.construct<MyBuffer>("MyBuffer")(alloc_inst); 

Cependant, je ne sais pas comment aller sur l'ajout d'un allocateur explicite au modèle de classe.

Answer 1

ce qui me fais confonds est, pourquoi vous avez besoin d'allouer ou de créer un objet dans SharedMemory (SHM), par exemple si vous réservez la mémoire partagée de la taille 65536 octets, supposons que vous obtenez votre mémoire partagée à l'adresse 0x1ABC0000, si le succès de la réservation, vous aurez un espace mémoire libre et directement accessible à 0x1ABC0000 to 0x1ABCFFFF.

alors lorsque votre application a besoin de « allouer » objet SHM de la taille sizeof(SHMObject) et votre gestionnaire de mémoire voir cette adresse à 0x1ABC0000+0x1A est libre, votre gestionnaire de mémoire doit simplement revenir 0x1ABC001A valeur et marquer (0x1ABC001A to 0x1ABC001A+sizeof(SHMObject)) était occupé, et vous venez besoin de lancer: SHMObject* shmObjectPtr = (SHMObject*)(0x1ABC001A);

et bien sûr cela suppose que vous avez votre propre allocateur de mémoire personnalisé qui fonctionne sur une plage spécifiée d'adresse mémoire.

comme pour le modèle, je ne comprends pas vraiment comment votre tampon anneau SHM ressembler, mais je l'ai fait avant d'utiliser SHM, ma mise en œuvre est comme ceci: `

//memory SHM allocator 
template<typename T> class ShmRingAllocator 
{ 
    protected: 
     void* baseAddress; 
    public: 
     ShmRingAllocator(void* baseAddress,int memSize); 
     void* allocate(); //this function do what I described earlier, or you can use placement new: new (baseAddress+offset)T; 
} 

//some kind of shared_ptr<> that handle object in SHM, this provides mechanishm to check is the pointer still valid in shm or not 
template<typname T> ShmRingObjectPtr 
{ 
    protected: 
     T* object; //mapped address of object at current process 
     ShmBuffer* shm; //every object has pointer to which SHM does this pointer pointing at 
    public: 
     virtual T* operator->(); //operator overload to access T object 
} 

class ShmBuffer //base class for all kind of SHM buffer 
{ 
    protected: 
     std::string shmName; 
     void* shmBasePtr; 
} 

template<typename T,class A=ShmRingAllocator<T>> ShmRingBuffer : public ShmBuffer 
{ 
    protected: 
     A allocator; 
    public: 
     ShmRingObjectPtr<T> insert() //push one element to ring buffer 
     { 
       return ShmRingObjectPtr<T>((T*)this->allocator.allocate(),this); 
     } 
} 

`

Answer 2

Je pense que vous recherchez simplement le placement standard nouveau.

Si shm_addr est un pointeur void* à mémoire partagée que vous pouvez faire:

MyBuffer *pBuf = new (shm_Addr) MyBuffer; 

et le nouveau MyBuffer sera construit à l'endroit donné. Cela peut fonctionner avec n'importe quel type d'objet, y compris les types de modèles.

Vous pouvez envelopper dans une fonction séparée si vous le souhaitez.

Pour détruire quelque chose créé avec placement standard, vous devez appeler explicitement le destructeur. C'est parce que delete essayerait de désallouer la mémoire en tant que mémoire allouée new régulière qui ne serait pas une chose valide à faire. C'est la seule fois en C++ que vous devez appeler explicitement un destructeur.

pBuf->~MyBuffer();