Повысить межпроцессный режим offset_ptr и ускорить потоки для передачи данных

Я пытаюсь настроить систему для записи непрерывных байтов информации (int) с использованием управляемой разделяемой памяти boost. Это урезанная версия моего класса:

class PACKET_INFO
{
private:

offset_ptr<char> data[10];  // data pointers for various IPC threads to create transfer blocks.

public:

int Put(void * src,int to,int from,int type,int size); //write
bool message_sig; // Received message
int datasize;
int Get(void * dest,int ID); //Read
boost::interprocess::interprocess_mutex      mutex;

};

int PACKET_INFO :: Put(void * src,int to,int size)
{
managed_shared_memory managed_shm(open_only, "SHM_test");
if(message_sig) return 0; //If there's already a message waiting, don't do anything
scoped_lock<interprocess_mutex> lock(mutex,try_to_lock);
if(!lock) return 0;
data[to] = (char *)managed_shm.allocate(size*sizeof(int));
memcpy(data[to].get(),src,size*sizeof(int));
message_sig = true;
datasize = size;
}

int PACKET_INFO :: Get(void * dest,int ID)
{
managed_shared_memory managed_shm(open_only, "SHM_test");
scoped_lock<interprocess_mutex> lock(mutex,try_to_lock);
if(!lock) std::cout << "Will fail to read!" << std::endl;
memcpy(dest,data[ID].get(),datasize*sizeof(int));
message_sig = false; //Reset after receiving.
datasize = 0;
managed_shm.deallocate(data[ID].get()); //release memory
}

Я использую дополнительные данные-члены (не показаны) для проверки работоспособности перед записью и получением данных. Все соответствует запланированному. Когда выполняются два параллельных процесса (A и B), A всегда создает управляемый объект совместно используемой памяти «SHM_test» и записывает данные с помощью функции Put в B. Это делается путем выделения требуемого размера для конкретного offset_ptr и выполнения над ним memcpy , B читает эти данные с помощью функции Get и соответственно возвращает данные из определенного offset_ptr.

Теперь это работает безупречно, насколько я видел, когда эти функции вызываются двумя обычными отдельными процессами. Однако, когда я запускаю многопоточную версию A, которая использует функцию Put, она работает нормально примерно 29/30 раз. Однажды я получил ошибку в процессе B, указывающую на ошибку memcpy. На дальнейшую отладку Б я получил:

(gdb) print data[ID]
$8 = {internal = {m_offset = 18446744073690921056, alignment_helper = {data_ = {buf = "`\270\343\376\377\377\377\377",
align_ = {<No data fields>}}}}}
(gdb) print data[ID].get()
$9 = 0x7ffff346c3d0 <Address 0x7ffff346c3d0 out of bounds>

Это указывало на то, что адрес offset_ptr не был в допустимом диапазоне процесса. Чтобы быть удовлетворенным, я одновременно отлаживал процесс A:

(gdb) print Packet->data[ID]
$3 = {internal = {m_offset = 18446744073690921056, alignment_helper = {data_ = {buf = "`\270\343\376\377\377\377\377", align_ = {<No data fields>}}}}}
(gdb) print Packet->data[ID].get()
$4 = 0x7ffff3c293d0 ""

Где, Packet — это объект класса PACKET_INFO. Этот объект сконструирован как именованный объект в разделяемой памяти процессом A и найден в совместно используемой памяти процессом B. Если посмотреть на выходные данные GDB, смещения четко совпадают … это означает, что он должен работать! Но я действительно не могу понять, почему в случае многопоточного процесса A это приводит к выходу за пределы для offset_ptr процесса B.

Я знаю, что это очень упрощенная версия проблемы, но я надеюсь, что этого достаточно для диагностики или внушения.

РЕДАКТИРОВАТЬ: Предупреждение!
Поскольку поток процесса A выполняет функцию put и успешно завершает работу, я не смог отладить A в точке потока. Отладочная информация от родительского процесса.