-> add private_read_only to mapped_region to support MAP_PRIVATE plus PROT_READ

-> add contiguous_elements option to burst allocation

-> Test construct<> with throwing constructors

-> Implement zero_memory flag for allocation_command

-> The general allocation funtion can be improved with some fixed size allocation bins.

-> Adapt error reporting to TR1 system exceptions

-> Improve exception messages

-> Movability of containers should depend on the no-throw guarantee of allocators copy constructor

-> Check self-assignment for vectors

-> Update writing a new memory allocator explaining new functions (like alignment)

-> private node allocators could take the number of nodes as a runtime parameter.

-> Explain how to build intrusive indexes.

-> Add intrusive index types as available indexes.

-> Add maximum alignment allocation limit in PageSize bytes. Otherwise, we can't
   guarantee alignment for process-shared allocations.

-> Add default algorithm and index types. The user does not need to know how are
   they implemented.

-> Pass max size check in allocation to node pools

-> Use in-place expansion capabilities to shrink_to_fit and reserve functions
   from iunordered_index.

-> change unique_ptr to avoid using compressed_pair

-> Improve unique_ptr test to test move assignment and other goodies like assigment from null

-> barrier_test fails on MacOS X on PowerPC.

-> use virtual functions to minimize template explosion in managed classes

-> Insertions with InpIt are not tested in containers

-> Run tests with rvalue reference compilers with no variadic insertions

-> find a way to pass security attributes to shared memory

-> Implement vector with memcpy/memmove for trivially copyable types.

-> flat_xxx constructors are not documented

-> operator >> and similar need moved_value

-> rvalue reference enabled compilers are not optimized with is_movable and move_iterator

-> Add allocator test template that test all new functions (allocate_many, etc.)

-> MacOS shm_open is non-conformant. Is there a way to know the size of a shared memory object?

-> swap() of multiallocaiton iterator is wrong. Try to reimplement it with slist

-> Could the mapped_file constructor allow a wchar_t filename on Windows?
 Or some cross-platform way to get Unicode support?

-> map::node_ptr p = m.create_node(my_special_cheap_key_value, mv1, mv2);
//We would need to unconst-cast...
const_cast<Key&>(p->first) = modify( p->second );
m.insert( boost::move(p) ); 

->  I found some bug in the interprocess library. I use
 boost::interprocess::managed_mapped_file class and
 managed_mapped_file::shrink_to_fit() method to decrease the size of file
 on the disk. It works good but the thread hang up on shrink_to_fit() call
 if the file exists already and it's size is zero. It makes me check the
 file existance and it's size before shrink_to_fit() call.
 Thank you!

-> Ticket URL: <https://svn.boost.org/trac/boost/ticket/3375>

->Robust mutex emulation:

Two new fields:
 - owner
 - state

Use intermodule singleton to store the lock file name

LOCK
  if (broken_id){
    throw exception;
  }

  lock_own_unique_file();

  while(1){
    if (try_lock_mtx){
      write unique_id
    }
    else{
      sleep();
      ++tries;
      if(tries > 100)
        if(!robust_check()){
          tries = 0;
        }
        else{
          break;
        }
      }
    }
  }
  

UNLOCK
  if (fixing_mode){
    write_broken_id
  }
  else{
    write invalid_id
  }

  unlock_mtx

ROBUST_CHECK

  if(check_if_owner_dead_and_take_ownership_atomically()){
    return false;
  }
  write fixing_id

CHECK_IF_OWNER_DEAD_AND_TAKE_OWNERSHIP_ATOMICALLY

   do{
      old_owner = read_owner_atomically()
      if(check_owner_unique_resource_is_dead(old_owner){
         return true;
      }
   }while(cas(old_owner, cur_owner) == old_owner);
   return false;

CHECK_OWNER_UNIQUE_RESOURCE_IS_DEAD(owner)

   file = file_to_owner(owner);
   if(file_exists(file)){
      if(try_lock(file)){
         write_owner_atomically();
         remove(file);
         unlock(file)
         return true;
      }
   }
   return false;


LOCK_OWN_UNIQUE_FILE
class MyRobustMutexLockFile
{
   int fd;
};

MyRobustMutexLockFile()
{
   //loop create_and_lock because another process
   //can lock and erase it

   //better create, lock and rename?
   fd = create_file(lockfilename);
   while(1){
      lock_file(fd);
      int fd2 = create_exclusive(lockfilename);
      if(fd2){
         close(fd);
         fd = fd2;
         continue;
      }
      else if(already_exist_error){ //must already exist
         break;
      }
      else{
         close(fd);
         throw exception;
      }
   }
}

~MyRobustMutexLockFile()
{
   close(fd);
   //No race condition because
   //if any other thread tries to create the file
   //the shm has a lock so constructor/destructor is serialized
   unlink(lockfilename)
}

detail::intermodule_singleton<MyRobustMutexLockFile>::get();
