C에서 Linux와 공유 메모리를 사용하는 방법


117

내 프로젝트 중 하나에 약간의 문제가 있습니다.

나는 공유 메모리를 사용하는 잘 문서화 된 예를 찾으려고 노력 fork()했지만 성공하지 못했습니다.

: 기본적으로 시나리오는 사용자가 프로그램을 시작할 때, 나는 공유 메모리에 두 개의 값을 저장할 필요가있다 CURRENT_PATH A는 문자 *FILE_NAME 또한 문자 *를 .

명령 인수에 따라 새 프로세스가 시작 fork()되고 해당 프로세스 는 공유 메모리에 저장된 current_path 변수 를 읽고 수정해야 하며 file_name 변수는 읽기 전용입니다.

저에게 지시 할 수있는 예제 코드 (가능한 경우)가 포함 된 공유 메모리에 대한 좋은 튜토리얼이 있습니까?


1
프로세스 대신 스레드 사용을 고려할 수 있습니다. 그러면 더 이상 트릭없이 전체 메모리가 공유됩니다.
elomage 2014

아래 답변은 System V IPC 메커니즘에 대해 설명합니다 shmget(). 또한 (일명 )을 mmap()사용한 순수한 접근 방식 — POSIX에 의해 정의되지는 않았습니다. POSIX 및 공유 메모리 개체 관리 도 있습니다. [… 계속…]MAP_ANONMAP_ANONYMOUSMAP_ANONshm_open()shm_close()
Jonathan Leffler

[… continuation…] 이들은 System V IPC 공유 메모리와 동일한 이점을 가지고 있습니다. 공유 메모리 객체는이를 생성하는 프로세스의 수명을 넘어서 (일부 프로세스가 실행될 때까지 shm_unlink()) 지속될 수 mmap()있는 반면, 사용하는 메커니즘 은 파일이 필요하고 MAP_SHARED지속됩니다. 데이터 ( MAP_ANON지속성을 배제 함). 사양의 근거 섹션에 완전한 예가 shm_open()있습니다.
Jonathan Leffler

답변:


164

두 가지 접근 방식이 있습니다 : shmgetmmap. mmap더 현대적이고 유연하기 때문에 에 대해 이야기하겠습니다 .하지만 구식 도구를 사용하고 싶다면 man shmget( 또는이 튜토리얼 )을 살펴볼 수 있습니다 .

mmap()기능은 고도로 사용자 정의 가능한 매개 변수로 메모리 버퍼를 할당하여 액세스 및 권한을 제어하고 필요한 경우 파일 시스템 스토리지로 백업하는 데 사용할 수 있습니다.

다음 함수는 프로세스가 자식과 공유 할 수있는 메모리 내 버퍼를 만듭니다.

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>

void* create_shared_memory(size_t size) {
  // Our memory buffer will be readable and writable:
  int protection = PROT_READ | PROT_WRITE;

  // The buffer will be shared (meaning other processes can access it), but
  // anonymous (meaning third-party processes cannot obtain an address for it),
  // so only this process and its children will be able to use it:
  int visibility = MAP_SHARED | MAP_ANONYMOUS;

  // The remaining parameters to `mmap()` are not important for this use case,
  // but the manpage for `mmap` explains their purpose.
  return mmap(NULL, size, protection, visibility, -1, 0);
}

다음은 위에서 정의한 함수를 사용하여 버퍼를 할당하는 예제 프로그램입니다. 부모 프로세스는 메시지를 쓰고 분기 한 다음 자식이 버퍼를 수정할 때까지 기다립니다. 두 프로세스 모두 공유 메모리를 읽고 쓸 수 있습니다.

#include <string.h>
#include <unistd.h>

