วิธีใช้หน่วยความจำร่วมกับ Linux ในภาษา C


117

ฉันมีปัญหาเล็กน้อยกับหนึ่งในโครงการของฉัน

ฉันพยายามค้นหาตัวอย่างที่มีการบันทึกไว้เป็นอย่างดีเกี่ยวกับการใช้หน่วยความจำที่ใช้ร่วมกันfork()แต่ไม่ประสบความสำเร็จ

โดยทั่วไปสถานการณ์คือเมื่อผู้ใช้เริ่มโปรแกรมฉันจำเป็นต้องเก็บค่าสองค่าในหน่วยความจำที่ใช้ร่วมกัน: current_pathซึ่งเป็นถ่าน *และfile_nameซึ่งเป็นchar *ด้วย

ขึ้นอยู่กับอาร์กิวเมนต์ของคำสั่งกระบวนการใหม่จะเริ่มต้นด้วยfork()และกระบวนการนั้นจำเป็นต้องอ่านและแก้ไขตัวแปรcurrent_path ที่จัดเก็บในหน่วยความจำแบบแบ่งใช้ในขณะที่ตัวแปรfile_nameอ่านได้อย่างเดียว

มีคำแนะนำที่ดีเกี่ยวกับหน่วยความจำที่ใช้ร่วมกันพร้อมรหัสตัวอย่าง (ถ้าเป็นไปได้) ที่คุณสามารถแนะนำฉันได้ไหม


1
คุณอาจพิจารณาใช้เธรดแทนกระบวนการ จากนั้นความทรงจำทั้งหมดจะถูกแบ่งปันโดยไม่มีเทคนิคใด ๆ เพิ่มเติม
elomage

คำตอบด้านล่างนี้จะกล่าวถึงกลไก System V IPC shmget()และอื่น ๆ และmmap()แนวทางที่บริสุทธิ์ด้วยMAP_ANON(aka MAP_ANONYMOUS) - แม้ว่าMAP_ANONPOSIX จะไม่ได้กำหนดไว้ก็ตาม นอกจากนี้ยังมี POSIX shm_open()และshm_close()สำหรับการจัดการอ็อบเจ็กต์หน่วยความจำแบบแบ่งใช้ […ต่อ…]
Jonathan Leffler

[…ความต่อเนื่อง…] สิ่งเหล่านี้มีข้อได้เปรียบเช่นเดียวกับที่หน่วยความจำแบบแบ่งใช้ System V IPC มี - อ็อบเจ็กต์หน่วยความจำแบบแบ่งใช้สามารถคงอยู่ได้ตลอดอายุการใช้งานของกระบวนการที่สร้างขึ้น (จนกว่ากระบวนการบางอย่างจะดำเนินการshm_unlink()) ในขณะที่กลไกที่ใช้mmap()ต้องใช้ไฟล์และMAP_SHAREDเพื่อคงอยู่ ข้อมูล (และMAP_ANONป้องกันการคงอยู่) มีตัวอย่างที่สมบูรณ์ในส่วนเหตุผลของข้อกำหนดของshm_open().
Jonathan Leffler

คำตอบ:


164

มีสองวิธี: shmgetและmmap. ฉันจะพูดถึง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
นี่คือเหตุผลว่าทำไม Linux จึงน่าหงุดหงิดสำหรับนักพัฒนาที่ไม่มีประสบการณ์ หน้าคนไม่ได้อธิบายวิธีการใช้งานจริงและไม่มีโค้ดตัวอย่าง :(
bleepzter

47
ฮ่าฮ่าฉันรู้ว่าคุณหมายถึงอะไร แต่จริงๆแล้วมันเป็นเพราะเราไม่คุ้นเคยกับการอ่าน manpages เมื่อฉันเรียนรู้ที่จะอ่านและคุ้นเคยกับพวกเขาพวกเขาก็มีประโยชน์มากกว่าแบบฝึกหัดที่มีหมัดที่มีการสาธิตเฉพาะ ฉันจำได้ว่าฉันได้คะแนน 10/10 ในหลักสูตรระบบปฏิบัติการของฉันโดยไม่ใช้อะไรเลยนอกจากจัดการเพื่ออ้างอิงในระหว่างการสอบ
slezica

18
shmgetเป็นเชยจริงๆและบางคนก็บอกเลิกวิธีการทำหน่วยความจำร่วม ... ดีกว่าการใช้mmapและไฟล์ธรรมดาหรือเพียงshm_open MAP_ANONYMOUS
R .. GitHub STOP HELPING ICE

4
@Mark @R พวกคุณพูดถูกฉันจะชี้ให้เห็นในคำตอบสำหรับการอ้างอิงในอนาคต
slezica

4
คำตอบนี้ได้รับความนิยมด้วยเหตุผลบางประการดังนั้นฉันจึงตัดสินใจที่จะทำให้คุ้มค่ากับการอ่าน ใช้เวลาเพียง 4 ปี
slezica

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
ทำไมคุณถึงทำให้ 0 เป็นโมฆะ * แทนที่จะใช้ NULL?
ClémentPé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
นี่เป็นรหัสที่ดียกเว้นฉันไม่คิดว่ามันแสดงวิธีการเข้าถึงเซ็กเมนต์หน่วยความจำที่ใช้ร่วมกันโดยไคลเอนต์ (โดยใช้shmgetและshmatจากกระบวนการอื่น) ซึ่งเป็นจุดรวมของหน่วยความจำที่ใช้ร่วมกัน ... = (
étale-cohomology

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 เปิด () ถูกเรียกภายใต้ฝาครอบดังนั้นฉันจะไม่เห็นด้วยกับการประเมินของคุณ นี่คือตัวอย่างcode.woboq.org/userspace/glibc/sysdeps/posix/shm_open.c.html
Leo

ในขณะที่การใช้งาน shm_open () บางตัวใช้ open () ภายใต้ประทุน POSIX มีข้อกำหนดที่ต่ำกว่าสำหรับตัวอธิบายไฟล์ที่สร้างโดย shm_open () ตัวอย่างเช่นการใช้งานไม่จำเป็นต้องรองรับฟังก์ชัน I / O เช่น read () และ write () สำหรับ shm_open () file descriptors ทำให้การใช้งานบางอย่างสามารถทำการปรับแต่งให้เหมาะสมสำหรับ shm_open () ที่ไม่สามารถทำเพื่อ open () ได้ หากสิ่งที่คุณจะทำคือ mmap () คุณควรใช้ shm_open ()
osvein

การตั้งค่า Linux-glibc ส่วนใหญ่ทำการเพิ่มประสิทธิภาพโดยใช้ tmpfs เพื่อสำรอง shm_open () ในขณะที่โดยปกติ tmpfs เดียวกันสามารถเข้าถึงได้ผ่าน open () แต่ไม่มีวิธีพกพาที่จะทราบเส้นทางของมัน shm_open () ให้คุณใช้การเพิ่มประสิทธิภาพนั้นในลักษณะพกพา POSIX ให้ shm_open () มีศักยภาพในการทำงานได้ดีกว่า open () การใช้งานบางอย่างไม่ได้ใช้ประโยชน์จากศักยภาพดังกล่าว แต่จะไม่แย่ไปกว่า open () แต่ฉันยอมรับว่าการอ้างว่า open () มักจะเพิ่มค่าโสหุ้ยนั้นกว้างเกินไป
osvein
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.