3-4. 공유 메모리 (Shared Memory) 방식

1. 공유 메모리 방식의 이해

프로세스 간 통신(IPC, Inter-Process Communication)은 운영체제 내에서 실행되는 서로 다른 프로세스들이 데이터를 교환하고 자원을 공유하기 위한 중요한 메커니즘입니다. 여러 IPC 기법 중 공유 메모리 방식은 프로세스들이 동일한 메모리 영역에 접근하여 정보를 주고받는 방법을 제공합니다. 이는 데이터 교환의 속도가 매우 빠르다는 장점을 가지며, 대량의 데이터를 효율적으로 처리해야 하는 상황에서 특히 유용합니다. 공유 메모리 방식은 마치 여러 사람이 함께 사용할 수 있는 게시판이나 공용 책상과 같습니다. 각 프로세스는 이 공유된 공간에 데이터를 쓰고 읽음으로써 서로 소통할 수 있습니다.

2. 공유 메모리 방식의 원리

공유 메모리 방식의 핵심은 프로세스들이 서로의 메모리에 직접 접근할 수 있도록 하는 것입니다. 운영체제는 이러한 접근을 가능하게 하기 위해 특별한 메모리 영역을 할당하고, 각 프로세스가 이 영역에 맵핑될 수 있도록 합니다.

1) 메모리 할당 및 맵핑

공유 메모리를 사용하기 위해서는 먼저 공유 메모리 영역을 생성해야 합니다. 운영체제는 shmget() 시스템 콜을 통해 이 작업을 수행합니다. shmget()은 공유 메모리 식별자(shared memory identifier, shmid)를 반환하며, 이 식별자를 통해 공유 메모리 영역에 접근할 수 있습니다.

#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

• key: 공유 메모리 영역을 식별하는 고유한 키값.
• size: 공유 메모리 영역의 크기 (바이트).
• shmflg: 접근 권한 및 생성 플래그. IPC_CREAT 플래그를 사용하여 새로운 공유 메모리를 생성하거나, IPC_EXCL 플래그와 함께 사용하여 이미 존재하는 경우 오류를 발생시킬 수 있습니다.

다음으로, 프로세스는 shmat() 시스템 콜을 사용하여 공유 메모리 영역을 자신의 주소 공간에 맵핑합니다.

#include <sys/types.h>
#include <sys/shm.h>
#include <unistd.h>

void *shmat(int shmid, const void *shmaddr, int shmflg);

• shmid: shmget()이 반환한 공유 메모리 식별자.
• shmaddr: 공유 메모리 영역을 맵핑할 주소. NULL을 지정하면 운영체제가 적절한 주소를 선택합니다.
• shmflg: 맵핑 옵션 (예: SHM_RDONLY는 읽기 전용 맵핑).

이 과정을 통해 각 프로세스는 마치 자신의 메모리 공간처럼 공유 메모리 영역에 접근할 수 있게 됩니다.

2) 데이터 접근 및 동기화

각 프로세스가 공유 메모리에 접근할 수 있게 되면, 데이터를 읽고 쓸 수 있습니다. 하지만 여러 프로세스가 동시에 공유 메모리에 접근할 경우, 데이터의 일관성이 깨질 수 있습니다. 이러한 문제를 해결하기 위해 동기화 기법을 사용해야 합니다. 락(Lock)과 뮤텍스(Mutex), 세마포어(Semaphore) 등이 대표적인 동기화 기법입니다.

위 그림은 공유 메모리 아키텍처에서 프로세스들이 공유 메모리에 접근할 때, Mutex를 사용하여 데이터 일관성을 유지하는 과정을 보여줍니다.

• 프로세스 1, 2: 공유 메모리를 사용하는 두 개의 프로세스.
• 공유 메모리: 프로세스들이 데이터를 공유하는 메모리 영역.
• Mutex: 상호 배제를 위한 락. 한 번에 하나의 프로세스만 접근을 허용합니다.
• Lock/Unlock: Mutex를 획득하고 해제하는 과정.

3) 공유 메모리 해제

공유 메모리 사용이 완료되면, shmdt() 시스템 콜을 사용하여 프로세스 주소 공간에서 공유 메모리 맵핑을 해제해야 합니다.

#include <sys/types.h>
#include <sys/shm.h>

int shmdt(const void *shmaddr);

• shmaddr: shmat()이 반환한 공유 메모리 주소.

마지막으로, shmctl() 시스템 콜을 사용하여 공유 메모리 영역을 삭제합니다.

#include <sys/ipc.h>
#include <sys/shm.h>

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

• shmid: shmget()이 반환한 공유 메모리 식별자.
• cmd: 제어 명령. IPC_RMID는 공유 메모리 영역을 삭제하는 데 사용됩니다.
• buf: 제어 정보 (사용하지 않을 경우 NULL).

3. 공유 메모리 방식의 장단점

1) 장점

