Question

My problem is, I have block matrix updated by multiple threads.
Multiple threads may be updating disjoint block at a time but in general there may be race conditions. right now matrix is locked using single lock.

The question is, is it possible (and if it is, how?)
to implement an efficient array of locks, so that only portions of matrix maybe locked at a time.

The matrix in question can get rather large, on order of 50^2 blocks. my initial guess is to use dynamically allocate vector/map of mutexes.

Is it good approach?
Is it better to use multiple condition variables instead?
Is there a better approach?

Answer 1

Use a single lock. But instead of using it to protect the entire matrix use it to guard a std::set (or a boost::unordered_set) which says which blocks are “locked”.

Something like this.

class Block;

class Lock_block
{
public:
   Lock_block( Block& block ) : m_block(&block)
   {
      boost::unique_lock<boost::mutex> lock(s_mutex);
      while( s_locked.find(m_block) != s_locked.end() )
      {
         s_cond.wait(lock);
      }
      bool success = s_locked.insert(m_block).second;
      assert(success);
   }

   ~Lock_block()
   {
      boost::lock_guard<boost::mutex> lock(s_mutex);
      std::size_t removed = s_locked.erase(m_block);
      assert(removed == 1);
      s_cond.notify_all();
   }
private:
   Block* m_block;

   static boost::mutex s_mutex;
   static boost::condition s_cond;
   static std::set<Block*> s_locked;
};