프로그래밍/C/C++2010.03.19 15:54
1. ACE
ACE에 대한 개요는 다음 게시물을 참조하기 바랍니다.


2. echo server 예제 
#include <ace/OS.h>
#include <ace/Log_Msg.h>
#include <ace/Message_Block.h>
#include <ace/INET_Addr.h>
#include <ace/Proactor.h>
#include <ace/Asynch_IO.h>
#include <ace/Asynch_Acceptor.h>

class Stream_Handler : public ACE_Service_Handler {
private :
	ACE_Asynch_Read_Stream	reader_;
	ACE_Asynch_Write_Stream writer_;
	ACE_INET_Addr			remote_address_;

public :
	~Stream_Handler()
	{
		if( this->handle() != ACE_INVALID_HANDLE )
			ACE_OS::closesocket(this->handle());
	}

	//override
	virtual void open(ACE_HANDLE new_handle, ACE_Message_Block &message)
	{
		ACE_TRACE("Stream_Handler::open");
		ACE_ASSERT(new_handle != ACE_INVALID_HANDLE);
		this->handle(new_handle);
		if( reader_.open(*this) != 0 || writer_.open(*this) != 0 )
		{
			ACE_ERROR((LM_ERROR, "[ERROR%T](%N:%l) ### %p\n", "Stream_Handler::open"));
			delete this;
			return;
		}
		ACE_Message_Block *mb;
		ACE_NEW_NORETURN(mb, ACE_Message_Block(1024));
		if( reader_.read(*mb, mb->space()) != 0 )
		{
			ACE_ERROR((LM_ERROR, "[ERROR%T](%N:%l) ### %p\n", "Stream_Handler::open"));
			delete this;
			return;
		}
		ACE_DEBUG((LM_INFO, "[DEBUG%T](%N:%l) ### New client accepted: %s:%u\n", 
				remote_address_.get_host_addr(), remote_address_.get_port_number()));
	}

	//override
	virtual void addresses(const ACE_INET_Addr &remote_address, const ACE_INET_Addr &local_address)
	{
		ACE_TRACE("Stream_Handler::addresses");
		ACE_UNUSED_ARG(local_address);
		remote_address_ = remote_address;
	}
	
	//override
	virtual void handle_read_stream(const ACE_Asynch_Read_Stream::Result &result)
	{
		ACE_TRACE("Stream_Handler::handle_read_stream");
		ACE_Message_Block &mb = result.message_block();
		if( !result.success() || result.bytes_transferred() == 0 )
		{
			ACE_DEBUG((LM_INFO, "[DEBUG%T](%N:%l) ### Connection close %s:%u\n", 
				remote_address_.get_host_addr(), remote_address_.get_port_number()));
			mb.release();
			delete this;
		}
		else
		{
			if( writer_.write (mb, mb.length ()) != 0 )
			{
				ACE_ERROR((LM_ERROR, "[ERROR%T](%N:%l) ### %p\n", 
                                       "Stream_Handler::handle_read_stream"));
				mb.release();
				delete this;
			}
			else
			{
				ACE_Message_Block *new_mb;
				ACE_NEW_NORETURN(new_mb, ACE_Message_Block(1024));
				reader_.read(*new_mb, new_mb->space());
			}
		}
	}
	
	//override
	virtual void handle_write_stream(const ACE_Asynch_Write_Stream::Result &result)
	{
		ACE_TRACE("Stream_Handler::handle_write_stream");
		result.message_block().release();
	}

};


int ACE_TMAIN(int agrc, ACE_TCHAR *argv[])
{
	ACE_INET_Addr listen;
	listen.set(9088);
	ACE_Asynch_Acceptor<Stream_Handler> acceptor;
	acceptor.open(listen, 
		0,	// byte to read
		1,	// call pass_address
		ACE_DEFAULT_ASYNCH_BACKLOG,
		1,	// reuse_addr
		0,	// default proactor
		0,	// validate new connection
		1,	// reissue accept
		-1);// number of initial accepts
	ACE_Proactor::instance()->proactor_run_event_loop();
	ACE_RETURN(0);
}

3. ACE와 Boost.Asio
ACE와 Boost.Asio는 멀티플랫폼 고성능 서버를 개발하기 위한 최고의 C++ 도구입니다.
(당분간 이 둘을 뛰어넘는 라이브러리는 나오기는 힘들것 이라고 개인적으로 생각합니다.)

특히 고성능 서버 개발을 위한 비동기 작업을 운영체제의 구분에 관계없이 Proactor라는 패턴을 통해 접근할 수 있습니다.
물론 두 라이브러리 모두 Proactor를 구현할수 없는 플랫폼에 대해서는 Reactor를 통해 Proactor를 시뮬레이션해주는 기능 또한 제공합니다.


