Gemeinsame Karte mit boost::interprocess

Habe ich eine einfache Anforderung, die möglicherweise schwer zu lösen. Ich habe einige führt wie diese oder diese aber ich kann nicht scheinen, um readilly Sie verwenden. Die erstere nicht selbst übersetzen, in baubare code für mich. Ich bin nicht erfahren mit Boost, um nur dies Schreibe, auf meine eigene, aber es scheint mir, könnte dies eine häufige Anforderung.

Habe ich auch stoßen Der STL-Map aber ich habe noch nicht in der Lage gewesen, es zu montieren, die in funktionierenden code.

Ich bin am überlegen boost::interprocess ist der Weg hier zu gehen, es sei denn, ich will schaffen, shared memory map von Grund auf neu.

Ich bin nicht besorgt, mit der Portabilität. Ich brauche eine Lösung, die die Arbeit mit MS-compiler, speziell die eine, die kommt mit VS 2010.

Dieses poster zu wollen scheint mehr oder weniger das, was ich versuche zu tun, außer ich brauche die Karte eine GUID an, die eine beliebige Länge Binär-Puffer (aber einen int zu string ist ebenso gut als Ausgangspunkt). Leider kann ich nicht kompilieren, den code sauber zu beginnen, auch mit Experimenten.

Auch ich habe zwei Bedenken: A) ist es möglich, automatisch (oder zumindest vorhersehbar) vergrößern/verkleinern des freigegebenen Speicher für die Allokation muss und B) angenommen, ein Prozess wird die Karte, wie kann ein anderes Verfahren "Anhängen", um es?

Ich habe nichts dagegen, wenn eine Lösung erfordert mehrere gemeinsame "Segmente", um die Zuweisung muss. Es muss nicht unbedingt eine einzelne monolithische gemeinsamen Speicherblock.

Jede Hilfe wird sehr geschätzt.

  • Ja, boost::interprocess::map sollte Ihnen nur, was Sie brauchen.
InformationsquelleAutor wpfwannabe | 2012-09-13
  1. 16

    Hier das jüngste Beispiel, das ich geschrieben hatte, zu lernen, die Verwendung von Landkarten in den Shared memory. Es kompiliert wird, also wahrscheinlich, mit dem Sie Experimentieren können Sie entsprechend Ihrer Anforderung.

    Den code für ein server-Prozess erstellt gemeinsam genutzten Speicher und stellt anzeigen ein:-

    #include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <functional>
#include <utility>

int main ()
{
    using namespace boost::interprocess;

    //remove earlier existing SHM
    shared_memory_object::remove("SharedMemoryName");

    //create new 
    managed_shared_memory segment(create_only,"SharedMemoryName",65536);

    //Note that map<Key, MappedType>'s value_type is std::pair<const Key, MappedType>,
    //so the allocator must allocate that pair.
    typedef int    KeyType;
    typedef float  MappedType;
    typedef std::pair<const int, float> ValueType;

    //allocator of for the map.
    typedef allocator<ValueType, managed_shared_memory::segment_manager> ShmemAllocator;

    //third parameter argument is the ordering function is used to compare the keys.
    typedef map<KeyType, MappedType, std::less<KeyType>, ShmemAllocator> MySHMMap;

    //Initialize the shared memory STL-compatible allocator
    ShmemAllocator alloc_inst (segment.get_segment_manager());

    //Construct a shared memory map.
    MySHMMap *mymap =  segment.construct<MySHMMap>("MySHMMapName") (std::less<int>() ,alloc_inst);

    //offset ptr within SHM for map 
    offset_ptr<MySHMMap> m_pmap = segment.construct<MySHMMap>("MySHMMapName")(std::less<int>(), alloc_inst);

    //Insert data in the map
    for(int i = 0; i < 10; ++i)
    {
            m_pmap->insert(std::pair<const int, float>(i, (float)i));
    }

    return 0;
}

    Den code für einen client-Prozess legt den Speicher und greift auf anzeigen der Daten.

    #include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <functional>
#include <utility>

int main ()
{
    using namespace boost::interprocess;

    try
    {

            managed_shared_memory segment(open_or_create, "SharedMemoryName",65536);

            //Again the map<Key, MappedType>'s value_type is std::pair<const Key, MappedType>, so the allocator must allocate that pair.
            typedef int    KeyType;
            typedef float  MappedType;
            typedef std::pair<const int, float> ValueType;

            //Assign allocator 
            typedef allocator<ValueType, managed_shared_memory::segment_manager> ShmemAllocator;

            //The map
            typedef map<KeyType, MappedType, std::less<KeyType>, ShmemAllocator> MySHMMap;

            //Initialize the shared memory STL-compatible allocator
            ShmemAllocator alloc_inst (segment.get_segment_manager());

            //access the map in SHM through the offset ptr                                                         
            MySHMMap :: iterator iter;
            offset_ptr<MySHMMap> m_pmap = segment.find<MySHMMap>("MySHMMapNAme").first;

            iter=m_pmap->begin();
            for(; iter!=m_pmap->end();iter++)
            {
                   std::cout<<"\n "<<iter->first<<" "<<iter->second;
            }
    }catch(std::exception &e)            
    {
            std::cout<<" error  " << e.what() <<std::endl;
            shared_memory_object::remove("SharedMemoryName");
    }
    return 0;
}

    Den Code für den Client-Prozess erklärt, wie die Benutzung von "Namen" und eine offset-Zeiger ist, können andere Prozesse Anhängen und den Zugriff auf die Karte erstellte Inhalte SHM durch den server-Prozess.
    Aber, die Aufteilung von Größe (hier seine '65536') beim erstellen eines neuen shared-memory-segment, bin ich mir nicht sicher, ob die Größe geschrumpft, aber wahrscheinlich können Sie weitere Stücke von shared-memory zur Erweiterung des SHM...

    Hoffe, es half...

    • Vielen Dank für die tolle Probe! Hoffentlich wird jemand es nutzen. Ich habe mein Glück gefunden vor einiger Zeit und es sieht sehr ähnlich zu dem, was du gepostet hast. Also +1...
    • Scheint die Größe des shared-memory-fixiert ist?
    • Konstruieren Sie (in server-Prozess) zwei mal "MySHMMapName". In den client-Prozess, den Sie definiert "MySHMMapNAme" <-- Hauptstadt Einen Namen. Es ist nicht für mich arbeiten, löschte ich das erste Konstrukt, und umbenannt in die Namen. Danke trotzdem!
    • Ich nehme an, dies ist nicht lock-frei, richtig? Sperren muss separat durchgeführt werden, wenn zwei Prozesse mit der Karte?
    InformationsquelleAutor Leafy
Schreibe einen Kommentar