Ion; thank you!!
I found the errors in my prior code thanks to your tip and used the
improvements you suggested. I had unwittingly declared variables with very
similar names and different types, leading to confused behavior. Anyway
that is solved and I now have a working implementation of a mutex
synchronised interprocess vector of strings. Have included it below in case
it's of use to anyone else trying the same...
A further question if I may?
What is the best approach to extend a managed_shared_memory_segment? I can
dynamically add (via write() function) shared vector elements until such
time as an interprocess_exception boost_interprocess::bad_alloc is thrown;
when the memory allocated to the shared segment is filled. Is there a way
to handle this exception so that the segment can be extended with more
memory and then resume adding data elements to the vector? Or perhaps some
other way to detect the segment memory is running short and take action to
extend it?
Thanks again,
Riskybiz.
Code:
Class Definition:
#ifndef SHARED_MEMORY_WRAPPER_H//if not defined already
#define SHARED_MEMORY_WRAPPER_H//then define it
#include
#include
#include
#include
#include
#include <iostream>
#include <stdexcept>
using namespace boost::interprocess;
class SharedMemoryWrapper
{
public:
SharedMemoryWrapper(const std::string &name, bool server) :
m_name(name), m_server(server)
{
if (server)
{
//Clean up resources from any prior instances
named_mutex::remove("named_mutex");
shared_memory_object::remove(m_name.c_str());
//Create shared memory
m_segment = new managed_shared_memory(create_only, m_name.c_str(),
1000000);
//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);
}
else
{
try
{
//Open the shared segment
m_segment = new managed_shared_memory(open_only, name.c_str());
//Find the vector using the c-string name and open it
sharedSegmentVector =
m_segment->find<MyShmStringVector>("sharedSegmentVector").first;
}
catch(interprocess_exception ipe)
{
std::cout << "Error: Interprocess Exception: " << ipe.what() << std::endl;
}
catch(...)
{
std::cout << "Error: Unknown Exception: " << std::endl;
}
}
m_mutex = new named_mutex(open_or_create, "named_mutex");
}
~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;
}
//Writer
void write(const std::string &inStr)
{
try
{
CharAllocator charallocator(m_segment->get_segment_manager());
scoped_lock lock(*m_mutex);
MyShmString shmStr(inStr.c_str(), charallocator);
sharedSegmentVector->push_back(shmStr);
}
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 lock(*m_mutex);
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()";
}
//Vector Size
size_t getSize() const
{
return this->sharedSegmentVector->size();
}
private:
//Typedefs
typedef boost::interprocess::allocator CharAllocator;
typedef boost::interprocess::basic_string MyShmString;
typedef boost::interprocess::allocator StringAllocator;
typedef boost::interprocess::vector
MyShmStringVector;
bool m_server;
std::string m_name;
managed_shared_memory *m_segment;
MyShmStringVector *sharedSegmentVector;
named_mutex *m_mutex;
};//class
#endif//header guard
Test Programmes:
// 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("SharedMemoryTest",
true);
size_t cnt(0);
while(cnt < 100)
{
//Convert number to string representation
std::string cntStr = static_caststd::ostringstream*(
&(std::ostringstream() << cnt) )->str();
//Write to shared memory vector
smw->write("Iteration: " + cntStr);
cnt++;
}
size_t vecSize = smw->getSize();
std::cout << "Elements Present: "<< vecSize << std::endl;
delete smw;
return 0;
}
// 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("SharedMemoryTest",
false);
std::string outStr;
for(size_t index = 0; index < 100; index++)
{
outStr = smw->read(index);
std::cout << outStr << std::endl;
}
delete smw;
return 0;
}
Ion Gaztañaga
Riskybiz