mapeo de memoria compartida de procesos

mapa de almacenamiento compartido

La E/S asignada por almacenamiento asigna un archivo de disco de Word a un búfer en el espacio de almacenamiento

Entonces, al recuperar datos del búfer, equivale a leer los bytes correspondientes en el archivo. Por analogía, si los datos se almacenan en el búfer, el número correspondiente de bytes se escribirá automáticamente en el archivo. De esta manera, la dirección (puntero) se puede utilizar para completar la operación de E/S cuando no sea adecuada para las funciones de lectura y escritura.

La memoria compartida es posiblemente la forma más útil de comunicación entre procesos y la forma más rápida de PC, porque los procesos pueden leer y escribir en la memoria directamente sin copiar datos.

 función de mapa de almacenamiento

Función: un archivo u otros objetos se asignan a la memoria
función mmap void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); addr:
        especifica la dirección inicial de la asignación, generalmente configurada a NULL, especificado por la
        longitud del sistema: la longitud del archivo asignado a la memoria
        prot: el método de protección del área asignada
        banderas: las características del área asignada fd: el descriptor de archivo devuelto por open, que representa el         desplazamiento
        del archivo que se asignará
: el desplazamiento al principio del archivo. Debe ser un múltiplo entero de 4k, normalmente 0, lo que significa mapeo desde el principio del archivo.

función mapamundi

Función: liberar el área de mapeo de memoria
Parámetros: addr: la primera dirección del área de mapeo creada usando la función mmap
           longitud: el tamaño del archivo del área de mapeo
Valor de retorno: éxito: 0
                falla: -1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>

int main(void){
    int fd = -1; 
    int ret = -1; 
    void *addr = NULL;

    fd = open("txt",O_RDWR);
    if(-1 == fd){
        perror("open");
        return 1;
    }   

    addr = mmap(NULL,1024,PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 
    if(addr == MAP_FAILED){
        perror("mmap");
        return 1;
    }   

    printf("ok.......");

    close(fd);

    memcpy(addr, "1234567890",10);

    munmap(addr,1024);

    return 0;
}

Los procesos padre e hijo se comunican mediante un mapa de memoria.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>

int main(void){
    int fd = -1;
    int ret = -1;
    pid_t pid = -1;
    void *addr = NULL;

    fd = open("txt",O_RDWR);
    if(-1 == fd){
        perror("open");
        return 1;
    }

    addr = mmap(NULL,1024,PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(addr == MAP_FAILED){
        perror("mmap");
        return 1;
    }

    printf("ok.......");

    close(fd);

    pid = fork();
    if(-1 == pid){
        perror("fork");
        return 1;
    }

    //child process
    if(0 == pid){
        memcpy(addr,"ABCDEGHJIL",10);
    }else{
        wait(NULL);
        //parent process
        printf("addr:%s\n",(char*)addr);
    }

    munmap(addr,1024);

    return 0;
}

ok... ok... dirección: ABCDEGHJILaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaad

El mapeo anónimo logra la comunicación entre padres e hijos 

        Al usarlo, descubrimos que es muy conveniente completar operaciones de lectura y escritura de archivos en el área de mapeo del apetito, y la comunicación entre los procesos padre e hijo también es relativamente fácil. Pero la desventaja es que cada vez que crea un área de mapeo, debe confiar en un archivo para lograrlo.

        Por lo general, para crear un área de mapeo, es necesario abrir un archivo temporal y luego desvincularlo y cerrarlo después de la creación, lo cual es problemático. En su lugar, se puede utilizar directamente un mapa anónimo.

        De hecho, el sistema Linux nos proporciona un método para crear un área de mapeo anónima, que puede crear un área de mapeo sin depender de un archivo. También debe especificarse con la ayuda de los indicadores de parámetros de banderas.

Utilice MAP_ANONYMOUS (o MAP_ANON)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <unistd.h>

int main(void){
    int ret = -1; 
    pid_t pid = -1; 
    void *addr = NULL;
    
    //创建匿名映射
    addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); 
    if(MAP_FAILED == addr){
        perror("mmap");
        return 1;
    }   
    
    //创建进程
    pid = fork();
    if(-1 == pid){
        perror("fork");
        munmap(addr,4096);
        return 1;
    }   

    //父子进程通信
    if(0 == pid){
        //子进程写
        memcpy(addr, "1234567890",10);
    }   
    else{
        //父进程读
        wait(NULL);
        printf("parent process %s\n",(char*)addr);
    }   

    munmap(addr,4096);
    return 0;
}

Resultado de salida: 

proceso padre 1234567890