[Network] C/C++에서 프로세스 간 통신

💡 본 문서는 'C/C++에서 프로세스 간 통신'에 대해 정리해놓은 글입니다.
프로세스 간 통신은 ip로 통신하는 것보다 빠른 일련의 과정을 통해 메모리를 주고 받고 있습니다. 이 방법 중 일부에 대해 정리하였으니 참고하시기 바랍니다.

1.  소개

많은 사람들이 무거운 작업을 분리하고 추가 최적화, 많은 독립성을 제공할 수 있기 때문에 프로그램을 위해 스레드보다 프로세스를 선택합니다. 예로 들어, Google 크롬 브라우저에서 각 탭을 실행하기 위해서 무거운 처리(예: 서버와의 통신, 네트워크 리소스 관리, 렌더링 등)을 해야하며, 각 탭은 매우 독립적으로 작동하기에 이는 프로세스를 사용하도록 작동합니다. 따라서 하나 프로세스 죽더라도 다른 프로세스에는 영향을 주지 않습니다. 또한 이 설계를 통해 비활성 탭은 운영 체제에서 우선 순위가 낮은 작업으로 처리되고 메모리가 부족할 때 디스크로 스왑되고 다른 프로세스를 위해 저장되기 때문에 메모리 최적화를 더 진행할 수 있습니다.

계산 속도와 효율성을 높이기 위해 프로세스가 협력해야 하는 상황이 많이 있습니다. 그러나 독립적인 메모리에서 실행되도록 설계되었기 때문에 시스템에서 제공하는 특별한 통신 메커니즘이 필요하며, 해당 포스팀에서는 Shared Memory, Named Pipe, UNIX Domain Socket(TCP/IP 소켓과 다름)의 세 가지 방법을 제시합니다.

2. 프로세스 간 통신

먼저 각 방법의 장단점을 살펴보겠습니다.

	Shared Memory	Named pipe (FIFO)	UNIX domain socket
Asyn/Syn	Asynchronous	Synchronous (for unidirectial pipe)	Synchronous
Size	Data size limit to the physical memory	Queue size is at 16 pages (4096 bytes per page). No limit on data size as long as the data is consumed fast enough	Extremely high throughput. Limit to the speed of the storage device.
Communication	Multiple processes can access at the same time but synchronization management needed	Unidirectional communication for a single pipe	Bi-directional communication
Access	Random access	Read-write in a linear fashion	Read-write in a linear fashion
Memory Manage	Manual memory management	Auto memory mamangement	Auto memory management

위에 나열된 세 가지 기술에서 Shared Memory는 기본적으로 모든 것을 관리해야 하기 때문에 가장 낮은 수준의 접근 방식인 반면, UNIX Domain Socket은 프로세스 간에 적절한 통신 채널을 쉽게 설정할 수 있습니다. 하지만 편리함에는 항상 비용이 따르며, 반면에 공유 메모리는 모든 목적에 맞게 데이터 전송 bit을 최적화할 수 있는 유연성을 제공합니다. 이를 통해 메모리 용량을 최대한 활용하고 여러 프로세스의 동시(concurrent) 액세스를 관리할 수 있습니다. 따라서 목적과 리소스에 따라 최선의 방법을 사용하시기 바랍니다.

이제 간단한 예제를 통해 각 방법에 대해 자세히 살펴보겠습니다. (참고: 여기에 사용된 예제는 Linux 플랫폼만 대상으로 하며 일부 수정은 다른 플랫폼에서 실행해야 함).

2.1 Shared Memory(이하 공유 메모리)

공유 메모리는 사용 가능한 IPC 기술 중 가장 빠릅니다. 메모리가 메모리 영역을 공유하는 프로세스의 주소 공간에 매핑되면 프로세스 간에 데이터를 전달할 때 커널이 관여하지 않습니다. 그러나 공유 메모리 영역에서 데이터를 저장하고 가져올 때 프로세스 간 일부 형태의 동기화(e.g. mutexes, condition variables, read-write locks, record locks, semaphores)가 필요합니다. 단순화를 위해 예제에서는 동기화 기술을 사용하지 않았습니다.

다음 프로그램은 부모 프로세스와 자식 프로세스 사이를 통과하는 카운터를 반복적으로 증가시키는 프로그램이며, 하단에 일부 설명을 첨부하였으니 참고하시기 바랍니다.

