전달하고자 하는                                                                        처리를 위해 기다리고있는 
메시지 버퍼                                                                            메시지 버퍼 
 +----+     +-------------------+   +----+          +----+     +-------------------+     +----+ 
 |++++|     | SOCK_Connector    |   |++++|          |++++|     | SOCK_Acceptor     |     |++++| 
 +----+     | SOCK_Stream       |   +----+          +----+     | SOCK_Stream       |     +----+ 
   |        | connect()     ----|------------------------------|>accept()          |       |    
 +----+     | send() / recv()   |                              | send()/recv()     |     +----+ 
 |++++|     | close()           |                              | close()           |     |++++| 
 +----+     +-------------------+                              +-------------------+     +----+ 
   |                                                                                       | 
 +----+                                                                                  +----+ 
 |++++|                                                                                  |++++| 
 +----+                                                                                  +----+ 
 

1. 네트워크 애플리케이션을 작성하게 되면 응용 수준의 프로토콜들을 정의 한다. 그러기 위해서는 메시지에서 헤더,데이터등을 분리할 수 있어야 한다.
   
2. MTU(12)등에 의해서 메시지는 분리되거나 혹은 붙어서 들어올 수 있다. 이경우 단위 메시지로 만들기 위한 루틴이 필요하게 된다.
   
3. 받아들인 메시지는 다른 프로세스나 쓰레드로 넘기기 위해서 버퍼형태로 관리 될 수 있어야 한다.
   
   

1. 각각의 ACE_Message_Block는 실제 다루어야할 데이터를 포함하고 있는 ACE_Data_Block에 대한 포인트 정보를 가지고 있다.
   
2. 다중의 메시지를 chain 형태로 관리할 수 있다.
   
3. 다중의 메시지를 ACE_Message_Queue를 통해서 동시 관리 가능하다.
   
4. 자동으로 동기화와 메모리 관리가 이루어진다.
   

 +-----------------------------------------------+ 
 | ACE_Message_Block                             | 
 +-----------------------------------------------+ 
 | # rd_ptr_ : size_t                            | 
 | # wr_ptr_ : size_t                            | 
 | # cont_ : ACE_Message_Block *                 | 
 | # next_ : ACE_Message_Block *                 | 
 | # prev_ : ACE_Message_Block *                 | 
 | # data_block_ : ACE_Data_Block *              | 
 | + init (size: size_t) : int                   | 
 | + msg_type (type : ACE_Message_Type)          |            +------------------+ 
 | + msg_type () : ACE_message_Type              |            | ACE_Data_Block   | 
 | + msg_priority (prio : u_long)                |<>--------> +------------------+ 
 | + clone () : ACE_Message_Block *              |*         1 | # base_ : char * | 
 | + duplicate () : ACE_Message_Block *          |            | # refcnt_ : int  | 
 | + release () : ACE_Message_Block *            |            +------------------+ 
 | + set_flags (flags : u_long) : u_long         |            +------------------+ 
 | + clr_flags (flags : u_long) : u_long         | 
 | + copy (buf : const char *, n : size_t) : int | 
 | + rd_ptr (n : size_t)                         | 
 | + rd_ptr () : char *                          | 
 | + wr_ptr (n : size_t)                         | 
 | + wr_ptr () : char *                          | 
 | + length () : size_t                          | 
 | + total_length () : size_t                    | 
 | + size () : size_t                            | 
 +-----------------------------------------------+ 
 

9.19.1 2종류의 ACE_Message_Block 클래스

간단한 메시지와(Simple Message Structure) 여러형태의 메시지를 포함한 (Composite message contain) 형태를 처리할 수 있도록 지원되고 있다.

간단한 메시지를 지원하는 ACE_Message_Block는 하나의 단일한 형식을 가지는 데이터를 포인트한다.

반면 두개이상의 ACE_Message_Block가 서로다른 형태를 가지는 데이터를 사용해야 하는 경우가 있을 것이다. 이러한 경우는 여러종류의 메시지를 처리해야 하는 미들웨어를 작성하고자 할경우 종종발생한다. ACE_Message_Block는 이러한 복잡한 형태의 데이터구조를 관리하도록 지원한다.

9.20 ACE_Message_Block의 이용

다음은 ACE_Message_Blocks를 이용해서 어떻게 데이터의 목록을 만들고 유지하는지를 보여준다.

