[Boost-users] problem with memcpy to shared memory

2 Mar 2010

      Hi,

I want to create a buffer in shared memory and have modified the
example code provided in Boost.Interprocess to get the following
class:

template<typename ItemType>
class SharedMemoryBufferMock {
private:
    ItemType*        m_data;            // array of ItemType items
    ItemType*        m_read_ptr;        // points to next buffer
location to be read from
    ItemType*        m_write_ptr;        // points to next buffer
location to be written to
    std::string     m_segmentName;    // unique name for the memory
segment that holds the buffer object
    std::string     m_objectName;     // unique name for the buffer object
    unsigned long    m_nItems;
    unsigned long    m_capacity;
public:
    SharedMemoryBufferMock( unsigned long maxItemCount );
    virtual ~SharedMemoryBufferMock();

    unsigned long     capacity()     { return m_capacity; }
    unsigned long     size()        { return m_nItems; }
    bool             isFull()    { return m_nItems == m_capacity; }
    bool            isEmpty()    { return m_nItems == 0; }

    ItemType*         read();
    void             write( ItemType* item_ptr);
};

/*
 * Implementation of the templated methods.
 */
template<typename
ItemType>SharedMemoryBufferMock<ItemType>::SharedMemoryBufferMock(
unsigned long maxItemCount )
{
	if( maxItemCount == 0 ) {
		std::cerr << "Buffer cannot be created with a capacity of zero!" << std::endl;
		exit(1);
	}

	// Create unique name for memory segment using PID of current process.
	std::stringstream pid_str;
	pid_str << "BufferMemorySegment_" << getpid();
	m_segmentName = pid_str.str();
	pid_str.str("");
	pid_str << "BufferMemoryObject_" << getpid();
	m_objectName  = pid_str.str();

	boost::interprocess::shared_memory_object::remove(m_segmentName.c_str());

	m_capacity = maxItemCount;

	// Create a new segment with given name and size
	boost::interprocess::managed_shared_memory segment(
boost::interprocess::create_only,
														m_segmentName.c_str(),
														//memSize
														65536
														);

	// Create the buffer data object with specified item capacity.
	m_data = segment.construct<ItemType>
										( m_objectName.c_str() )	// name of the object
										[maxItemCount]				// number of items
										(ItemType());				// ctor for elements

	// Initialize read and write locations.
	m_write_ptr = m_read_ptr = m_data;
}

template<typename ItemType> void
SharedMemoryBufferMock<ItemType>::write( ItemType* item_ptr )
{
	if( isFull() ) {
		std::cerr << "Cannot write to buffer, it's full. Read one or more
elements first!" << std::endl;
		exit(1);
	}
	std::memcpy( m_write_ptr, item_ptr, sizeof(ItemType) );
	m_write_ptr++;
	m_nItems++;
}

When I test the code using the following:
		SharedMemoryBufferMock<int> sharedBuf(100);
		for( int i = 0; i < 10; i++ ) {
			cout << "writing " << i << endl;
			sharedBuf.write( &i );
		}

I get a segmentation fault at the memcpy step. I've been at this for a
couple of hours now and cannot see what I'm doing wrong. Any comments
would be greatly appreciated.

Thanks,

C

[Boost-users] problem with memcpy to shared memory

Cuneyt Taskiran