int main() {
  char parent_message[] = "hello";  // parent process will write this message
  char child_message[] = "goodbye"; // child process will then write this one

  void* shmem = create_shared_memory(128);

  memcpy(shmem, parent_message, sizeof(parent_message));

  int pid = fork();

  if (pid == 0) {
    printf("Child read: %s\n", shmem);
    memcpy(shmem, child_message, sizeof(child_message));
    printf("Child wrote: %s\n", shmem);

  } else {
    printf("Parent read: %s\n", shmem);
    sleep(1);
    printf("After 1s, parent read: %s\n", shmem);
  }
}

52
이것이 리눅스가 경험이없는 개발자들에게 매우 실망스러운 이유입니다. 매뉴얼 페이지에는 실제로 사용하는 방법이 설명되어 있지 않으며 샘플 코드도 없습니다. :(
bleepzter 2011-04-13

47
하하 무슨 말인지 알지만 사실 우리가 맨 페이지를 읽는 데 익숙하지 않기 때문입니다. 내가 그것들을 읽고 익숙해 졌을 때, 그것들은 특정 시연이있는 형편없는 튜토리얼보다 훨씬 더 유용 해졌습니다. 시험 중 맨 페이지 만 사용하여 운영 체제 과정에서 10/10을 받았던 것을 기억합니다.
slezica 2011

18
shmget정말 구식이고, 일부는 더 이상 사용되지 않는다고 말할 것입니다. 공유 메모리를 수행하는 방법 ... mmapand shm_open, 일반 파일 또는 간단히 MAP_ANONYMOUS.
R .. GitHub STOP HELPING ICE

4
@Mark @R 여러분이 맞습니다. 나중에 참조 할 수 있도록 답변에서 지적하겠습니다.
slezica 2011-04-14

4
글쎄,이 답변은 어떤 이유로 인기를 얻었으므로 읽을만한 가치가 있도록 결정했습니다. 4 년 밖에
걸리지 않았습니다

26

다음은 공유 메모리의 예입니다.

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

#define SHM_SIZE 1024  /* make it a 1K shared memory segment */

int main(int argc, char *argv[])
{
    key_t key;
    int shmid;
    char *data;
    int mode;

    if (argc > 2) {
        fprintf(stderr, "usage: shmdemo [data_to_write]\n");
        exit(1);
    }

    /* make the key: */
    if ((key = ftok("hello.txt", 'R')) == -1) /*Here the file must exist */ 
{
        perror("ftok");
        exit(1);
    }

    /*  create the segment: */
    if ((shmid = shmget(key, SHM_SIZE, 0644 | IPC_CREAT)) == -1) {
        perror("shmget");
        exit(1);
    }

    /* attach to the segment to get a pointer to it: */
    data = shmat(shmid, NULL, 0);
    if (data == (char *)(-1)) {
        perror("shmat");
        exit(1);
    }

    /* read or modify the segment, based on the command line: */
    if (argc == 2) {
        printf("writing to segment: \"%s\"\n", argv[1]);
        strncpy(data, argv[1], SHM_SIZE);
    } else
        printf("segment contains: \"%s\"\n", data);

    /* detach from the segment: */
    if (shmdt(data) == -1) {
        perror("shmdt");
        exit(1);
    }

    return 0;
}

단계 :

  1. ftok를 사용하여 경로 이름 및 프로젝트 식별자를 System V IPC 키로 변환

  2. 공유 메모리 세그먼트를 할당하는 shmget 사용

  3. shmat를 사용하여 shmid로 식별 된 공유 메모리 세그먼트를 호출 프로세스의 주소 공간에 연결합니다.

  4. 메모리 영역에서 작업을 수행하십시오.

  5. shmdt를 사용하여 분리


6
NULL을 사용하는 대신 0을 void *로 캐스팅하는 이유는 무엇입니까?
Clément Péau

그러나이 코드는 공유 메모리 삭제를 처리하지 않습니다. 프로그램 종료 후 ipcrm -m 0을 통해 수동으로 삭제해야합니다.
bumfo

12

이들은 공유 메모리 사용을위한 것입니다.

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

int shmid;
int shmkey = 12222;//u can choose it as your choice

int main()
{
  //now your main starting
  shmid = shmget(shmkey,1024,IPC_CREAT);
  // 1024 = your preferred size for share memory
  // IPC_CREAT  its a flag to create shared memory

  //now attach a memory to this share memory
  char *shmpointer = shmat(shmid,NULL);

  //do your work with the shared memory 
  //read -write will be done with the *shmppointer
  //after your work is done deattach the pointer

  shmdt(&shmpointer, NULL);

8

이 코드 샘플을 시도해보고 테스트했습니다. 소스 : http://www.makelinux.net/alp/035

#include <stdio.h> 
#include <sys/shm.h> 
#include <sys/stat.h> 

int main () 
{
  int segment_id; 
  char* shared_memory; 
  struct shmid_ds shmbuffer; 
  int segment_size; 
  const int shared_segment_size = 0x6400; 

  /* Allocate a shared memory segment.  */ 
  segment_id = shmget (IPC_PRIVATE, shared_segment_size, 
                 IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR); 
  /* Attach the shared memory segment.  */ 
  shared_memory = (char*) shmat (segment_id, 0, 0); 
  printf ("shared memory attached at address %p\n", shared_memory); 
  /* Determine the segment's size. */ 
  shmctl (segment_id, IPC_STAT, &shmbuffer); 
  segment_size  =               shmbuffer.shm_segsz; 
  printf ("segment size: %d\n", segment_size); 
  /* Write a string to the shared memory segment.  */ 
  sprintf (shared_memory, "Hello, world."); 
  /* Detach the shared memory segment.  */ 
  shmdt (shared_memory); 

  /* Reattach the shared memory segment, at a different address.  */ 
  shared_memory = (char*) shmat (segment_id, (void*) 0x5000000, 0); 
  printf ("shared memory reattached at address %p\n", shared_memory); 
  /* Print out the string from shared memory.  */ 
  printf ("%s\n", shared_memory); 
  /* Detach the shared memory segment.  */ 
  shmdt (shared_memory); 

  /* Deallocate the shared memory segment.  */ 
  shmctl (segment_id, IPC_RMID, 0); 

  return 0; 
} 

2
그것은 (사용하여 클라이언트가 공유 메모리 세그먼트에 액세스하는 방법을 보여줍니다 나는 생각하지 않는다 제외하고는이, 좋은 코드 shmgetshmat다른 프로세스에서) 종류의 공유 메모리의 요점 ... = (중입니다
étale - 코호 몰 로지

7

다음은 mmap 예입니다.

#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

/*
 * pvtmMmapAlloc - creates a memory mapped file area.  
 * The return value is a page-aligned memory value, or NULL if there is a failure.
 * Here's the list of arguments:
 * @mmapFileName - the name of the memory mapped file
 * @size - the size of the memory mapped file (should be a multiple of the system page for best performance)
 * @create - determines whether or not the area should be created.
 */
void* pvtmMmapAlloc (char * mmapFileName, size_t size, char create)  
{      
  void * retv = NULL;                                                                                              
  if (create)                                                                                         
  {                                                                                                   
    mode_t origMask = umask(0);                                                                       
    int mmapFd = open(mmapFileName, O_CREAT|O_RDWR, 00666);                                           
    umask(origMask);                                                                                  
    if (mmapFd < 0)                                                                                   
    {                                                                                                 
      perror("open mmapFd failed");                                                                   
      return NULL;                                                                                    
    }                                                                                                 
    if ((ftruncate(mmapFd, size) == 0))               
    {                                                                                                 
      int result = lseek(mmapFd, size - 1, SEEK_SET);               
      if (result == -1)                                                                               
      {                                                                                               
        perror("lseek mmapFd failed");                                                                
        close(mmapFd);                                                                                
        return NULL;                                                                                  
      }                                                                                               

      /* Something needs to be written at the end of the file to                                      
       * have the file actually have the new size.                                                    
       * Just writing an empty string at the current file position will do.                           
       * Note:                                                                                        
       *  - The current position in the file is at the end of the stretched                           
       *    file due to the call to lseek().  
              *  - The current position in the file is at the end of the stretched                    
       *    file due to the call to lseek().                                                          
       *  - An empty string is actually a single '\0' character, so a zero-byte                       
       *    will be written at the last byte of the file.                                             
       */                                                                                             
      result = write(mmapFd, "", 1);                                                                  
      if (result != 1)                                                                                
      {                                                                                               
        perror("write mmapFd failed");                                                                
        close(mmapFd);                                                                                
        return NULL;                                                                                  
      }                                                                                               
      retv  =  mmap(NULL, size,   
                  PROT_READ | PROT_WRITE, MAP_SHARED, mmapFd, 0);                                     

      if (retv == MAP_FAILED || retv == NULL)                                                         
      {                                                                                               
        perror("mmap");                                                                               
        close(mmapFd);                                                                                
        return NULL;                                                                                  
      }                                                                                               
    }                                                                                                 
  }                                                                                                   
  else                                                                                                
  {                                                                                                   
    int mmapFd = open(mmapFileName, O_RDWR, 00666);                                                   
    if (mmapFd < 0)                                                                                   
    {                                                                                                 
      return NULL;                                                                                    
    }                                                                                                 
    int result = lseek(mmapFd, 0, SEEK_END);                                                          
    if (result == -1)                                                                                 
    {                                                                                                 
      perror("lseek mmapFd failed");                  
      close(mmapFd);                                                                                  
      return NULL;                                                                                    
    }                                                                                                 
    if (result == 0)                                                                                  
    {                                                                                                 
      perror("The file has 0 bytes");                           
      close(mmapFd);                                                                                  
      return NULL;                                                                                    
    }                                                                                              
    retv  =  mmap(NULL, size,     
                PROT_READ | PROT_WRITE, MAP_SHARED, mmapFd, 0);                                       

    if (retv == MAP_FAILED || retv == NULL)                                                           
    {                                                                                                 
      perror("mmap");                                                                                 
      close(mmapFd);                                                                                  
      return NULL;                                                                                    
    }                                                                                                 

    close(mmapFd);                                                                                    

  }                                                                                                   
  return retv;                                                                                        
}                                                                                                     

open파일 I / O 오버 헤드를 추가합니다. shm_open대신 사용하십시오 .
osvein

1
@Spookbuster, shm_open의 일부 구현에서 open ()은 내부적으로 호출되므로 귀하의 평가에 동의하지 않습니다. 여기에 예가 있습니다. code.woboq.org/userspace/glibc/sysdeps/posix/shm_open.c.html
Leo

일부 shm_open () 구현은 내부적으로 open ()을 사용하지만 POSIX는 shm_open ()에 의해 생성 된 파일 설명자에 대한 요구 사항이 낮습니다. 예를 들어, shm_open () 파일 설명자에 대해 read () 및 write ()와 같은 I / O 함수를 지원하기 위해 구현이 필요하지 않으므로 특정 구현에서 open ()에 대해 만들 수없는 shm_open ()을 최적화 할 수 있습니다. mmap ()으로하려는 모든 작업이 있으면 shm_open ()을 사용해야합니다.
osvein

대부분의 Linux-glibc 설정은 tmpfs를 사용하여 shm_open ()을 지원함으로써 이러한 최적화를 수행합니다. 일반적으로 open ()을 통해 동일한 tmpfs에 액세스 할 수 있지만 경로를 알 수있는 이식 가능한 방법은 없습니다. shm_open ()이 최적화를 이식 가능한 방식으로 사용할 수 있습니다. POSIX는 shm_open ()이 open ()보다 더 나은 성능을 발휘할 수 있도록합니다. 모든 구현이 그 잠재력을 활용하는 것은 아니지만 open ()보다 성능이 나쁘지는 않습니다. 그러나 나는 open ()이 항상 오버 헤드를 추가한다는 내 주장이 너무 광범위하다는 데 동의합니다.
osvein
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.