int main (int argc, char *argv[]) 
{ 
  // BUFSIZ의 크기를 가지는 ACE_Message_Block를 생성한다. 
  ACE_Message_Block *head = new ACE_Message_Block (BUFSIZ); 
  ACE_Message_Block *mblk = head; 
 
  for (;;) { 
    // wr_ptr ()을 이용해서 표준입력으로 부터 읽어들인 데이터를  
    // 쓴다. 
    ssize_t nbytes = ACE::read_n (ACE_STDIN,  
                                  mblk->wr_ptr (),  
                                  mblk->size ()); 
    if (nbytes <= 0) 
      break; // Break out at EOF or error. 
 
    // 읽어들인 메시지의 끝을 명확히 하기 위해서 크기를 명시한다. 
    mblk->wr_ptr (nbytes);  
 
    mblk->cont (new ACE_Message_Block (BUFSIZ)); 
    mblk = mblk->cont (); 
  } 
 
  // Print the contents of the list to the standard output. 
  for (mblk = head; mblk != 0; mblk = mblk->cont ())  
    ACE::write_n (ACE_STDOUT, mblk->rd_ptr (), mblk->length ()); 
   
  head->release (); // Release all the memory in the chain. 
  return 0; 
} 
 

10 Client Application 작성

10.1 Logging Client

그럼 ACE C++ Socket Wrapper facades를 이용해서 작성된 클라이언트 프로그램의 형태에 대해서 알아보도록 한다.

class Logging_Client { 
public: 
  // Send <log_record> to the server. 
  int send (const ACE_Log_Record &log_record); 
  // Accessor method. 
  ACE_SOCK_Stream &peer () { return logging_peer_; } 
  // Close the connection to the server. 
  ~Logging_Client () { logging_peer_.close (); } 
private: 
  ACE_SOCK_Stream logging_peer_; // Connected to server. 
}; 
 

다음은 Logging_Client::send() 메서드에 대한 설명이다.

1. 데이터의 크기를 계산한다. (2-8)
   
2. 데이터에서 헤더와 body부분을 분리해낸다. (10-16)
   
3. 분리된 정보는 logging server 로 보낸다.(18-24)
   

 1 int Logging_Client::send (const ACE_Log_Record &log_record) { 
 2   const size_t max_payload_size = 
 3       4 // type() 
 4     + 8 // timestamp 
 5     + 4 // process id 
 6     + 4 // data length 
 7     + ACE_Log_Record::ACE_MAXLOGMSGLEN // data 
 8     + ACE_CDR::MAX_ALIGNMENT; // padding; 
 9  
10   ACE_OutputCDR payload (max_payload_size); 
11   payload << log_record; 
12   ACE_CDR::ULong length = payload.total_length (); 
13  
14   ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8); 
15   header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER); 
16   header << ACE_CDR::ULong (length); 
17  
18   iovec iov[2]; 
19   iov[0].iov_base = header.begin ()->rd_ptr (); 
20   iov[0].iov_len  = 8; 
21   iov[1].iov_base = payload.begin ()->rd_ptr (); 
22   iov[1].iov_len  = length; 
23  
24   return logging_peer_.sendv_n (iov, 2); 
25 } 
 

다음은 main함수다.

 1 int main (int argc, char *argv[])  
 2 { 
 3   u_short logger_port = 
 4     argc > 1 ? atoi (argv[1]) : 0; 
 5   const char *logger_host = 
 6     argc > 2 ? argv[2] : ACE_DEFAULT_SERVER_HOST; 
 7   int result; 
 8  
 9   ACE_INET_Addr server_addr; 
10    
11   if (logger_port != 0) 
12     result = server_addr.set (logger_port, logger_host); 
13   else 
14     result = server_addr.set ("ace_logger", logger_host); 
15   if (result == -1)  
16     ACE_ERROR_RETURN((LM_ERROR, 
17                      "lookup %s, %p\n", 
18                      logger_port == 0 ? "ace_logger" : argv[1], 
19                      logger_host), 1); 
20 
21   ACE_SOCK_Connector connector; 
22   Logging_Client logging_client; 
23  
24   if (connector.connect (logging_client.peer (), 
25                          server_addr) < 0) 
26     ACE_ERROR_RETURN ((LM_ERROR, 
27                       "%p\n", 
28                       "connect()"), 
29                       1); 
30 
31   // Limit the number of characters read on each record. 
32   cin.width (ACE_Log_Record::MAXLOGMSGLEN); 
33   for (;;) { 
34     std::string user_input; 
35     getline (cin, user_input, '\n'); 
36  
37     if (!cin || cin.eof ()) break; 
38  
39     ACE_Time_Value now (ACE_OS::gettimeofday ()); 
40     ACE_Log_Record log_record (LM_INFO, now, 
41                                ACE_OS::getpid ()); 
42     log_record.msg_data (user_input.c_str ()); 
43  
44     if (logging_client.send (log_record) == -1) 
45       ACE_ERROR_RETURN ((LM_ERROR, 
46                          "%p\n", "logging_client.send()"), 1); 
47   } 
48  
49   return 0; // Logging_Client destructor  
50             // closes TCP connection. 
51 } 
 
 

