copy-on-write

I used this script (see code at the end) to assess whether a global object is shared or copied when the parent process is forked. Briefly, the script creates a global data object, and the child processes iterate over data . The script also monitors the memory usage to assess whether the object was copied in the child processes. Here are the results: data = np.ones((N,N)) . Operation in the child process: data.sum() . Result: data is shared (no copy) data = list(range(pow(10, 8))) . Operation in the child process: sum(data) . Result: data is copied . data = list(range(pow(10, 8))) . Operation

I am implementing cp(file copy) command using mmap(). For that I mapped the source file in MAP_PRIVATE (As I just want to read)mode and destination file in MAP_SHARED mode(As I have to writeback the changed content of destination file). While doing this I have observed performance penalty due to lots of minor page faults that occurs due to 2 reason. 1) Zero fill on demand while calling mmap(MAP_PRIVATE) for source file. 2) Copy on write while calling mmap(MAP_SHARED) for destination file. Is there any way to disable Zero-fill-on-demand and Copy-on-write ? Thanks, Harish There is MMAP_POPULATE

I just saw this nice copy-on-write pointer implementation. It looks pretty generic and useful, so my question is: Is such a class contained in any of the C++ toolkits (boost, loki, etc.)? If not, I'd really like to know why because it is a really useful idiom and apparently a generic implementation seems doable (like the one I linked to). There was a lot of debate over the possibility, and at least one suggested version of what eventually came out as auto_ptr was for a reference counted COW pointer. Unfortunately, the time for COW has mostly passed. Making a COW pointer (or COW-whatever)

Following up on the discussion from this question , I was wondering how does one using native C++ determine programmatically whether or not the std::string implementation they are using utilizes Copy-On-Write (COW) I have the following function: #include <iostream> #include <string> bool stdstring_supports_cow() { //make sure the string is longer than the size of potential //implementation of small-string. std::string s1 = "012345678901234567890123456789" "012345678901234567890123456789" "012345678901234567890123456789" "012345678901234567890123456789" "012345678901234567890123456789"; std:

we have a multi-threaded desktop application in C++ (MFC). Currently developers use either CString or std::string, probably depending on their mood. So we'd like to choose a single implementation (probably something other than those two). MFC's CString is based on copy-on-write (COW) idiom, and some people would claim this is unacceptable in a multithreaded environment (and probably reference to this article ). I am not convinced by such claims, as atomic counters seem to be quite fast, and also this overhead is somehow compensated by a reduction in memory re-allocations. I learned that std: