Share std::map between processes with mmap()

Question

I'm trying to share a std::map<std::string, std::chrono::system_clock::time_point> map: each string is a hostname identifying a site, and the time_point is the last time a process visited that site.

I was trying with mmap but each process still see its own copy of the map.

Here's my code (I took away all the methods and variables not concerning my problem):

#include <sys/mman.h>
#include <unistd.h>

#include <iostream>
#include <map>
#include <string>
#include <chrono>

typedef std::map<std::string, std::chrono::system_clock::time_point> mymap;
typedef mymap::iterator iter;
typedef mymap* mapPointer;

class MmapManager {
    private:
        MmapManager() {
            frequency = (mapPointer) mmap(NULL, sizeof(frequency), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
            if (frequency == MAP_FAILED) {
                std::cout << "mapping failed" << std::endl;
            }
        };

        ~MmapManager() {
            std::cout << "~MmapManager()" << std::endl;
        }

    public:
        // my class was designed with the singleton pattern
        static MmapManager& getInstance() {
            static MmapManager instance;
            return instance;
        }

    private:
        // pointer to my map
        mapPointer frequency;

    public:
        // check if the process already visited site "host"
        bool isHostAlreadyVisited(std::string host) {
            return frequency->find(host) != frequency->end();
        }
        // add new visited site and time of the visit
        void addHost(std::string host) {
            (*frequency)[host] = std::chrono::system_clock::now();
            std::cout << "PROC " << getpid() << " added " << host << std::endl;
        }
        // get time of the visit for site "host"
        std::chrono::system_clock::time_point getElement(std::string host) {
            return (*frequency)[host];
        }
        // print the map
        void showMap(void) {
            std::cout << "PROC " << getpid() << " prints map keys" << std::endl;
            for (auto it = frequency->begin(); it != frequency->end(); ++it) {
                std::cout << it->first << std::endl;
            }
        }
};

int main(void) {

    // simulate the processes
    for (int i=0; i<5; i++) {
        // child process
        if (fork() == 0) {
            // if child never visited this site...
            if (! MmapManager::getInstance().isHostAlreadyVisited("www.google.com")) {
                std::cout << "PID " << getpid() << " www.google.com is new" << std::endl;
                // ...add it to the map
                MmapManager::getInstance().addHost("www.google.com");
            }
            else {
                // if child already visited it, calculate 
                // how much time passed since last visit
                auto now = std::chrono::system_clock::now();
                auto before = MmapManager::getInstance().getElement("www.google.com");
                std::chrono::duration<double> diff = now-before;
                std::cout << "PID " << getpid() << " visited www.google.com " << diff.count() << " seconds ago" << std::endl;
            }
            MmapManager::getInstance().showMap();
            _exit(EXIT_SUCCESS);
        }
    }
    return 0;
}

Here's one of the possible outputs:

PID 12457 www.google.com is new
PID 12459 www.google.com is new
PID 12458 www.google.com is new
PID 12460 www.google.com is new
PID 12461 www.google.com is new

I can't use other external libraries like Boost or use threads: I know they share memory, but the program was designed this way (with child processes doing stuff) and I can't modify it (original code is not mine).

Why does each process still see its own copy of the map?

Edit: I think I did all the things you suggested me:

• insertion in map is protected with a lock mechanism (thanks kfsone);
• created a custom allocator for string and another for map (thanks Maxim Egorushkin for these two);
• map is allocated before forking (thanks Zan Lynx).

The output is not different and map is still not shared:

MmapManager()
printMap
map empty
PID 5085 www.google.com is new
PID 5086 www.google.com is new
PROC 5086 added www.goole.com
PROC 5085 added www.goole.com
PID 5087 www.google.com is new
PROC 5087 added www.goole.com

You suggested me to use Boost but I'd like to use it after my code will work: I'm not reinventing the wheel, just learning the hard way.

Here follows my new code:

#include <sys/mman.h>
#include <unistd.h>
#include <sys/shm.h>        /* shmat(), IPC_RMID        */
#include <semaphore.h>      /* sem_open(), sem_destroy(), sem_wait().. */
#include <fcntl.h>          /* O_CREAT, O_EXEC          */
#include <stdlib.h>

#include <iostream>
#include <map>
#include <string>
#include <chrono>
#include <cstddef>
#include <vector>
#include <limits>
#include <memory>

template<typename T> class stringAllocator {
    public : 
        typedef T value_type;
        typedef size_t size_type;
        typedef ptrdiff_t difference_type;
        typedef T* pointer;
        typedef T const * const_pointer;
        typedef T& reference;
        typedef T const & const_reference;

        template<typename U> struct rebind {
            typedef stringAllocator<U> other;
        };

        pointer address (reference value ) const {
            return &value;
        }

        const_pointer address (const_reference value) const {
            return &value;
        }

        size_type max_size () const throw() {
            return std::numeric_limits <size_type>::max() / sizeof(T);
        }

        stringAllocator () throw () {}
        stringAllocator (stringAllocator const &) throw () {}

        template <typename U>
        stringAllocator(stringAllocator <U> const &) throw () {}

        ~stringAllocator() throw () {}

        pointer allocate (size_type n) {
            pointer ptr = (pointer)malloc(n * sizeof(value_type));
            return ptr;
        }

        void deallocate (pointer p, size_type n) {
            free(p);
        }

        void construct (pointer p, const_reference value) {
            new(p) T(value);
        }

        void destroy (pointer p) {
            p->~T();
        }
};

template <class T1, class T2>
    bool operator==(const stringAllocator<T1>&, const stringAllocator<T2>&) throw() {
        return true;
    }

template <class T1, class T2>
    bool operator!=(const stringAllocator<T1>&, const stringAllocator<T2>&) throw() {
        return false;
    }

typedef std::basic_string<
    char, 
    std::char_traits<char>, 
    stringAllocator<char>
> myString;

/*************************************** map allocator ****************************************/

template<typename T> class mapAllocator{
    public :
        typedef T value_type;
        typedef value_type* pointer;
        typedef const value_type* const_pointer;
        typedef value_type& reference;
        typedef const value_type& const_reference;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;

        template<typename U>
        struct rebind {
            typedef mapAllocator<U> other;
        };

        mapAllocator() throw() {}
        mapAllocator (mapAllocator const &) throw () {} 
        ~mapAllocator() throw () {}

        template<typename U>
        mapAllocator(mapAllocator<U> const&) {}

        pointer address(reference r) { return &r; }
        const_pointer address(const_reference r) { return &r; }

        pointer allocate(size_type cnt, typename std::allocator<void>::const_pointer = 0) {
            pointer new_memory = reinterpret_cast<pointer>(::operator new(cnt * sizeof (T)));
            return new_memory;
        }
        void deallocate(pointer p, size_type n) {
            ::operator delete(p);
        }
        size_type max_size() const {
            return std::numeric_limits<size_type>::max() / sizeof(T);
        }

        void construct(pointer p, const T& t) {
            new(p) T(t);
        }

        void destroy(pointer p) {
            p->~T();
        }    
};

template <class T1, class T2>
    bool operator==(const mapAllocator<T1>&, const mapAllocator<T2>&) throw() {
        return true;
    }

template <class T1, class T2>
    bool operator!=(const mapAllocator<T1>&, const mapAllocator<T2>&) throw() {
        return false;
    }

/*************************************** end map allocator ****************************************/

// class compare for map with std::string as Key
class strless {
    public:
        bool operator() (const myString first, const myString second ) const { 
            return first.compare(second) < 0; 
        }
};

template<typename Key, typename T>
    using Map = std::map<
        Key,                                    // class Key
        T,                                      // class T
        strless,                                // class Compare = std::less<Key>
        mapAllocator<std::pair<const Key, T>    // class Allocator = std::allocator<std::pair<const Key, T> >
    >
>;

// typedef for the actual map I need to share between processes
typedef Map<myString, std::chrono::system_clock::time_point> frequencyMap;

class MmapManager {
    private:
        MmapManager() {
            std::cout << "MmapManager()" << std::endl;
            semMmap = sem_open("semaphore", O_CREAT|O_EXCL, 0644, 1);
            sem_unlink("semaphore");
        };

