Tôi có thể thực hiện một memcpy copy-on-write trong Linux không?

Question

Tôi có một số mã mà tôi thường xuyên sao chép một khối bộ nhớ lớn, thường sau khi thực hiện những thay đổi rất nhỏ với nó.

Tôi đã triển khai một hệ thống theo dõi các thay đổi, nhưng tôi nghĩ rằng nó có thể tốt đẹp, nếu có thể nói với hệ điều hành để làm một 'copy-on-write' của bộ nhớ, và để cho nó đối phó với chỉ thực hiện một bản sao của những phần đó thay đổi. Tuy nhiên, trong khi Linux thực hiện copy-on-write, ví dụ khi fork() ing, tôi không thể tìm ra cách kiểm soát nó và tự làm nó.

Answer 1

Cơ hội tốt nhất của bạn có thể là mmap() dữ liệu gốc để lưu trữ, và sau đó mmap() cùng một tệp lần nữa bằng cách sử dụng MAP_PRIVATE.

Answer 2

Cơ chế sao chép ghi đè được sử dụng, ví dụ: by fork() là một tính năng của MMU (Memory Management Unit), xử lý phân trang bộ nhớ cho hạt nhân. Việc truy cập MMU là một hoạt động riêng, tức là không thể được thực hiện bởi một ứng dụng không gian người dùng. Tôi cũng không biết bất kỳ API sao chép trên ghi nào cũng được xuất sang không gian người dùng.

(Sau đó, một lần nữa, tôi không chính xác một guru trên API Linux, để những người khác có thể chỉ ra các cuộc gọi API có liên quan tôi đã bỏ qua.)

Edit: Và kìa, MSalters tăng lên đến dịp này. ;-)

Answer 3

Tùy thuộc vào chính xác bạn đang sao chép, persistent data structure có thể là giải pháp cho sự cố của bạn.

Answer 4

Dễ dàng hơn khi thực hiện sao chép-ghi-ghi trong ngôn ngữ hướng đối tượng, như C++. Ví dụ, hầu hết các lớp container trong Qt là copy-on-write.

Nhưng nếu khóa học bạn có thể làm điều đó trong C quá, nó chỉ là một số công việc nhiều hơn nữa. Khi bạn muốn gán dữ liệu của bạn cho một khối dữ liệu mới, bạn không làm một bản sao, thay vào đó bạn chỉ cần sao chép một con trỏ trong một trình bao bọc xung quanh dữ liệu của bạn. Bạn cần phải theo dõi trong các khối dữ liệu của bạn về trạng thái của dữ liệu. Nếu bây giờ bạn thay đổi thứ gì đó trong khối dữ liệu mới của mình, bạn tạo bản sao "thực" và thay đổi trạng thái. Dĩ nhiên, bạn không thể sử dụng các toán tử đơn giản như "=" để gán, thay vào đó cần phải có các hàm (Trong C++ bạn chỉ cần thực hiện quá tải toán tử).

Triển khai mạnh mẽ hơn nên sử dụng bộ đếm tham chiếu thay vì cờ đơn giản, tôi để nó tùy thuộc vào bạn.

Một ví dụ nhanh chóng và dơ bẩn: Nếu bạn có một

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

bạn phải thực hiện chức năng assign và getters/setters mình.

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

Bạn cũng cần phải viết các hàm tạo và hàm hủy. Tôi thực sự khuyên bạn nên c + + cho việc này.

Answer 5

Bạn sẽ có thể mở bộ nhớ của riêng mình qua/proc/$ PID/mem và sau đó mmap() phần thú vị của nó với MAP_PRIVATE đến một số địa điểm khác.

Answer 6

Dưới đây là một ví dụ làm việc:

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

Tôi là một chút không chắc chắn về việc liệu tôi cần phải kích hoạt phần nhận xét ra, vì sự an toàn.