11 Logging Server 작성

다음은 작성할 Logging_Server의 클래스 계층이다. Logging_Handler class는 간단하게 정의 할 수 있을 것이다. 계층을 이루고 있는 각각의 클래스는 별도로 설명을 하도록 하겠다.

 +----------------------------------------------------------------------+ 
 | Logging_Server                                                       |  
 +----------------------------------------------------------------------+ 
 | - acceptor_ : ACE_SOCK_Acceptor                                      |  
 +----------------------------------------------------------------------+ 
 | + run(argc, : int, argv : char **) : int                             | 
 | # open (port : w_short = 0) : int                                    | 
 | # wait_for_multiple_events () : int                                  | 
 | # handle_connections () : int                                        | 
 | # handle_data (s : ACE_SOCK_Stream *) : int                          | 
 | # make_log_file (f : ACE_FILE_IO&, s, ACE_SOCK_Stream *= 0): int     | 
 | # acceptor() : ACE_SOCK_Acceptor&                                    | 
 +----------------------------------------------------------------------+ 
                                 ^ 
                                 | 
       +------------------------------------------------------+ 
       |                |                 |                   | 
 +-----------+    +-----------+    +-------------+     +-------------+ 
 | Iterative |    | Reactive  |    | Process Per |     | Thread Per  | 
 | Logging   |    | Logging   |    | Connection  |     | Connection  | 
 | Server    |    | Server    |    | Logging     |     | Logging     | 
 +-----------+    +-----------+    | Server      |     | Server      | 
       |                |          +-------------+     +-------------+ 
       |                |                 |                |  ^ 
       |                |   +-------------+                |  | 
       |                |   |                              |  | 
       |        +-----------------+                        |  | 
       +------<>| Logging_Handler |<-----------------------+  | 
                +-----------------+                           | 
                                                        +---------------+ 
                                                        | RT Thread Per | 
                                                        | Connection    | 
                                                        | Logging       | 
                                                        | Server        | 
                                                        +---------------+ 
 

11.1 Logging Server 코드

이 예제는 ACE_Message_Block와 ACE CDR 클래스를 이용해서 만든 간단한 로깅 서버다.

// Forward declaration. 
class ACE_SOCK_Stream; 
 
class Logging_Server 
{ 
public: 
  // Template Method that runs logging server's event loop. 
  virtual int run (int argc, char *argv[]); 
 
protected: 
  // The following four methods are ``hooks'' that can be 
  // overridden by subclasses.  
  virtual int open (u_short logger_port = 0); 
  virtual int wait_for_multiple_events () { return 0; } 
  virtual int handle_connections () = 0; 
  virtual int handle_data (ACE_SOCK_Stream * = 0) = 0; 
  // This helper method can be used by the hook methods. 
  int make_log_file (ACE_FILE_IO &, ACE_SOCK_Stream * = 0); 
 
  // Close the socket endpoint and shutdown ACE. 
  virtual ~Logging_Server () {  
    acceptor_.close ();  
  } 
 
  // Accessor. 
  ACE_SOCK_Acceptor &acceptor () {  
    return acceptor_;  
  } 
 
private: 
  // Socket acceptor endpoint.  
  ACE_SOCK_Acceptor acceptor_;  
}; 
 

#include "ace/FILE_Addr.h" 
#include "ace/FILE_Connector.h" 
#include "ace/FILE_IO.h" 
#include "ace/INET_Addr.h" 
#include "ace/SOCK_Stream.h" 
#include "Logging_Server.h" 
 
int Logging_Server::run (int argc, char *argv[]) 
{ 
  if (open (argc > 1 ? atoi (argv[1]) : 0) == -1) 
    return -1; 
 
  for (;;) { 
    if (wait_for_multiple_events () == -1) return -1; 
    if (handle_connections () == -1) return -1; 
    if (handle_data () == -1) return -1; 
  } 
  return 0; 
} 
int Logging_Server::open (u_short logger_port) 
{ 
  // Raises the number of available socket handles to  
  // the maximum supported by the OS platform. 
  ACE::set_handle_limit (); 
     
  ACE_INET_Addr server_addr; 
  int result; 
 
  if (logger_port != 0) 
    result = server_addr.set (logger_port, INADDR_ANY); 
  else 
    result = server_addr.set ("ace_logger", INADDR_ANY); 
  if (result == -1) return -1; 
 
  // Start listening and enable reuse of listen address  
  // for quick restarts. 
  return acceptor_.open (server_addr, 1); 
} 
int Logging_Server::make_log_file (ACE_FILE_IO &logging_file, 
                                   ACE_SOCK_Stream *logging_peer) 
{  
  std::string filename (MAXHOSTNAMELEN, ’\0’); 
 
  if (logging_peer != 0) { // Use client host name as file name. 
    ACE_INET_Addr logging_peer_addr; 
    logging_peer->get_remote_addr (logging_peer_addr); 
    logging_peer_addr.get_host_name (filename.c_str (),  
                                     filename.size ()); 
    filename += ".log"; 
  } else filename = "logging_server.log"; 
 
  ACE_FILE_Connector connector; 
  return connector.connect (logging_file,  
                            ACE_FILE_Addr (filename.c_str ()), 
                            0, // No time-out. 
                            ACE_Addr::sap_any, // Ignored. 
                            0, // Don't try to reuse the addr. 
                            O_RDWR|O_CREAT|O_APPEND, 
                            ACE_DEFAULT_FILE_PERMS); 
} 
 

11.2 Logging_Handler 작성

#include "ace/FILE_IO.h" 
#include "ace/SOCK_Stream.h" 
 
class ACE_Message_Block; // Forward declaration. 
 
class Logging_Handler 
{ 
protected: 
  // Reference to a log file. 
  ACE_FILE_IO &log_file_;  
 
  // Connected to the client. 
  ACE_SOCK_Stream logging_peer_;  
  // Receive one log record from a connected client.  <mblk>  
  // contains the hostname, <mblk->cont()> contains the log  
  // record header (the byte order and the length) and the data.  
  int recv_log_record (ACE_Message_Block *&mblk); 
 
  // Write one record to the log file. The <mblk> contains the  
  // hostname and the <mblk->cont> contains the log record.  
  int write_log_record (ACE_Message_Block *mblk); 
 
  // Log one record by calling <recv_log_record> and 
  // <write_log_record>.  
  int log_record ();  
} 
 
// 데이터를 받아들이고, 받아들인 데이터는 CDR클래스를 이용해서 해더파싱을 해서 
// 필요한 정보를 얻어온다. 
// 최종적으로는 ACE_Message_Block chain을 저장한다. 
int Logging_Handler::recv_log_record (ACE_Message_Block *&mblk) 
{ 
  ACE_INET_Addr peer_addr; 
  logging_peer_.get_remote_addr (peer_addr); 
  mblk = new ACE_Message_Block (MAXHOSTNAMELEN + 1); 
  peer_addr.get_host_name (mblk->wr_ptr (), MAXHOSTNAMELEN); 
  mblk->wr_ptr (strlen (mblk->wr_ptr ()) + 1); // Go past name. 
 
  ACE_Message_Block *payload = 
    new ACE_Message_Block (ACE_DEFAULT_CDR_BUFSIZE); 
  // Align Message Block for a CDR stream. 
  ACE_CDR::mb_align (payload); 
 
  if (logging_peer_.recv_n (payload->wr_ptr (), 8) == 8) { 
    payload->wr_ptr (8);     // Reflect addition of 8 bytes. 
 
    ACE_InputCDR cdr (payload); 
 
    ACE_CDR::Boolean byte_order; 
    // Use helper method to disambiguate booleans from chars. 
    cdr >> ACE_InputCDR::to_boolean (byte_order); 
    cdr.reset_byte_order (byte_order); 
 
    ACE_CDR::ULong length; 
    cdr >> length; 
 
    payload->size (8 + ACE_CDR::MAX_ALIGNMENT + length); 
 
    if (logging_peer_.recv_n (payload->wr_ptr(), length) > 0) { 
      payload->wr_ptr (length);   // Reflect additional bytes. 
      mblk->cont (payload); // Chain the header and payload. 
      return length; // Return length of the log record. 
    } 
  } 
  payload->release (); 
  mblk->release (); 
  payload = mblk = 0; 
  return -1; 
} 
 