ACE와 Boost.Asio를 프로젝트에 사용하게 됨으로써 얻는 효과는 분명하지만, 이 두 라이브러리의 진입 장벽이 결코 낮지 않습니다. C++은 손바닥 뒤집듯이 자유롭게 구사할 수 있어야 하며, 디자인 패턴, 운영체제, TCP/IP 및 네트워킹에 대한 이해를 필요로 합니다. 특히 ACE의 경우 Boost.Asio보다 더욱 방대한 영역을 다루고 있기 때문에 라이브러리가 더 크고 무거우며, 그만큼 더 많은 학습량을 요구합니다.

개인적으로는 ACE를 먼저 접하고 Boost.Asio를 접하게 되었는데, Boost.Asio를 이해하는데 많은 시간이 걸리지는 않았습니다. ACE와 Boost.Asio의 예제 코드를 확인해보면 서로 유사한 형태를 지니고 있음을 확인할 수 있는데, 이는 제가 의도적으로 코드를 비슷하게 작성한 것이 아니라, 두 라이브러리 모두 Proactor라는 디자인 패턴을 통해 비동기 오퍼레이션을 처리하기 때문입니다.

ACE는 Proactor를 비롯해서 Reactor, 쓰레드, 동기화 객체, 시그널 등 운영체제의 많은 부분을 캡슐화 하고 있습니다. Boost.Asio는 쓰레드나 동기화 객체와 같은 주제를 포함하지 않지만 Boost 라이브러리 전체로 범위를 넓혀보면 ACE와 마찬가지로 쓰레드, 동기화 객체, 시그널 등을 모두 포함하고 있음을 확인할 수 있습니다. 특히 Boost는 차세대 C++ 표준이라 불리우는만큼 성능이나 버그등에 대해서는 의심의 여지가 없으며, 기존의 코드와도 쉽게 결합할수 있습니다. 

따라서, ACE와 Boost.Asio 중 선택적으로 학습을 해야하는 경우라면 Boost.Asio를 먼저 추천하겠습니다.
Posted by devop

댓글을 달아 주세요

프로그래밍/C/C++2010.03.19 13:11
1. Boost.Asio
대부분의 프로그램들은 파일, 네트워크, 시리얼 케이블 또는 콘솔을 통해 외부와 소통합니다. 때론 네트워크를 사용하는 단일 입출력 작업의 완료에 많은 시간이 소모됩니다. 이러한 문제는 프로그램 개발에서 까다로운 문제입니다.

Boost.Asio는 스레드, 명시적 락킹에 기반한 동시성 모델을 사용하지 않고 이러한 긴 동작을 관리하는 도구를 제공합니다.

Boost.Asio라이브러리는 C++을 사용해 네트워크같은 운영체제의 기능을 자주 접근하는 시스템 프로그래밍을 위해 만들어졌습니다. 특히 Boost.Asio는 다음을 목표합니다.

  • 이식성 - 일반적으로 사용되는 운영체제를 지원합니다. 그리고 지원되는 운영체제에서 동일한 동작을 제공합니다.
  • 확장성 - 수천이 동시 접속 가능한 네트워크 응용프로그램 개발을 가능하게 합니다. 확장성을 위해 각각의 운영체제에서 지원하는 최적의 메커니즘을 사용해 구현합니다.
  • 효율성 - scatter-gather I/O를 지원하고, 데이터 복사를 최소화한 프로그램을 가능하게 합니다.
  • BSD 소켓같은 널리 알려진 API로부터 모델 개념화. BSD 소켓 API는 널리 구현되고 알려져 많은 문헌에서 정보를 얻을 수 있습니다. 다른 프로그래밍 언어도 종종 네트워크 API에 유사한 인터페이스를 사용합니다. Boost.Asio는 합리적으로 기존의 경험을 활용할 수 있습니다.
  • 쉬운 사용 - 새로운 사용자들에게 툴킷을 사용하여 프레임워크보다 진입 장벽을 낮춰줍니다. 기본적인 규칙과 가이드라인을 학습하는데 필요한 초기 투자를 최소화 할 수 있습니다. 그리고 라이브러리 사용자는 명시된 함수의 사용방법만 이해하면 됩니다.
  • 앞으로의 추상화를 위한 기반. 상위 수준의 추상화를 제공하는 다른 라이브러리 개발을 가능하게 합니다. 예를 들어, HTTP같은 널리 사용되는 프로토콜을 구현할 수 있습니다.

Boost.Asio는 기본적으로 네트워크에 초점을 맞추고 시작되어, 비동기 입출력 개념을 시리얼 포트, 파일등의 운영체제의 다른 자원을 포함하도록 확장되었습니다.


2. echo server 예제
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>


class Stream_Handler {
public :
	typedef boost::asio::ip::tcp::socket Peer;

private :
	Peer peer_;
	char buf_[1024];
 
public :
	Stream_Handler(boost::asio::io_service &io_service)
		: peer_(io_service) 
	{ /* empty */ }

	void open()
	{
		peer_.async_read_some(boost::asio::buffer(buf_, 1024),
			boost::bind(&Stream_Handler::handle_read_stream, this,
				boost::asio::placeholders::error,
				boost::asio::placeholders::bytes_transferred));
	}

	void handle_read_stream(const boost::system::error_code &err, size_t byte_transferred) 
	{
		if( !err )
		{
			boost::asio::async_write(peer_, boost::asio::buffer(buf_, byte_transferred),
				boost::bind(&Stream_Handler::handle_write_stream, this, boost::asio::placeholders::error));
				
		}
		else
		{
			std::cout << "handle_read_stream: " << err << std::endl;
			delete this;
		}
	}

	void handle_write_stream(const boost::system::error_code &err)
	{
		if( !err )
		{
			peer_.async_read_some(boost::asio::buffer(buf_, 1024),
				boost::bind(&Stream_Handler::handle_read_stream, this,
					boost::asio::placeholders::error,
					boost::asio::placeholders::bytes_transferred));
		}
		else
		{
			std::cout << "handle_write_stream: " << err << std::endl;
			delete this;
		}
	}

	Peer& peer()
	{
		return peer_;
	}

};


class Echo_Server {
private :
	boost::asio::ip::tcp::acceptor acceptor_;

	void new_handler()
	{
		Stream_Handler *handler = new Stream_Handler(acceptor_.io_service());
		acceptor_.async_accept(handler->peer(), boost::bind(&Echo_Server::handle_accept, this, 
			handler, boost::asio::placeholders::error));
	}

public :
	Echo_Server(boost::asio::io_service &io_service, short port)
		: acceptor_(io_service, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
	{
		new_handler();
	}

	void handle_accept(Stream_Handler *handler, 
		const boost::system::error_code &err)
	{
		if( !err )
		{
			handler->open();
			std::cout << "New client accepted: " << 
                               handler->peer().remote_endpoint().address().to_string() << std::endl;
			new_handler();
		}
		else 
		{
			std::cout << "handle_accept: " << err << std::endl;
			delete this;
		}
	}

};


int _tmain(int argc, _TCHAR* argv[])
{
	short port = 9088;
	try {
		boost::asio::io_service io_service;
		Echo_Server echo_server(io_service, port);
		io_service.run();
	} catch(std::exception &e) {
		std::cout << "Unexpected error: " << e.what() << std::endl;
	}
	return 0;
}

3. Boost.Asio 비동기(asynchronous) 오퍼레이션
Boost.Asio의 비동기 오퍼레이션을 사용한다는 것은 비동기 오퍼레이션이 완료되었을 때, 콜백을 받을수 있는 객체(또는 함수)가 존재한다는 뜻입니다. 

io_service.run();

위 코드는 Boost.Asio 비동기 오퍼레이션을 수행하기 위한 중요한 부분인데, 콜백 핸들러는 오직 현재 boost::io_service::run() 함수를 호출한 쓰레드로부터 호출됨을 보장해 줍니다. 따라서 위 코드가 실행되지 않았다면, 비동기 오퍼레이션의 완료 콜백은 절대 일어나지 않습니다.

또한,  boost::io_service::run() 함수를 호출하기 전에 io_service 객체에 무언가 작업(비동기 오퍼레이션)을 걸어 주는것은 중요합니다. 아무 할일이 없다면 boost::io_service::run() 함수를 곧바로 리턴되기 때문입니다.
반대로, boost::io_service::run() 함수는 아직 작업(비동기 오퍼레이션)이 남아있는 동안에는 리턴되지 않습니다.


4. 멀티쓰레드 환경에서 콜백 핸들러 동기화
위 코드에서는 boost::io_service::run() 함수의 호출이 하나의 쓰레드(메인 쓰레드)에서만 이루어 집니다. 이것은 콜백 핸들러가 동시에 실행되지 않음을 의미합니다,.(boost::io_service::run()함수를 호출한 쓰레드에서 콜백 핸들러가 실행되기 때문)
이와 같이 boost::io_service::run()함수의 호출을 싱글쓰레드로 제한하는 것이 보통 최선의 방법의 방법으로 여겨질수 있으나, 다음과 같은 단점이 있습니다.

  • 콜백 핸들러의 처리가 늦어지면, 전체 응답시간이 늦어집니다.
  • 멀티프로세서 시스템의 장점을 이용할 수 없습니다.

실제로 위와 같은 문제와 만난다면, boost::io_service::run()함수를 다수의 쓰레드에서 호출하는 방법을 사용할 수 있습니다. 하지만 이것은 콜백 핸들러가 공유자원에 동시 접근이 가능한 것을 의미하며, 공유자원에 대한 접근을 동기화해야 합니다.

boost::asio::strand

boost::asio::strand는 콜백 핸들러의 엄격한 순차적 호출을 보장해줍니다. 즉, 이것을 사용함으로서, 코드의 실행은 명시적인 Locking이 필요없어 지게 됩니다.(뮤텍스 호출과 같은)  오직 하나의 쓰레드에서 boost::io_service::run()함수를 호출하는 것은 모든 콜백 핸들러가 암시적인 boost::asio::strand안에서 실행된다는 것을 의미합니다. io_service는 핸들러가 오직 boost::io_service::run()을 통해서만 호출되는 것을 보장해주기 때문입니다.
Posted by devop

댓글을 달아 주세요