• 빠른 속도: 공유 메모리는 프로세스 간 데이터 교환 속도가 매우 빠릅니다. 프로세스들은 자신의 메모리 공간에 직접 접근하여 데이터를 읽고 쓸 수 있기 때문입니다. 이는 커널의 개입 없이 이루어지므로 오버헤드가 최소화됩니다.
• 단순한 구현: 메시지 전달 방식에 비해 상대적으로 구현이 간단합니다.
• 대용량 데이터 전송에 적합: 대량의 데이터를 빠르게 전송해야 하는 경우에 효율적입니다.

2) 단점

• 동기화 문제: 여러 프로세스가 공유 메모리에 동시에 접근할 경우, 데이터 일관성을 유지하기 위해 동기화 메커니즘을 사용해야 합니다. 동기화는 복잡성을 증가시키고, 잘못 구현될 경우 데드락(Deadlock)과 같은 문제를 발생시킬 수 있습니다.
• 보안 문제: 공유 메모리에 대한 접근 권한을 적절하게 관리하지 않으면, 허가되지 않은 프로세스가 데이터에 접근하여 보안 문제가 발생할 수 있습니다.
• 프로세스 간의 의존성: 공유 메모리를 사용하는 프로세스들은 서로의 존재를 알고 있어야 하며, 공유 메모리 영역의 크기나 구조에 대한 합의가 필요합니다.

4. 공유 메모리 방식의 사용 예시

1) 생산자-소비자 문제

생산자-소비자 문제는 공유 메모리 방식을 사용하여 해결하기에 적합한 대표적인 예시입니다. 생산자 프로세스는 공유 메모리에 데이터를 쓰고, 소비자 프로세스는 공유 메모리에서 데이터를 읽습니다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include <semaphore.h>
#include <fcntl.h>

#define SHM_SIZE 1024
#define SEM_MUTEX_NAME "/mutex_sem"
#define SEM_FULL_NAME "/full_sem"
#define SEM_EMPTY_NAME "/empty_sem"

// Producer process
int producer(int shmid, sem_t *mutex, sem_t *empty, sem_t *full) {
    char *shmaddr = (char *)shmat(shmid, NULL, 0);
    if (shmaddr == (char *)-1) {
        perror("shmat (producer)");
        exit(1);
    }

    for (int i = 0; i < 10; i++) {
        // Produce item
        char data[16];
        snprintf(data, sizeof(data), "Data %d", i);

        sem_wait(empty);
        sem_wait(mutex);

        // Write data to shared memory
        strcpy(shmaddr, data);
        printf("Producer wrote: %s\n", shmaddr);

        sem_post(mutex);
        sem_post(full);

        sleep(1); // Simulate production time
    }

    shmdt(shmaddr);
    return 0;
}

// Consumer process
int consumer(int shmid, sem_t *mutex, sem_t *empty, sem_t *full) {
    char *shmaddr = (char *)shmat(shmid, NULL, 0);
    if (shmaddr == (char *)-1) {
        perror("shmat (consumer)");
        exit(1);
    }

    for (int i = 0; i < 10; i++) {
        sem_wait(full);
        sem_wait(mutex);

        // Read data from shared memory
        printf("Consumer read: %s\n", shmaddr);

        sem_post(mutex);
        sem_post(empty);

        sleep(2); // Simulate consumption time
    }

    shmdt(shmaddr);
    return 0;
}

int main() {
    int shmid;
    key_t key = 1234;
    sem_t *mutex, *full, *empty;

    // Create shared memory
    shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid < 0) {
        perror("shmget");
        exit(1);
    }

    // Create semaphores
    mutex = sem_open(SEM_MUTEX_NAME, O_CREAT, 0666, 1);
    full = sem_open(SEM_FULL_NAME, O_CREAT, 0666, 0);
    empty = sem_open(SEM_EMPTY_NAME, O_CREAT, 0666, 1);

    if (mutex <mark class="highlight"> SEM_FAILED || full </mark> SEM_FAILED || empty == SEM_FAILED) {
        perror("sem_open");
        exit(1);
    }

    pid_t pid = fork();

    if (pid <mark class="highlight"> -1) {
        perror("fork");
        exit(1);
    } else if (pid </mark> 0) {
        // Child process (consumer)
        consumer(shmid, mutex, empty, full);
    } else {
        // Parent process (producer)
        producer(shmid, mutex, empty, full);
        wait(NULL); // Wait for the child process to finish
    }

    // Clean up
    if (shmdt((void *)shmat(shmid, NULL, 0)) <mark class="highlight"> -1) {
        perror("shmdt (cleanup)");
    }
    if (shmctl(shmid, IPC_RMID, NULL) </mark> -1) {
        perror("shmctl");
    }

    sem_close(mutex);
    sem_close(full);
    sem_close(empty);

    sem_unlink(SEM_MUTEX_NAME);
    sem_unlink(SEM_FULL_NAME);
    sem_unlink(SEM_EMPTY_NAME);

    return 0;
}

