Boost::asio, разделяемая память и межпроцессное взаимодействие

У меня есть приложение, написанное для использования boost::asioисключительно в качестве источника входных данных, поскольку большинство наших объектов основано на сетевой связи. Из-за некоторых специфических требований теперь нам требуется возможность использования общей памяти в качестве метода ввода. Я уже написал компонент общей памяти, и он работает относительно хорошо.

Проблема заключается в том, как обрабатывать уведомления от процесса с общей памятью к приложению-потребителю о том, что данные доступны для чтения --нам нужно обрабатывать данные в существующем входном потоке (с помощьюboost::asio), и мы также необходимо не блокировать этот входной поток, ожидающий данных.

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

Это работает и сейчас, но введение промежуточного потока означает, что в значительном количестве случаев у нас есть дополнительное переключение контекста, прежде чем мы сможем прочитать данные, что отрицательно сказывается на задержке, а накладные расходы на дополнительный поток нить тоже относительно дорогая.

Вот упрощенный пример того, что делает приложение:

#include <iostream>
using namespace std;

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/bind.hpp>

class simple_thread
{
public:
   simple_thread(const std::string& name)
      : name_(name)
   {}

   void start()
   {
      thread_.reset(new boost::thread(
         boost::bind(&simple_thread::run, this)));
   }

private:
   virtual void do_run() = 0;

   void run()
   {
      cout << "Started " << name_ << " thread as: " << thread_->get_id() << "\n";
      do_run();
   }


protected:
   boost::scoped_ptr<boost::thread> thread_;
   std::string name_;
};

class input_thread
   : public simple_thread
{
public:
   input_thread() : simple_thread("Input")
   {}

   boost::asio::io_service& svc()
   {
      return svc_;
   }

   void do_run()
   {
      boost::system::error_code e;
      boost::asio::io_service::work w(svc_);
      svc_.run(e);
   }

private:
   boost::asio::io_service svc_;
};

struct dot
{
   void operator()()
   {
      cout << '.';
   }
};

class interrupt_thread
   : public simple_thread
{
public:
   interrupt_thread(input_thread& input)
      : simple_thread("Interrupt")
     , input_(input)
   {}

   void do_run()
   {
      do
      {
         boost::this_thread::sleep(boost::posix_time::milliseconds(500));
         input_.svc().post(dot());
      }
      while(true);
   }

private:
   input_thread& input_;
};

int main()
{
   input_thread inp;
   interrupt_thread intr(inp);

   inp.start();
   intr.start();

   while(true)
   {
      Sleep(1000);
   }
}

Есть ли способ получить данные, обрабатываемые в input_threadнапрямую (без необходимости postих вводить через interrupt_thread? Предполагается, что поток прерывания полностью управляется синхронизацией от внешнего приложения (, уведомляющего о доступности данных через семафор ). Кроме того, предположим, что у нас есть полный контроль как над приложениями-потребителями, так и над приложениями-поставщиками.что у нас есть дополнительные объекты, которые должны обрабатываться объектом input_thread(, поэтому мы не можем просто заблокировать и ждать там объекты семафора). Цель состоит в том, чтобы уменьшить накладные расходы, использование ЦП и задержку данных, поступающих через приложение, предоставляющее общую память.