"It's not an easy task. You should catch the exception and then notify all connected processes that should disconnected from the segmenet (as only offline growing is supported). After that a process can call "grow" to try extend the segment. Then, all processes can attach to the newly grown segment. Think of that as a complex binary file that must be extended and internal structures changed. All users should close the file, the file should be changed by a process and then all users can start using the file again." OK Ion, I see. 1. Can I ask what mechanism you would suggest for notifying the other processes to disconnect before the grow() operation. 2. My wrapper class implementation is still in the experimental stages, I'm trying to build it up to operate in the way I need. I've hacked it around a bit to account for the fact that I cannot control the order in which the client & server instances will ultimately be launched by the 3rd party application I'm building a DLL for; so I've got to make the wrapper class as flexible as possible. What I'm trying to do is get my toy client process to wait, if it should happen to launch first, before the server, and then have the clients notified by the server process when data is ready to be accessed. So....I can get the client to wait using a named_condition, but then I can't get it to wake up. The notifyall() is not taking effect. P.S. In my tests I first launch the client and then the server process. Have I missed something fundamental here, is my notifyall() properly constructed and directed to the right destination? 3. Also, another thought; if the shared memory segment should happen to grow whilst a client is waiting then the client will need to remap the segment on waking, correct? But will it even get the notifyall() signal, because the client is still 'looking' at a different memory location? Could this be my problem? Not sure. Though I did test the code without the grow() commands and the client process still did not wake! Many, many thanks for your help so far, just a few more hurdles to clear and this wrapper class will be operational. Riskybiz. #ifndef SHARED_MEMORY_WRAPPER_H//if not defined already #define SHARED_MEMORY_WRAPPER_H//then define it #include <boost/interprocess/managed_shared_memory.hpp> #include <boost/interprocess/containers/vector.hpp> #include <boost/interprocess/containers/string.hpp> #include <boost/interprocess/allocators/allocator.hpp> #include <boost/interprocess/sync/named_mutex.hpp> #include <boost/interprocess/sync/named_condition.hpp> #include <iostream> #include <stdexcept> using namespace boost::interprocess; class SharedMemoryWrapper { public: SharedMemoryWrapper(const std::string &name, bool server) : m_name(name), m_server(server) { try { //Open the shared segment. Will throw an interprocess exception if fails to open i.e. segment does not exist. Control jumps to the catch block. m_segment = new managed_shared_memory(open_only, m_name.c_str()); //Find the vector using the c-string name and open it sharedSegmentVector = m_segment->find<MyShmStringVector>("sharedSegmentVector").first; //Open the underlying mutex m_mutex = new named_mutex(open_only, "smw_mutex"); //Open the underlying condition variable waitForData = new named_condition(open_only, "smw_named_condition"); if(m_server)//Flag to put client processes to sleep until ready for them { sleep = false; } else { sleep = true; } } catch(interprocess_exception &ipe)//Catch the interprocess exception and instantiate the shared memory resources here. { try { std::cout << "Error: interprocess_exception: " << ipe.what() << "Going to instantiate shared memory resources now...." << std::endl; //Clean up resources from any prior instances named_mutex::remove("smw_mutex"); named_condition::remove("smw_named_condition"); shared_memory_object::remove(m_name.c_str()); //Create shared memory m_segment = new managed_shared_memory(create_only, m_name.c_str(), 100000); //Create allocators CharAllocator charallocator(m_segment->get_segment_manager()); StringAllocator stringallocator(m_segment->get_segment_manager()); //This vector is fully constructed in shared memory. All pointers //buffers are constructed in the same shared memory segment //This vector can be safely accessed from other processes. sharedSegmentVector = m_segment->construct<MyShmStringVector>("sharedSegmentVector")(stringallocat or); if(m_server)//Flag to put client processes to sleep until ready for them { sleep = false; } else { sleep = true; } //Instantiate the underlying mutex m_mutex = new named_mutex(create_only, "smw_mutex"); //Instantiate the underlying condition variable waitForData = new named_condition(create_only, "smw_named_condition"); //......despite the exception code continues executing to the end of the constructor. } catch(interprocess_exception &ipe1) { std::cout << "Error: Whilst instantiating shared memory resources: interprocess_exception: " << ipe1.what() << std::endl; } } catch(...) { std::cout << "Error: Unknown Exception: " << std::endl; } } ~SharedMemoryWrapper() { /* //Destructor: Will remove the shared memory resources if (m_server) { named_mutex::remove("named_mutex"); //Destroy the vector from the managed_shared_memory //m_segment->destroy_ptr(sharedSegmentVector);//This will free all strings that the vector contains m_segment->destroy<MyShmStringVector>("sharedSegmentVector");//Destroy the vector //Is it necessary to destroy the allocators here? //Remove the managed_shared_memory; this may fail if the memory does not exist or is mapped or opened by another process shared_memory_object::remove(m_name.c_str()); } */ //Delete instance members delete m_mutex; delete m_segment; delete waitForData; } //Writer void write(const std::string &inStr) { try { CharAllocator charallocator(m_segment->get_segment_manager()); scoped_lock<named_mutex> lock(*m_mutex); try { if(sleep)//Put client process to sleep when it first tries to access. { std::cout << "Going to wait...." << std::endl; sleep = false; waitForData->wait(lock);//Set condition variable to wait. When ready to allow access then call notify(). } } catch(interprocess_exception &ex) { std::cout << "Error in Writer Process Wait: interprocess_exception: "<< ex.what() << std::endl; } MyShmString shmStr(inStr.c_str(), charallocator); sharedSegmentVector->push_back(shmStr); //Try to grow if free memory is running low if(m_segment->get_free_memory() < 50000) { std::cout << "Free Memory Before: " << m_segment->get_free_memory() << " Elements: " << getSize() << std::endl; delete m_mutex;//delete delete waitForData;//delete delete m_segment;//unmap managed_shared_memory::grow(m_name.c_str(), 50000);//grow m_segment = new managed_shared_memory(open_only, m_name.c_str());//remap sharedSegmentVector = m_segment->find<MyShmStringVector>("sharedSegmentVector").first;//find //Reopen the underlying mutex m_mutex = new named_mutex(open_only, "smw_mutex"); //Reopen the underlying condition variable waitForData = new named_condition(open_only, "smw_named_condition"); std::cout << "Free Memory After Grow: " << m_segment->get_free_memory() << " Elements: " << getSize() << std::endl; } } catch(interprocess_exception ipe) { std::cout << "Error in SharedMemoryWrapper::write(): interprocess_exception: "<< ipe.what() << std::endl; } catch(...) { std::cout << "Error in SharedMemoryWrapper::write(): unknown error" << std::endl; } } //Reader std::string read(size_t &index) { try { scoped_lock<named_mutex> lock(*m_mutex); try { if(sleep)//Put client process to sleep when it first tries to access. { std::cout << "Going to wait...." << std::endl; sleep = false; waitForData->wait(lock);//Set condition variable to wait. When ready to allow access then call notify(). } } catch(interprocess_exception &ex) { std::cout << "Error in Reader Process Wait: interprocess_exception: "<< ex.what() << std::endl; } const MyShmString &shmStr = (*sharedSegmentVector)[index]; std::string stdStr(shmStr.begin(), shmStr.end()); return stdStr; } catch(interprocess_exception &ipe) { std::cout << "Error in SharedMemoryWrapper::read(): interprocess_exception: "<< ipe.what() << std::endl; } catch(std::range_error &re) { std::cout << "Error in SharedMemoryWrapper::read(): range_error: " << re.what() << std::endl; } catch(...) { std::cout << "Error in SharedMemoryWrapper::read(): unknown error "<< std::endl; } return "Error in SharedMemoryWrapper::read()"; } //Notifier void notify() { try { scoped_lock<named_mutex> lock(*m_mutex); std::cout << "Going to Notify...." << std::endl; lock.unlock(); waitForData->notify_all();//notify to release the wait condition; when data is available and ready to be accessed by client processes std::cout << "Notified" << std::endl; } catch(interprocess_exception &ipe) { std::cout << "Error: boost_interprocess exception: in notifier: " << ipe.what() << std::endl; } catch(...) { std::cout << "Unknown Error In Notifier: " << std::endl; } } //Vector Size size_t getSize() const { return this->sharedSegmentVector->size(); } //Remover void release() { try { std::cout << "Going to release shared memory resources...." << std::endl; named_mutex::remove("named_mutex"); named_condition::remove("smw_named_condition"); //Destroy the vector from the managed_shared_memory //m_segment->destroy_ptr(sharedSegmentVector);//This will free all strings that the vector contains m_segment->destroy<MyShmStringVector>("sharedSegmentVector");//Destroy the vector //Is it necessary to destroy the allocators here? //Remove the managed_shared_memory; this may fail if the memory does not exist or is mapped or opened by another process shared_memory_object::remove(m_name.c_str()); std::cout << "Resources Released" << std::endl; } catch(interprocess_exception ipe2) { std::cout << "Error: remove() interprocess_exception: " << ipe2.what() << std::endl; } } private: //Typedefs typedef boost::interprocess::allocator<char, managed_shared_memory::segment_manager> CharAllocator; typedef boost::interprocess::basic_string<char, std::char_traits<char>, CharAllocator> MyShmString; typedef boost::interprocess::allocator<MyShmString, managed_shared_memory::segment_manager> StringAllocator; typedef boost::interprocess::vector<MyShmString, StringAllocator> MyShmStringVector; bool m_server; std::string m_name; bool sleep; managed_shared_memory *m_segment; MyShmStringVector *sharedSegmentVector; named_mutex *m_mutex; named_condition *waitForData; };//class #endif//header guard Server program to prepare the shared vector of strings: // PrepareSharedMemoryVectorOfStrings.cpp : Defines the entry point for the console application. // #include "SharedMemoryWrapper.h" #include <iostream> #include <string> #include <sstream> int main(int argc, char *argv[]) { SharedMemoryWrapper *smw = new SharedMemoryWrapper("SMT", true); size_t cnt(0); while(cnt < 100) { //Convert number to string representation std::string cntStr = static_cast<std::ostringstream*>( &(std::ostringstream() << cnt) )->str(); //Write to shared memory vector smw->write(cntStr); cnt++; } size_t vecSize = smw->getSize(); std::cout << "Elements Present: "<< vecSize << std::endl; smw->notify(); //smw->release(); delete smw; return 0; } Client program to access the shared memory vector of strings: // AccessSharedMemoryVectorOfStrings.cpp : Defines the entry point for the console application. // #include "SharedMemoryWrapper.h" #include <iostream> #include <string> int main(int argc, char *argv[]) { SharedMemoryWrapper *smw = new SharedMemoryWrapper("SMT", false); try { std::string outStr("Blank"); //if(smw->getSize() == 100) //{ outStr = ""; for(size_t index = 0; index < 100; index++) { outStr += (smw->read(index) + " "); } //} std::cout << outStr << std::endl; } catch(...) { std::cout << "Error: Unknown Exception." << std::endl; } smw->release();//removes shared memory resources from the system delete smw; return 0; }