// 로그 파일에 메시지를 저장한다. 만약 디버깅 flag가 설정되어 있다면  
// 메시지의 내용을 표준출력한다. 
int Logging_Handler::write_log_record (ACE_Message_Block *mblk) 
{ 
  if (log_file_->send_n (mblk) == -1) return -1; 
 
  if (ACE::debug ()) { 
    ACE_InputCDR cdr (mblk->cont ());  
    ACE_CDR::Boolean byte_order; 
    ACE_CDR::ULong length; 
    cdr >> ACE_InputCDR::to_boolean (byte_order); 
    cdr.reset_byte_order (byte_order); 
    cdr >> length; 
    ACE_Log_Record log_record; 
    cdr >> log_record;  // Extract the <ACE_log_record>. 
    log_record.print (mblk->rd_ptr (), 1, cerr); 
  } 
 
  return mblk->total_length (); 
} 
 
int Logging_Handler::log_record () 
{ 
  ACE_Message_Block *mblk = 0; 
  if (recv_log_record (mblk) == -1) 
    return -1; 
  else { 
    int result = write_log_record (mblk); 
    mblk->release (); // Free up the entire contents. 
    return result == -1 ? -1 : 0; 
  } 
} 
 
 
 

 +-------------------+           +-------------------+ 
 | ACE_Message_Block |           | ACE_Message_Block | 
 +-------------------+           +-------------------+ 
 | cont() -----------|---------->| cont()            | 
 +-------------------+           +-------------------+ 
         |                                     | 
         |                                     | 
  +----------------+                      +----------------+    
  | ACE_Data_Block |                      | ACE_Data_Block | 
  +----------------+                      +----------------+ 
  | base() --------|----> HOSTNAME        | base() --------|--> LOGRECORD DATA 
  +----------------+                      +----------------+ 
     
 

11.3 Iterative Logging Server

가장 단순한 형태의 로깅 서버다.

iterative server는 한번에 하나의 client만 받아들여서 처리하는 간단한 형태를 가진다. 만약 처리도중에 새로운 client의 연결요청이 들어온다면, 새로운 client는 이전의 client에 대한 작업을 끝내기전까지 대기해야 한다.

이러한 방식의 server는 학습용으로는 쓸만할지 모르지만 개발할 필요가 없을 것이다.

#include "ace/FILE_IO.h" 
#include "ace/INET_Addr.h" 
#include "ace/Log_Msg.h" 
#include "Logging_Server.h" 
#include "Logging_Handler.h" 
 
class Iterative_Logging_Server : public Logging_Server  
{ 
public: 
  Iterative_Logging_Server (): logging_handler_ (log_file_) {} 
 
  Logging_Handler &logging_handler () { 
    return logging_handler_;  
  } 
 
protected: 
  ACE_FILE_IO log_file_; 
  Logging_Handler logging_handler_; 
 virtual int open (u_short logger_port) {  
    if (make_log_file (log_file_) == -1) 
      ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "make_log_file()"), 
                        -1); 
    return Logging_Server::open (logger_port); 
  } 
 
  virtual int handle_connections () { 
    ACE_INET_Addr logging_peer_addr; 
 
    if (acceptor ().accept (logging_handler_.peer (), 
                            &logging_peer_addr) == -1) 
      ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "accept()"), -1); 
    ACE_DEBUG ((LM_DEBUG, "Accepted connection from %s\n", 
               logging_peer_addr.get_host_name ())); 
    return 0; 
  } 
 virtual int handle_data (ACE_SOCK_Stream *) { 
    while (logging_handler_.log_record () != -1) 
      continue; 
 
    logging_handler_.close (); // Close the socket handle. 
    return 0; 
  } 
} 
 

#include "ace/Log_Msg.h" 
#include "Iterative_Logging_Server.h" 
 
int main (int argc, char *argv[]) 
{ 
  Iterative_Logging_Server server; 
 
  if (server.run (argc, argv) == -1)  
    ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "server.run()"), 1); 
  return 0; 
} 
 