/**
 * Sample code for sharing memory between processes
 * Two processes will iteratively increase a counter which values stored in a shared memory
 * 
 */


#include <stdio.h>
#include <unistd.h> // for fork()

#include <sys/mman.h> // for shared memory created
#include <sys/stat.h> // for mode constants
#include <fcntl.h> // for O_* constant

#define SHARED_OBJ_NAME "/somename"

// shared data struct
struct message
{
    int pid;
    int counter;
};

bool write_message(int pid, int value)
{
    int shmFd = shm_open(SHARED_OBJ_NAME, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
    ftruncate(shmFd, sizeof(message));
    message *msg_ptr = (message*)mmap(NULL, sizeof(message), PROT_READ | PROT_WRITE, MAP_SHARED, shmFd, 0);
    
    printf("Process %d: Increase the counter.\n", pid);
    msg_ptr->pid = pid;
    msg_ptr->counter = value;

    munmap(msg_ptr, sizeof(message));

    // remember to close to not hit an error of
    // opening too many files
    close(shmFd);

    return true;
}

bool read_message(int curr_pid, int &curr_value)
{
    int shmFd = shm_open(SHARED_OBJ_NAME, O_RDWR, S_IRUSR | S_IWUSR);
    ftruncate(shmFd, sizeof(message));
    message *msg_ptr = (message*)mmap(NULL, sizeof(message), PROT_READ | PROT_WRITE, MAP_SHARED, shmFd, 0);

    if (msg_ptr->pid == curr_pid)
    {
        printf("Process %d: No new msg available.\n", curr_pid);
        return false;
    }
    else
    {
        printf("Process %d: Receive %d from PID %d.\n", curr_pid, msg_ptr->counter, msg_ptr->pid);
        curr_value = msg_ptr->counter;
        munmap(msg_ptr, sizeof(message));
    }

    close(shmFd);

    return true;
}

int main(int argc, char **argv)
{
    printf("Init the initial value.\n");
    write_message(-1, 0);

    // create a child process by calling folk, 
    // it returns a non-zero pid for parent process and 0 for child process created
    pid_t pid = fork();

    //--- PARENT PROCESS
    if (pid != 0)
    {
        for (int i = 0; i < 5; i++)
        {
            int value;
            // only write message if reading sucessfully
            if (read_message(pid, value))
                write_message(pid, ++value);
            sleep(0.1);
        }
    }

    //--- CHILD PROCESS
    else
    {
        for (int j = 0; j < 5; j++)
        {
            int value;
            if (read_message(pid, value))
                write_message(pid, ++value);
            sleep(0.1);
        }
    }

    printf("=========== End of process %d\n", pid);
    // shm_unlink(SHARED_OBJ_NAME);

    return 0;
}

• fork()는 상위 프로세스를 하나 이상의 하위 프로세스로 "복제"하는 데 사용되며, 자식 프로세스 pid는 0으로 시작하기에 PID를 사용하여 구분합니다.
• 'shm_open'은 파일 디스크립터(OS 커널에 저장됨)의 형태로 공유 메모리 객체를 생성하는 데 사용되며, 이후 mmap을 사용하여 프로세스의 주소 공간에 매핑합니다. 따라서 이는 실제 공유 메모리 영역을 가리키는 포인터의 주소를 반환합니다.

위의 코드는 다음을 사용하여 빌드 gcc하고 실행할 수 있습니다.

gcc shared_memory.cpp -I/usr/local/include/ -L/usr/local/lib -lrt -o shared_mem
./shared_mem

프로그램의 출력:

Set the initial value.
Process -1: Increase the counter.
Process 26851: Receive 0 from PID -1.
Process 26851: Increase the counter.
Process 26851: No new msg received
Process 0: Receive 1 from PID 26851.
Process 0: Increase the counter.
Process 26851: No new msg received
Process 26851: Receive 2 from PID 0.
Process 0: No new msg received
Process 26851: Increase the counter.
Process 0: Receive 3 from PID 26851.
Process 0: Increase the counter.
Process 26851: Receive 4 from PID 0.
Process 26851: Increase the counter.
Process 0: Receive 5 from PID 26851.
Process 0: Increase the counter.
=========== End of process 26851
Process 0: No new msg received
=========== End of process 0

예제에서 부모와 자식 사이에 메시지가 전달되는 것을 볼 수 있습니다. 프로세스는 값을 증가시켜 다른 프로세스에 전달하고 다른 프로세스가 값을 증가시킬 때까지 기다립니다. 이러한 과정은 모두 공유 메모리 공간에서 발생합니다.

처음에 공유 메모리 크기가 0이라는 점은 주목할 가치가 있습니다. 'ftruncate'는 파일 디스크립터를 특정 길이로 자르는 데 사용됩니다. 실제 데이터 크기보다 큰 경우 추가 데이터는 0으로 초기화됩니다.

공유 메모리 영역에 대한 포인터를 전달하려는 경우가 자주 있습니다. 그러나 처음에 언급했듯이 프로세스는 별도의 메모리 영역을 가지고 있으므로 프로세스 간에 포인터를 전달하는 것은 불가능합니다. 이 프로세스의 메모리 주소는 다른 프로세스에서는 유효하지 않습니다. 공유 메모리 영역에 바이트 배열을 전달하려면 mmap를 사용하여 원하는 크기로 영역을 매핑한 다음, mmap에서 반환된 포인터 주소에 크기를 memcpy에 써야 합니다. 공유하려는 구조체에 different member types with a data array가 있을 경우 소켓을 통해 구조체를 전달할 때 단일 배열(i.e. a single memory region)로 결합/인코딩하여 전달해야 합니다. 그래야 다른 프로세스에서 읽을 때 공유 메모리 영역에 복사하고 동일한 순서로 디코딩할 수 있습니다.

2.2 Named pipe(FIFO)

Named pipe(FIFO)는 파이프와 유사하지만 파일 시스템에 이름이 있는 특수 파일입니다. 프로세스가 정보를 보내고 다른 프로세스가 정보를 받는 메시지 전달처럼 사용됩니다. 데이터는 높은 처리 속도로 파이프로 넣고 뺄 수 있습니다(FIFO). 여기서 큐가 한 번에 보유할 수 있는 최대 데이터 크기는 16 Pages 또는 65536 Bytes입니다.

/**
 * Example for using named pipe for communicating between processes
 * This demo is for a unidirectional named pipe which transfer data in one direction
 */

#include <unistd.h> // for fork()
#include <stdio.h> // for printf
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> // for O_* constant

// for print error message
#include <string.h>
#include <errno.h>

#define NAMED_PIPE "/var/lock/pipename"

// shared data struct
struct message
{
    int pid;
    int counter;
};


int main(int argc, char **argv)
{
    // create the named pipe (fifo) with permission
    int ret = mkfifo(NAMED_PIPE, 0666);
    if (ret < 0)
        printf("Error when creating FIFO. %s\n", strerror(errno));

    // create a child process by calling folk, 
    // it returns a non-zero pid for parent process and 0 for child process created
    pid_t pid = fork();

    //--- the parent process will write to the pipe only
    if (pid != 0)
    {
        int fd = open(NAMED_PIPE, O_WRONLY);
        for (int i = 0; i < 5; i++)
        {
            message msg;
            msg.pid = pid;
            msg.counter = i;
            printf("Process %d: Write %d.\n", pid, i);
            ret = write(fd, &msg, sizeof(msg));
            if (ret < 0)
                printf("Process %d: Error while writing message. %s\n", pid, strerror(errno));
            sleep(0.1);
        }
        close(fd);
    }

    //-- child process will read only
    else
    {
        
        int fd = open(NAMED_PIPE, O_RDONLY);
        for (int i = 0; i < 5; i++)
        {
            message msg;
            ret = read(fd, &msg, sizeof(msg));
            if (ret < 0)
                printf("Process %d: Error while reading message. %s\n", pid, strerror(errno));
            printf("Process %d: Received value %d from the parent process %d.\n", pid, msg.counter, msg.pid);
            sleep(0.1);
        }
        close(fd);
    }

    unlink(NAMED_PIPE);

    return 0;
}

예제를 빌드하고 실행합니다.

gcc named_pipe.cpp -I/usr/local/include/ -L/usr/local/lib -o named_pipe
./named_pipe

프로그램의 출력:

 

Process 17830: Write 0.
Process 17830: Write 1.
Process 17830: Write 2.
Process 0: Received value 0 from the parent process 17830.
Process 17830: Write 3.
Process 0: Received value 1 from the parent process 17830.
Process 17830: Write 4.
Process 0: Received value 2 from the parent process 17830.
Process 0: Received value 3 from the parent process 17830.
Process 0: Received value 4 from the parent process 17830.

2.3 UNIX Domain Socket

UNIX Domain Socket은 유용한 내장 기능이 많은 프로세스 간에 통신 채널을 설정할 수 있어 편리합니다. TCP/IP 인터넷 소켓으로 stream-oriented(TCP) 및 datagram-oriented(UDP) 프로토콜을 모두 지원합니다. blocking와 non-blocking중에서 선택할 수도 있습니다.

먼저 'socket'함수로 소켓을 만들 때 도메인 소켓으로 지정(AF_UNIX)해야 합니다. 생성된 후 함수를 사용하여 소켓을 고유한 파일 경로에 바인딩(bind)해야 합니다. 소켓이 고유한 IP 주소 및 포트 번호에 바인딩되는 인터넷 소켓(AF_INET)과 달리 UNIX Domain Socket은 파일 경로에 바인딩됩니다. 그러면 파일 시스템에 파일이 생성되고, 프로그램이 닫힌 후 파일이 더 이상 필요하지 않으면 수동으로 제거해야 합니다.

아래 예제에서는 클라이언트가 서버에 연결하여 'hello'하고 서버로부터 응답을 받습니다.

/**
 * Sample for UNIX domain socket
 * Two-way communication between process server and client:
 * 1) Client connect and say hello to server
 * 2) Server receive client message and display
 * 3) Server say hello back to client
 * 4) Client receive server message and display
 * 5) Done.
 */

#include <unistd.h> // for fork()
#include <stdio.h> // for printf
#include <stdlib.h> // for exit()
#include <sys/socket.h>
#include <sys/un.h> // socket in Unix

// for print error message
#include <string.h>
#include <errno.h>

#define SERVER_SOCK_PATH "unix_sock.server"
#define CLIENT_SOCK_PATH "unix_sock.client"
#define SERVER_MSG "HELLO FROM SERVER"
#define CLIENT_MSG "HELLO FROM CLIENT"


int main(int argc, char **argv)
{
    struct sockaddr_un server_addr;
    struct sockaddr_un client_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    memset(&client_addr, 0, sizeof(client_addr));
    int rc;
    // for simplicity, we will assign a fixed size for buffer of the message
    char buf[256];

    // create two processes of client and server
    pid_t pid = fork();


    //---------- SERVER PROCESS
    if (pid != 0)
    {
        // maximum number of client connections in queue
        int backlog = 10;

        /****************************************************/
        /* Open the server socket with the SOCK_STREAM type */
        /****************************************************/
        int server_sock = socket(AF_UNIX, SOCK_STREAM, 0);
        if (server_sock == -1)
        {
            printf("SERVER: Error when opening server socket.\n");
            exit(1);
        }

        /*************************************/
        /* Bind to an address on file system */
        /*************************************/
        // similar to other IPC methods, domain socket needs to bind to a file system
        // so that client know the address of the server to connect to
        server_addr.sun_family = AF_UNIX;
        strcpy(server_addr.sun_path, SERVER_SOCK_PATH);
        int len = sizeof(server_addr);

        // unlink the file before bind, unless it can't bind
        unlink(SERVER_SOCK_PATH);

        rc = bind(server_sock, (struct sockaddr *)&server_addr, len);
        if (rc == -1)
        {
            printf("SERVER: Server bind error: %s\n", strerror(errno));
            close(server_sock);
            exit(1);
        }

        /***************************************/
        /* Listen and accept client connection */
        /***************************************/
        // set the server in the "listen" mode and maximum pending connected clients in queue
        rc = listen(server_sock, backlog);
        if (rc == -1)
        {
            printf("SERVER: Listen error: %s\n", strerror(errno));
            close(server_sock);
            exit(1);
        }

        printf("SERVER: Socket listening...\n");
        int client_fd = accept(server_sock, (struct sockaddr *) &client_addr, (socklen_t*)&len);
        if (client_fd == -1)
        {
            printf("SERVER: Accept error: %s\n", strerror(errno));
            close(server_sock);
            close(client_fd);
            exit(1);
        }
        printf("SERVER: Connected to client at: %s\n", client_addr.sun_path);
        printf("SERVER: Wating for message...\n");

        /********************/
        /* Listen to client */
        /********************/
        memset(buf, 0, 256);
        int byte_recv = recv(client_fd, buf, sizeof(buf), 0);
        if (byte_recv == -1)
        {
            printf("SERVER: Error when receiving message: %s\n", strerror(errno));
            close(server_sock);
            close(client_fd);
            exit(1);
        }
        else
            printf("SERVER: Server received message: %s.\n", buf);

        /**********************/
        /* Response to client */
        /**********************/
        printf("SERVER: Respond to the client...\n");
        memset(buf, 0, 256);
        strcpy(buf, SERVER_MSG);
        rc = send(client_fd, buf, strlen(buf), 0);
        if (rc == -1)
        {
            printf("SERVER: Error when sending message to client.\n");
            close(server_sock);
            close(client_fd);
            exit(1);
        }
        printf("SERVER: Done!\n");

        close(server_sock);
        close(client_fd);
        remove(SERVER_SOCK_PATH);
    }

    //---------- CLIENT PROCESS
    else
    {
        /**************************************************/
        /* Open a client socket (same type as the server) */
        /**************************************************/
        int client_sock = socket(AF_UNIX, SOCK_STREAM, 0);
        if (client_sock == -1)
        {
            printf("CLIENT: Socket error: %s\n", strerror(errno));
            exit(1);
        }

        /********************************************/
        /* Bind client to an address on file system */
        /********************************************/
        // Note: this binding could be skip if we want only send data to server without receiving
        client_addr.sun_family = AF_UNIX;
        strcpy(client_addr.sun_path, CLIENT_SOCK_PATH);
        int len = sizeof(client_addr);

        unlink (CLIENT_SOCK_PATH);
        rc = bind(client_sock, (struct sockaddr *)&client_addr, len);
        if (rc == -1)
        {
            printf("CLIENT: Client binding error. %s\n", strerror(errno));
            close(client_sock);
            exit(1);
        }

        /****************************************/
        /* Set server address and connect to it */
        /****************************************/
        server_addr.sun_family = AF_UNIX;
        strcpy(server_addr.sun_path, SERVER_SOCK_PATH);
        rc = connect(client_sock, (struct sockaddr*)&server_addr, len);
        if(rc == -1)
        {
            printf("CLIENT: Connect error. %s\n", strerror(errno));
            close(client_sock);
            exit(1);
        }
        printf("CLIENT: Connected to server.\n");

        /**************************/
        /* Send message to server */
        /**************************/
        memset(buf, 0, sizeof(buf));
        strcpy(buf, CLIENT_MSG);
        rc = send(client_sock, buf, sizeof(buf), 0);
        if (rc == -1)
        {
            printf("CLIENT: Send error. %s\n", strerror(errno));
            close(client_sock);
            exit(1);
        }
        printf("CLIENT: Sent a message to server.\n");

        /**************************************/
        /* Listen to the response from server */
        /**************************************/
        printf("CLIENT: Wait for respond from server...\n");
        memset(buf, 0, sizeof(buf));
        rc = recv(client_sock, buf, sizeof(buf), 0);
        if (rc == -1)
        {
            printf("CLIENT: Recv Error. %s\n", strerror(errno));
            close(client_sock);
            exit(1);
        }
        else
            printf("CLIENT: Message received: %s\n", buf);

        printf("CLIENT: Done!\n");

        close(client_sock);
        remove(CLIENT_SOCK_PATH);
    }

    return 0;
}

예제를 빌드하고 실행합니다.

gcc unix_domain_socket.cpp -I/usr/local/include/ -L/usr/local/lib -o unix_domain_socket
./unix_domain_socket

프로그램의 출력:

SERVER: Socket listening...
SERVER: Connected to client at: unix_sock.client
SERVER: Wating for message...
CLIENT: Connected to server.
CLIENT: Sent a message to server.
CLIENT: Wait for respond from server...
SERVER: Server received message: HELLO FROM CLIENT.
SERVER: Respond to the client...
SERVER: Done!
CLIENT: Message received: HELLO FROM SERVER
CLIENT: Done!

참고

• Communication between processes in C/C++: https://biendltb.github.io/tech/inter-process-communication-ipc-in-cpp/