Czy mogę zrobić memcpy kopiowania przy pisaniu w systemie Linux?

Question

Mam pewien kod, w którym często kopiuję duży blok pamięci, często po wprowadzeniu do niego bardzo niewielkich zmian.

Wdrożyłem system, który śledzi zmiany, ale pomyślałem, że może być miło, jeśli to możliwe, powiedzieć systemowi operacyjnemu, aby wykonał "kopię na piśmie" pamięci, i pozwól sobie poradzić tylko z robieniem kopia tych części, które się zmieniają. Jednak podczas gdy Linux robi kopiowanie przy zapisie, na przykład przy użyciu fork(), nie mogę znaleźć sposobu na kontrolowanie go i robienie tego samemu.

Answer 1

Twoja najlepsza szansa to prawdopodobnie mmap() oryginalnych danych do pliku, a następnie mmap() ten sam plik ponownie przy użyciu MAP_PRIVATE.

Answer 2

Mechanizm kopiowania przy zapisie, np. przez fork() jest funkcją MMU (Memory Management Unit), która obsługuje stronicowanie pamięci dla jądra. Dostęp do MMU jest operacją uprzywilejowaną, tj. Nie może być wykonana przez aplikację obszaru użytkownika. Nie jestem również świadomy, że API "kopiuj na piśmie" eksportował do przestrzeni użytkownika.

(Potem znowu, nie jestem dokładnie guru na API Linux, więc inni mogą wskazać odpowiednich wywołań API tęskniłem.)

Edit: A oto MSalters wzrasta do okazji. ;-)

Answer 3

W zależności od tego, co dokładnie kopiujesz, persistent data structure może być rozwiązaniem Twojego problemu.

Answer 4

Łatwiej jest wdrożyć metodę kopiowania przy zapisie w języku obiektowym, takim jak C++. Na przykład większość klas kontenera w Qt to copy-on-write.

Ale jeśli oczywiście możesz to zrobić w C, to tylko trochę więcej pracy. Kiedy chcesz przypisać dane do nowego bloku danych, nie wykonujesz kopii, zamiast tego po prostu kopiujesz wskaźnik w obrysie otaczającym twoje dane. Musisz śledzić w swoich blokach danych status danych. Jeśli teraz zmienisz coś w swoim nowym bloku danych, zrobisz "prawdziwą" kopię i zmienisz status. Oczywiście nie można już używać prostych operatorów takich jak "=" do przypisania, zamiast tego trzeba mieć funkcje (w C++ wystarczy przeciążenie operatora).

Bardziej niezawodna implementacja powinna wykorzystywać liczniki odwołań zamiast prostej flagi, pozostawiam to Tobie.

szybkie i brudne przykład: Jeśli masz

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

trzeba wdrożyć przypisać funkcje i pobierające/ustawiające się.

// 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; 
} 

Musisz napisać konstruktorów i destruktorów, jak również. Naprawdę polecam C++ do tego.

Answer 5

Powinieneś być w stanie otworzyć własną pamięć poprzez/proc/$ PID/mem, a następnie mmap() interesującą jej część z MAP_PRIVATE w innym miejscu.

Answer 6

Oto przykład praca:

#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; 
} 

jestem trochę niepewny, czy muszę włączyć wykomentowane sekcji, dla bezpieczeństwa.