2) Can we use contexts like condition variables? Can we make something like this: struct task{ // Implementanion }; std::deque<task> g_tasks; continuation g_cont; boost::thread::mutex g_mutex; // Executes ready tasks void thread_1() { // This function will be run in thread #1 while(1) { scoped_lock lock(g_mutex); if (g_tasks.empty()) { lock.unlock(); g_cont.suspend(); } else { auto t = g_tasks.front(); g_tasks.pop_front(); lock.unlock(); t.run(); } } } // Generate tasks void threads_2_n() { // This function will be run in threads #2, #3 ... while(1) { // Generating task t task t; t.generate(); scoped_lock lock(g_mutex); g_tasks.push_back(t); lock.unlock(); g_cont.resume(); } } Will there be some performance gains, because there is no more system calls for condition variables? If answer is yes for 2), then it is a killer feature and I will vote YES and write a more detailed review. P.S.: Sorry for two mails, instead of one. Best regards, Antony Polukhin

Am 09.01.2012 19:35, schrieb Antony Polukhin:

1) What if we reimplement the ASIO example without Boost.Context (server class will look like this):

class server : public boost::enable_shared_from_this< server> { private: boost::asio::ip::tcp::acceptor acceptor_; boost::array< char, 1024> buffer_;

void do_() { boost::asio::ip::tcp::socket socket( acceptor_.get_io_service() ); acceptor_.async_accept( socket, boost::bind(& server::do_1_, this->shared_from_this(), _1) ); }

void do_1_(boost::system::error_code ec) { if (!ec) { socket.async_read_some( boost::asio::buffer(buffer_), boost::bind(& server::do_2_, this->shared_from_this(), _1, _2) ); } else { do_(); } }

void do_2_(boost::system::error_code ec, size_t n) if (!ec) { boost::asio::async_write( socket, boost::asio::buffer( buffer, n), boost::bind(& server::do_1_, this->shared_from_this(), _1) ); } else { do_(); } } }

server( boost::asio::io_service& io_service, short port) : acceptor_( io_service, boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), port) ), {}

public: typedef boost::shared_ptr< server> ptr_t;

static ptr_t create( boost::asio::io_service& io_service, short port) { return ptr_t( new server( io_service, port) ); }

void operator()( boost::system::error_code /*ec*/, size_t /*n*/) { do_(); } };

Looks like this implementation will be faster (it has the same amount of io_service posted functions, no dynamic allocations, but has no context switches). Am I missing something?

Beside the stack allocation (which could be preallocated and/or reused) the boost.context function will not be slower. With 'context switches' I don't mean context switches in the case of threads! 'context switches' in boost.context consist of saving/restoring relevant registers like stack pointer, instruction pointer, non-scratch registers etc = the code generated by the compiler does the same (which registers are saved/restored by a function call is defined by the 'call convention' like cdecl etc.). The ASIO example using boost.context is equivalent to using from functions do_<xyz>_() in this sense. The benefit in using boost.context is, that the code can be written more straight forward. Your logic isn't scattered among several functions (do_<xyz>_()). I think Chris might explain this issue better than me in its article 'Thinking Asynchronously in C++' at http://blog.think-async.com/2009/08/secret-sauce-revealed.html. I adopted Chris example. Oliver