Kann ich in Linux eine Kopie-auf-Schreib-Memcpy erstellen?

Question

Ich habe einen Code, wo ich häufig einen großen Speicherblock kopiere, oft nachdem ich nur sehr kleine Änderungen daran vorgenommen habe.

Ich habe ein System implementiert, das die Änderungen verfolgt, aber ich dachte, dass es nett sein könnte, wenn möglich, dem OS zu sagen, dass man den Speicher kopieren und nur mit einem machen soll Kopie jener Teile, die sich ändern. Aber während Linux schreibt, zum Beispiel beim fork(), kann ich keinen Weg finden, es zu kontrollieren und es selbst zu tun.

Answer 1

Ihre beste Chance ist wahrscheinlich, mmap() die ursprünglichen Daten in Datei und dann mmap() die gleiche Datei wieder mit MAP_PRIVATE.

Answer 2

Der Kopier-auf-Schreib-Mechanismus, der z. by fork() ist eine Funktion der MMU (Memory Management Unit), die den Speicher-Paging für den Kernel übernimmt. Der Zugriff auf die MMU ist eine privilegierte Operation, d. H. Kann nicht von einer Benutzerbereichsanwendung ausgeführt werden. Mir ist auch nicht bekannt, dass eine API zum Kopieren und Schreiben in den Benutzerbereich exportiert wurde.

(Dann wieder, ich bin nicht gerade ein Experte auf dem Linux-API, so dass andere könnte ich verpasst haben relevante API-Aufrufe hinweisen.)

Edit: Und siehe, steigt MSalters zum Anlass. ;-)

Answer 3

Je nachdem, was genau Sie kopieren, kann eine persistent data structure eine Lösung für Ihr Problem sein.

Answer 4

Es ist einfacher, Copy-on-Write in einer objektorientierten Sprache wie C++ zu implementieren. Zum Beispiel sind die meisten Containerklassen in Qt Copy-on-Write.

Aber natürlich können Sie das auch in C machen, es ist nur ein bisschen mehr Arbeit. Wenn Sie Ihre Daten einem neuen Datenblock zuweisen möchten, führen Sie keine Kopie durch, sondern kopieren einfach einen Zeiger in einen Wrapper um Ihre Daten. Sie müssen in Ihren Datensätzen den Status der Daten verfolgen. Wenn Sie nun etwas in Ihrem neuen Datenblock ändern, erstellen Sie eine "echte" Kopie und ändern den Status. Sie können natürlich nicht mehr die einfachen Operatoren wie "=" für die Zuweisung verwenden, sondern müssen Funktionen haben (In C++ würden Sie nur den Operator überladen).

Eine robustere Implementierung sollte Referenzzähler anstelle einer einfachen Flagge verwenden, ich überlasse es Ihnen.

A quick and dirty Beispiel: Wenn Sie eine

struct big { 
//lots of data 
    int data[BIG_NUMBER]; 
} 

haben Sie assign Funktionen und Getter/Setter selbst implementieren müssen.

// assume you want to implent cow for a struct big of some kind 
// now instead of 
struct big a, b; 
a = b; 
a.data[12345] = 6789; 

// you need to use 
struct cow_big a,b; 
assign(&a, b); //only pointers get copied 
set_some_data(a, 12345, 6789); // now the stuff gets really copied 


//the basic implementation could look like 
struct cow_big { 
    struct big *data; 
    int needs_copy; 
} 

// shallow copy, only sets a pointer. 
void assign(struct cow_big* dst, struct cow_big src) { 
    dst->data = src.data; 
    dst->needs_copy = true; 
} 

// change some data in struct big. if it hasn't made a deep copy yet, do it here. 
void set_some_data(struct cow_big* dst, int index, int data } { 
    if (dst->needs_copy) { 
     struct big* src = dst->data; 
     dst->data = malloc(sizeof(big)); 
     *(dst->data) = src->data; // now here is the deep copy 
     dst->needs_copy = false; 
    } 
    dst->data[index] = data; 
} 

Sie müssen auch Konstruktoren und Destruktoren schreiben. Ich empfehle wirklich C++ dafür.

Answer 5

Sie sollten in der Lage sein, Ihren eigenen Speicher über/proc/$ PID/mem zu öffnen und dann den interessanten Teil davon mit MAP_PRIVATE an einen anderen Ort zu mappen.

Answer 6

Hier ist ein funktionierendes Beispiel:

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

#define SIZE 4096 

int main(void) { 
    int fd = shm_open("/tmpmem", O_RDWR | O_CREAT, 0666); 
    int r = ftruncate(fd, SIZE); 
    printf("fd: %i, r: %i\n", fd, r); 
    char *buf = mmap(NULL, SIZE, PROT_READ | PROT_WRITE, 
     MAP_SHARED, fd, 0); 
    printf("debug 0\n"); 
    buf[SIZE - 2] = 41; 
    buf[SIZE - 1] = 42; 
    printf("debug 1\n"); 

    // don't know why this is needed, or working 
    //r = mmap(buf, SIZE, PROT_READ | PROT_WRITE, 
    // MAP_FIXED, fd, 0); 
    //printf("r: %i\n", r); 

    char *buf2 = mmap(NULL, SIZE, PROT_READ | PROT_WRITE, 
    MAP_PRIVATE, fd, 0); 
    printf("buf2: %i\n", buf2); 
    buf2[SIZE - 1] = 43; 
    buf[SIZE - 2] = 40; 
    printf("buf[-2]: %i, buf[-1]: %i, buf2[-2]: %i, buf2[-1]: %i\n", 
     buf[SIZE - 2], 
     buf[SIZE - 1], 
     buf2[SIZE - 2], 
     buf2[SIZE - 1]); 

    unlink(fd); 
    return EXIT_SUCCESS; 
} 

Ich bin ein wenig unsicher, ob ich brauche den auf Kommentar Abschnitt, für Sicherheit zu ermöglichen.