        ~MmapManager() {
            std::cout << "~MmapManager()" << std::endl;
        }

    public:
        static MmapManager& getInstance() {
            static MmapManager instance;
            return instance;
        }

    private:
        frequencyMap fmap;
        sem_t *semMmap;

    public:

        void start(void) {}

        bool isHostAlreadyVisited(myString host) {
            return fmap.find(host) != fmap.end();
        }

        void addHost(myString host) {
            sem_wait(semMmap);
            fmap[host] = std::chrono::system_clock::now();
            sem_post(semMmap);
            std::cout << "PROC " << getpid() << " added " << host << std::endl;
        }

        // get time of the visit for site "host"
        std::chrono::system_clock::time_point getElement(myString host) {
            return fmap[host];
        }

        void printMap(void) {
            std::cout << "printMap" << std::endl;
            if (!fmap.empty()) {
                for (auto it : fmap) {
                    std::cout << it.first << ' ';
                }
                std::cout << std::endl;
            } else {
                std::cout << "map empty" << std::endl;
            }
        }
};


int main(void) {

    MmapManager::getInstance().start();

    for (int i=0; i<3; i++) {
        if (fork() == 0) {
            if (!MmapManager::getInstance().isHostAlreadyVisited("www.google.com")) {
                std::cout << "PID " << getpid() << " www.google.com is new" << std::endl;           
                MmapManager::getInstance().addHost("www.goole.com");
            }
            else {
                // if child already visited it, calculate
                // how much time passed since last visit
                auto now = std::chrono::system_clock::now();
                auto before = MmapManager::getInstance().getElement("www.google.com");
                std::chrono::duration<double> diff = now-before;
                std::cout << "PID " << getpid() << " visited www.google.com " << diff.count() << " seconds ago" << std::endl;
            }
            _exit(EXIT_SUCCESS);
        }
    }

    MmapManager::getInstance().printMap();

    return 0;
}

Answer 1

This does not work because although you placed the container object into the shared memory, the elements are still allocated from the heap and thus they are not accessible by other processes.

You need a custom allocator that allocates elements in the shared memory. See Creating maps in shared memory for how it is done.

Note that the string class you use must also allocate memory from the shared memory.

In other words, you cannot have pointers to heap memory in the shared memory, because heap memory is not shared between processes. std classes have an allocator template argument, the default one allocates memory from the heap. This needs to be changed to a shared memory allocator to be able to share such objects via shared memory.

Answer 2

Another reason your code doesn't work is that you only create the maps after you called fork().

If you want your MAP_SHARED|MAP_ANONYMOUS map to be seen by all the children then you have to call mmap() before forking.