Question

I have a multithreaded server application that needs mutex locks over some shared memory.

The shared memory are basically sTL maps etc.

Much of the time I’m just reading from the map.
But, I also need to occasionally add to it.

e.g.
typedef std::map MessageMap;
MessageMap msgmap;
boost:shared_mutex access_;

void ProcessMessage(Message* message)
{
  //  Access message... read some stuff from it  message->...

  UUID id = message->GetSessionID();

  // Need to obtain a lock here. (shared lock? multiple readers)
  // How is that done?
  boost::interprocess::scoped_lock(access_);

  // Do some readonly stuff with msgmap
  MessageMap::iterator it = msgmap.find();
  // 

  // Do some stuff...

  // Ok, after all that I decide that I need to add an entry to the map.
  // how do I upgrade the shared lock that I currently have?
  boost::interprocess::upgradable_lock


  // And then later forcibly release the upgrade lock or upgrade and shared lock if I'm not looking
  // at the map anymore.
  // I like the idea of using scoped lock in case an exception is thrown, I am sure that
  // all locks are released.
}

EDIT:
I might be confusing the different lock types.

Whats the difference between shared/upgrade and exclusive.
i.e. I don’t understand the explanation.
It sounds like if you just want to allow lots of readers, a shared access is all you want to obtain. And to write to your shared memory you just need upgrade access. Or do you need exclusive? The explanation in boost is anything but clear.

Is upgrade access obtained because you might write. But shared means you definately won’t write is that what it means?

EDIT: Let me explain what I’m wanting to do with a little more clarity. I’m not yet happy with the answers.

Here is the example all over again but with an example of some code that I’m using as well.
Just an illustration, not the actual code.

typedef boost::shared_mutex Mutex;
typedef boost::shared_lock<Mutex> ReadLock;
typedef boost::unique_lock<Mutex> WriteLock;
Mutex mutex;
typedef map<int, int> MapType;    // Your map type may vary, just change the typedef
MapType mymap;

void threadoolthread() // There could be 10 of these.
{   
    // Add elements to map here
    int k = 4;   // assume we're searching for keys equal to 4
    int v = 0;   // assume we want the value 0 associated with the key of 4

    ReadLock read(mutex); // Is this correct?
    MapType::iterator lb = mymap.lower_bound(k);
    if(lb != mymap.end() && !(mymap.key_comp()(k, lb->first)))
    {
        // key already exists
    }
    else
    {
        // Acquire an upgrade lock yes?  How do I upgrade the shared lock that I already        have?
        // I think then sounds like I need to upgrade the upgrade lock to exclusive is that correct as well?

        // Assuming I've got the exclusive lock, no other thread in the thread pool will be able to insert.
        // the key does not exist in the map
        // add it to the map
        {
          WriteLock write(mutex, boost::adopt_lock_t());  // Is this also correct?
          mymap.insert(lb, MapType::value_type(k, v));    // Use lb as a hint to insert,
                                                        // so it can avoid another lookup
        }
        // I'm now free to do other things here yes?  what kind of lock do I have here, if any?  does the readlock still exist?
    }

Answer 1

You said that your application is multithreaded, so you should use boost::thread not boost::interprocess.

From the documentation (not tested) you should do it this way:

typedef boost::thread::shared_mutex shared_mutex;
boost::thread::upgrade_lock<shared_mutex> readLock(access_);

// Read access...

boost::thread::upgrade_to_unique_lock<shared_mutex> writeLock(readLock);

// Write access..

Also note that you acquire it while you lock for read access, so someone may delete this node and it’s no longer valid when you get to the write section. WRONG, sorry.

EDIT: I think that explanation in boost is clear. Let’s try rephrase it to you anyway:

There are three main types of mutex concepts (I don’t count TimedLockable since it’s not related to your question):

• Lockable — just a simple, exclusive ownership mutex. If someone lock()s it no-one can lock() it again until the owner unlock()s it. boost::thread::mutex implements this concept. To lock this concept in RAII style use lock_guard or unique_lock for a more complex interface.
• SharedLockable — is a Lockable with an additional “shared” ownership. You can get the exclusive ownership with lock() or the shared ownership with lock_shared(). If you lock the shared part you cannot upgrade your ownership to exclusive one. You need to unlock_shared() and lock() again which means that somebody else may modify the protected resource between unlock_shared() and lock(). It’s useful when you know a priori what kind of access to the resource you will do. shared_mutex implements this concept. Use lock_guard or unique_lock to get the exclusive ownership and shared_lock to get the shared ownership.
• UpgradeLockable — is SharedLockable which allows you to upgrade from shared ownership to exclusive ownership without unlocking. shared_mutex implements this concept too. You can use the above locks to get exclusive or shared ownership. To get an upgradable shared ownership use upgrade_lock and upgrade it with upgrade_to_unique_lock.