11.4 동시처리를 위해서 고려해야 할 사항

동시처리는 네트워크 프로그램의 안정성과 성능적 측면에서 필수적으로 고려되어야 하는 사항이다. 일반적으로 서버 프로그램의 경우 고려되어야 하는 것들이 많다.

동시처리와 관련되어서 많은 이슈가 제기되는 원인은, 프로세스/쓰레드의 제어(동기화, 통신, 운용), 클라이언트 정보의 유지와 분석등에 있어서 서버의 목적과 규모에 따라 다양한 방법들이 시도되어야 하기 때문이다.

여기에서는 다음과 같은 다양한 모델의 동시처리 방식에 대해서 살펴보도록 할 것이다.

1. 순차적 처리 vs 동시처리
   
2. 다중 프로세스 방식 vs 다중 쓰레드 방식
   
3. 프로세스/쓰레드 처리
   
4. User 쓰레드 vs Kernel(12) 쓰레드 vs hybrid 쓰레드 방식
   
5. 시분할 vs 실시간 스케쥴링
   
6. Task 구조 vs 메시지 기반 구조
   

11.4.1 Iterative(순차적 처리) 대 동시 처리

1. Iteratvie는 말그대로 클라이언트의 요청을 순차적으로 처리하는 방식이다. 하나의 클라이언트의 요청이 끝나야지만 다음 클라이언트의 요청이 처리될 수 있다. 처리에 걸리는 시간이 짧거나, 요청자체가 적은 경우에 간단하게 구현해서 사용할 수 있다.
   
2. 동시 처리는 동시에 여러개의 클라이언트의 요청을 받아들여서 이를 처리한다. 요청을 처리하는데 있어서 시간이 많이 걸리는 I/O 작업(DB혹은 파일 접근)이 필요할 경우 사용될 수 있다. 대부분의 바쁜 서버에서 채택되어지고 있는 방법이다.
   
   

11.4.2 다중 프로세스 대 다중 쓰레드

• 다중 프로세스 방식은 요청의 처리를 위한 클라이언트당 별개의 프로세스가 생성되는 방식이다. 생성된 프로세스는 독립적으로 작동한다. - 가상의 메모리와 입출력제어, 시그널 제어를 한다. - 또한 OS에 의해서 보호된다. 프로세스간 통신을 위해서 IPC(12)를 이용한다.
  
  
• 다중 쓰레드는 하나의 프로세스에서 여러개의 쓰레드가 병렬적으로 문맥을 교환하면서 요청을 처리하는 방식이다. 각각의 쓰레드는 프로세스에 종속적이며, 많은 자원이 프로세스에 의해서 전역적으로 관리된다 - Stack, registers, 시그널 마스크, TSD -. 쓰레드는 다른 쓰레드로 부터 보호되지 않는다. 쓰레드간 통신을 위해서 IPC를 사용할 수도 있지만, 쓰레드간 시그널과 전역변수를 이용해서 관리되기도 한다.
  
  

11.5 쓰레드풀 (Thread Pool)의 운용 전략

많은 쓰레드 응용 프로그램들은 어떠한 일이 발생할 경우 해당 일을 처리하기 위해서 새로운 쓰레드를 생성한다. 직관적인 방식이긴 하지만 새로운 쓰레드를 생성하기 위해서는 많은 비용이 발생 하다는 단점을 가진다. 이러한 문제의 해결을 위해서 쓰레드를 미리 만들어 놓고, 요청이 들어올경우 특정 쓰레드에 작업을 맡기기 위해서 쓰레드풀을 구성한다.

쓰레드풀은 아래와 같은 일반적인 두가지 방법중 하나의 방법을 선택한다.
Upload new Attachment "prevents"

11.5.1 Half-Sync/Half-Async Pattern

동기화와 비동기화 패턴 모두를 포함한다. 비동기 계층은 I/O 이벤트와 같은 비동기적인 사건을 다룬다. 데이터의 처리는 동기계층의 쓰레드들이 담당하게 된다. 동기계층과 비동기계층간의 데이터 전달을 위해서 완충영역인 Queueing 계층이 필요하다.

Upload new Attachment "halfsync_async.gif"

이 패턴은 다음과 같은 잇점을 가진다.

• Threads can be mapped to separate CPUs to scale up server performance via multi-processing
  
• Each thread blocks independently, which prevents a flow-controlled connection from degrading the QoS that other clients receive
  
  

11.5.2 Half-Sync/Half-Async Pattern의 단점

Half-Sync/Half-Async 쓰레드 모델은 일반적인 쓰레드방식(요청당 쓰레드 생성)에 비해서 효율적이며 좋은 성능을 보여주긴 하지만 다음과 같은 해결해야할 문제점들을 가지고 있다. 이러한 문제들은 동기계층과 비동기계층이라는 전혀다른 성격의 계층을 하나의 시스템에 유지함으로 주로 발생한다.

1. 동적 메모리 할당및 해제
   
2. 각 기능의 동기화
   
3. 문맥교환
   
4. CPU cache update
   

이는 잠재적인 문제들로 서버에 overhead를 주고 성능을 떨어트릴 수 있으며, 누적될 경우 서비스 자체가 불가하게 될 수도 있다.

위의 문제는 Leader/Followers architectural pattern을 이용함으로써 최소화 시킬 수 있다.

11.5.3 Leader/Followers architectural pattern

이 패턴은 Half-Sync/Half-Async 의 향상된 패턴이다. 다중 쓰레드는 이벤트소스를 공유하며, 이벤트소스로 부터터 이벤트가 발생하는 지를 기다리게 된다. 이 Half-sync/Half-Async패턴에서 Reactor 쓰레드가 분리되고, 분리된 쓰레드의 동기화를 위한 오베헤드를 제거한다.

       +------------------------+   demultiplexes 
       | Thread Poll            |<>---------------+ 
       +------------------------+                 | 
  +--<>| join()                 |                 | 
  |    | promote_new_leader()   |                 | 
  |    +------------------------+          +------------------+ 
  |          |                             | Event Handler    |     
  |          |  +--------+  uses           +------------------+ 
  |          +->| Handle | ----------------| handle_event()   | 
  |             +--------+ --------+       | get_handle()     |<|--+ 
  |                                |       +------------------+    | 
  |    +----------------------+    |                               | 
  +----| Handle Set           |<>--+                               | 
       +----------------------+            +------------------+    | 
       | handle_events()      |            | Concrete Event   |----+ 
       | deactivate_handle()  |            | Handler B        | 
       | reactivate_handle()  |            +------------------+ 
       | select()             |            | handle_event()   | 
       +----------------------+            | get_handle()     | 
                                           +------------------+ 
                                           +------------------+ 
                                           | Concrete Event   | 
                                           | Handler B        | 
                                           +------------------+ 
                                           | handle_event()   | 
                                           | get_handle()     | 
                                           +------------------+ 
 

11.6 Thread-perRequest On-demand Spawning Strategy

요청을 받는 쓰레드를 따로 분리해서, 클라이언트 연결이나, 데이터 요청이 들어왔을 때, 요청을 처리할 새로운 프로세스나 쓸레드를 생성하는 방식이다. 보통 thread-per-request와 thread-per-connection형식으로 널리 사용되고 있다.

필요할 때만 쓰레드를 생성시키면 되므로 자원의 소비를 줄일 수 있다는 장점을 가지지만, 쓰레드와 프로세스를 매번 새로 생성시켜야 하기 때문에, 실시간성을 중요하시 하거나, 많은 수의 연결/요청이 있는 서비스에는 사용하기 힘들다는 단점을 가진다.

12 N:1 와 1:1 쓰레드 모델

최근에는 컴퓨팅파워를 높이기 위해서 2개 이상의 CPU가 장착되는 경우를 흔히 볼 수 있다. 이럴경우 운영체제는 다수의 CPU를 효율적으로 관리하기 위해서 프로세스를 각 CPU에 할당시켜서 가능한 필요한 일을 빠르게 처리할 수 있도록 스케쥴링을 해주어야 한다. 쓰레드역시 마찬가지로 다수의 CPU가 있다면, 쓰레드를 효과적으로 스케쥴링할 수 있도록 OS에서 지원할 수 있어야 한다. 최근의 OS는 쓰레드를 스케쥴링하기 위한 다양한 방식을 제공하고 있다.

이러한 쓰케쥴링 방식은 크게 N:1 방식와 1:1방식 두가지가 존재한다.

Upload new Attachment "thread_model.gif"

1. Process contention scope : 하나의 쓰레드는 동일한 CPU에서 처리하는 방식으로 user threading 모델이라고 불리우기도 한다.
   