• SHM_SIZE: 공유 메모리 영역의 크기를 정의합니다.
• SEM_MUTEX_NAME, SEM_FULL_NAME, SEM_EMPTY_NAME: 세마포어 이름을 정의합니다.
• shmget() 함수로 공유 메모리를 생성합니다.
• shmat() 함수로 공유 메모리를 프로세스에 맵핑합니다.
• sem_open() 함수로 세마포어를 생성합니다. mutex는 상호 배제를 위해, empty는 생산자가 공유 메모리에 쓸 수 있는 공간의 유무를, full은 소비자가 공유 메모리에서 읽을 수 있는 데이터의 유무를 제어합니다.
• fork() 함수로 생산자 프로세스와 소비자 프로세스를 생성합니다.
• 생산자 프로세스는 데이터를 생성하여 공유 메모리에 쓰고, 소비자 프로세스는 공유 메모리에서 데이터를 읽습니다.
• sem_wait()과 sem_post() 함수를 사용하여 세마포어를 조작하며, 공유 메모리에 대한 접근을 동기화합니다.
• shmdt() 함수로 공유 메모리 맵핑을 해제하고, shmctl() 함수로 공유 메모리 영역을 삭제합니다.
• sem_close() 와 sem_unlink() 함수를 사용하여 세마포어를 닫고 삭제합니다.

위 그림은 공유 메모리 방식을 사용한 생산자-소비자 문제 해결 방식을 보여줍니다.

• 생산자: 데이터를 생성하고 공유 버퍼에 넣는 프로세스.
• 소비자: 공유 버퍼에서 데이터를 읽는 프로세스.
• 공유 버퍼: 생산자와 소비자가 데이터를 주고받는 공유 메모리 영역.
• Mutex: 공유 버퍼에 대한 접근을 제어하여 상호 배제를 보장합니다.
• Empty: 버퍼에 빈 공간이 있는지 확인하는 세마포어.
• Full: 버퍼에 데이터가 있는지 확인하는 세마포어.

2) 데이터베이스 시스템

데이터베이스 시스템은 여러 프로세스가 동시에 데이터베이스에 접근하여 데이터를 읽고 쓰는 작업을 수행합니다. 공유 메모리 방식은 이러한 환경에서 데이터 접근 속도를 향상시키기 위해 사용될 수 있습니다. 여러 프로세스가 공유 메모리에 접근하여 데이터를 공유하고, 락(Lock)과 트랜잭션 관리 기법을 사용하여 데이터의 일관성을 유지합니다.

3) 대규모 데이터 처리 시스템

대규모 데이터 처리 시스템에서 여러 프로세스가 데이터를 공유하고 처리해야 하는 경우가 많습니다. 공유 메모리 방식은 각 프로세스가 데이터를 메모리에 직접 접근하여 처리할 수 있도록 하여, 데이터 처리 속도를 향상시키고 효율적인 작업을 가능하게 합니다.

5. 주의사항과 트러블슈팅

1) 동기화 문제 해결

공유 메모리 방식을 사용할 때는 동기화 문제를 해결하는 것이 가장 중요합니다. 락(Lock), 뮤텍스(Mutex), 세마포어(Semaphore)와 같은 동기화 메커니즘을 적절히 사용하여 공유 메모리에 대한 접근을 제어해야 합니다. 동기화 메커니즘을 잘못 사용하면 데드락(Deadlock)과 같은 심각한 문제가 발생할 수 있습니다.

2) 메모리 누수 방지

공유 메모리를 사용한 후에는 반드시 맵핑을 해제하고, 공유 메모리 영역을 삭제해야 합니다. 그렇지 않으면 메모리 누수가 발생할 수 있습니다. shmdt() 및 shmctl() 시스템 콜을 사용하여 적절한 시점에 메모리를 해제하는 코드를 구현해야 합니다.

3) 권한 관리

공유 메모리에 대한 접근 권한을 적절하게 관리하여 보안 문제를 예방해야 합니다. shmget() 시스템 콜의 shmflg 인자를 사용하여 공유 메모리 영역의 접근 권한을 설정할 수 있습니다.

4) 오류 처리

공유 메모리 관련 시스템 콜은 다양한 오류를 발생시킬 수 있습니다. 예를 들어, 공유 메모리 영역 생성 실패, 맵핑 실패, 권한 오류 등이 있습니다. 이러한 오류를 적절하게 처리하기 위해 오류 처리 코드를 추가해야 합니다.

5) 디버깅

공유 메모리 관련 코드는 디버깅이 어려울 수 있습니다. 여러 프로세스가 동시에 동작하고, 동기화 문제로 인해 문제가 발생하는 경우가 많기 때문입니다. 디버깅 도구 및 기법을 사용하여 문제를 진단하고 해결해야 합니다.