Posso fare una memcpy copy-on-write in Linux?

Question

Ho un codice in cui copio spesso un grande blocco di memoria, spesso dopo aver apportato solo piccole modifiche.

Ho implementato un sistema che tiene traccia delle modifiche, ma ho pensato che sarebbe bello, se possibile, dire al sistema operativo di fare un 'copia-on-write' della memoria, e lasciare che si occupi solo di fare un copia di quelle parti che cambiano. Comunque mentre Linux fa il copy-on-write, per esempio quando fork() ing, non riesco a trovare un modo per controllarlo e farlo da solo.

Answer 1

Probabilmente la tua migliore possibilità è quella di mmap() i dati originali da archiviare, quindi mmap() lo stesso file utilizzando nuovamente MAP_PRIVATE.

Answer 2

Il meccanismo di copia su scrittura impiegato, ad es. by fork() è una funzionalità della MMU (Memory Management Unit), che gestisce il paging della memoria per il kernel. L'accesso alla MMU è un'operazione privilegiata, ovvero non può essere eseguita da un'applicazione dello spazio utente. Non sono a conoscenza di alcuna API copy-on-write esportata nello spazio utente.

(Poi di nuovo, io non sono esattamente un guru sulle API di Linux, in modo che altri potrebbero notare le chiamate alle API importanti che ho perso.)

Edit: Ed ecco, MSalters aumenta all'occasione. ;-)

Answer 3

A seconda di cosa esattamente si sta copiando, un persistent data structure potrebbe essere una soluzione per il tuo problema.

Answer 4

È più facile implementare la copia su scrittura in un linguaggio orientato agli oggetti, come C++. Ad esempio, la maggior parte delle classi contenitore in Qt sono copy-on-write.

Ma se lo si può fare anche in C, è solo un po 'più di lavoro. Quando si desidera assegnare i dati a un nuovo blocco di dati, non si esegue una copia, ma si copia semplicemente un puntatore in un intreccio di wrapper attorno ai dati. È necessario tenere traccia dei blocchi di dati dello stato dei dati. Se ora modifichi qualcosa nel tuo nuovo blocco dati, fai una copia "reale" e cambia lo stato. Ovviamente non è più possibile utilizzare gli operatori semplici come "=" per l'assegnazione, ma è necessario avere funzioni (in C++ si farebbe semplicemente un sovraccarico dell'operatore).

Un'implementazione più robusta dovrebbe utilizzare i contatori di riferimento invece di una semplice bandiera, lascio a voi.

Un esempio veloce e sporco: Se si dispone di un

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

è necessario implementare le funzioni di assegnare e getter/setter te stesso.

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

È necessario scrivere anche costruttori e distruttori. Consiglio vivamente C++ per questo.

Answer 5

Dovresti essere in grado di aprire la tua memoria tramite/proc/$ PID/mem e poi mmap() la parte interessante di esso con MAP_PRIVATE in qualche altro posto.

Answer 6

Ecco un esempio di lavoro:

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

Sono un po 'sicuri di se ho bisogno di abilitare la sezione commentata, per la sicurezza.