2. System contention scope : CPU가 몇개든 관계없이, System 영역에서 쓰레드가 처리된다. 단일의 CPU처럼 보고 처리하는 방식이라고 보면 된다. kernel threading 모델이라고 불리우기도 한다.
   
   

몇몇 운영체제(Solaris와 같은)는 N:1과 1:1 방식을 함께 지원하는 N:M 방식의 hybrid-threading model을 지원하기도 한다. 운영체제의 쓰레드 라이브러리는 기본적으로 user-space 쓰레드를 생성시키고, 요구될 때에만 system contention 쓰레드를 생성시킨다.

13 Task- vs. Message-based Concurrency Architectures

concurrency architecture(구조)는 다음과 같은 요소들로 구성된다.

1. CPUs : 애플리케이션의 실행코드
   
2. Data & control message : 네트워크 장치로 부터 주고 받는 데이터들
   
3. Service processing task : 메시지나 데이터를 받아서 수행하는 서비스
   
   
4. Task base concurrency 구조는 서비스 단위로 다수의 CPUs를 수행하는 방식이다.
   
5. Message base concurrency 구조는 어플리케이션 혹은 네트워크 장치를 통해서 전달되는 메시지 단위로 CPUs를 할당하는 방식이다.
   
   

14 Overview of OS Concurrency(협력) Mechanisms

많은 경우 네트워크 애플리케이션들은 서비스 요청을 해결하기 위해서 다수의 프로세스를 생성시켜야 하며, 이들 프로세스간에 협력을 유지할 수 있어야 한다. 이번 장에서는 이러한 협력의 유지를 위한 아래의 주제들에 대해서 다룰 것이다.

1. Synchronous event demultiplexing
   
2. Multiprocessing
   
3. Multi threading 1. Synchronization
   

또한 C에서 제공하는 concurrency API를 이용해서 네트워크 애플리케이션을 만드는 방법과 발생할 수 있는 여러가지 문제점/해결방안 등에 대해서 토론하도록 하겠다.

14.1 Synchronous Event Demultiplexing

다수의 메시지를 처리하는 가장 손쉬운 방식은 메시지가 들어오면 이를 버퍼에 담아두고, 이벤트를 발생시킨다음 일정시간 간격(즉 동기적)으로 이벤트가 도착했는지를 확인해서, 이벤트가 있다면 버퍼에 있는 메시지를 읽어들여서 처리하는 방식일 것이다.

이러한 이벤트 동기화를 이용한 메시지처리를 위해서 Unix 시스템은 poll()과 select(), windows는 WaitForMultipleObjects()와 같은 함수를 제공한다. 이중 select()가 이벤트 기반의 다중 입출력 데이터를 처리하기 위한 가장 일반적인 함수로 사용된다.

select()에 대한 내용은 select man page를 참고하기 바란다.

14.2 멀티 Processing 방식

멀티 Processing는 다수의 프로세스를 생성시켜서 요청을 처리하는 방식이다. Unix의 경우 fork()와 exec()함수를 이용해서 프로세스를 생성시킬 수 있으며, windows의 경우 CreateProcess()함수를 이용해서 새로운 프로세스를 생성시킬 수 있다.

멀티 프로세싱방식을 이용할 경우, 프로세스 동기화가 중요한 이슈가 되는데 유닉스의 경우 wait(), waitpid() 윈도우즈의 경우 WaitForSignalObject(), WaitForMultipleObjects()와 같은 프로세스 동기함수를 지원한다.

14.3 멀티 쓰레드 방식

운영체제는 멀티 쓰레드를 지원하기 위해서 쓰레드 생성/종료, 쓰레드 동기화, 쓰레드 특성, 쓰레드 메모리관리를 위한 함수들을 제공한다.

이들 함수에 대한 내용은 Pthread API를 참고하기 바란다.

14.4 쓰레드 동기화

쓰레드는 파일, 네트워크 장치, 데이타베이스, 공유메모리등의 자원을 공유해서 접근하는 경우가 자주 발생한다. 그러므로 이들 공유된 자원에 대한 동기화가 필요하게 된다. 다음은 동기화를 위해서 사용할 수 있는 도구들이다.

1. Mutex
   
2. 사용 semaphore
   
3. 조건변수
   
4. Read/Write lock
   
   • 파일레코드 잠금 응용
     
     

15 ACE Event Demuxing Wrapper Facades