Does any OS allow moving memory from one address to another without physically copying it?

Question

memcpy/memmove duplicate (copy the data) from source to destination. Does anything exist to move pages from one virtual address to another without doing an actual byte by byte copy of the source data? It seems to be perfectly possible to me, but does any operating system actually allow this? It seems odd to me that dynamic arrays are such a widespread and popular concept but that growing them by physically copying is such a wasteful operation. It just doesn't scale when you start talking about array sizes in the gigabytes (eg imagine growing a 100GB array into a 200GB array. That's a problem that's entirely possible on servers in the < $10K range now.

void* very_large_buffer = VirtualAlloc(NULL, 2GB, MEM_COMMIT);
// Populate very_large_buffer, run out of space.
// Allocate buffer twice as large, but don't actually allocate 
// physical memory, just reserve the address space.
void* even_bigger_buffer = VirtualAlloc(NULL, 4GB, MEM_RESERVE);
// Remap the physical memory from very_large_buffer to even_bigger_buffer without copying
// (i.e. don't copy 2GB of data, just copy the mapping of virtual pages to physical pages)
// Does any OS provide support for an operation like this?    
MoveMemory(very_large_buffer, even_bigger_buffer, 2GB)
// Now very_large_buffer no longer has any physical memory pages associated with it
VirtualFree(very_large_buffer)

Answer 1

To some extent, you can do that with mremap on Linux.

That call plays with the process's page table to do a zero-copy reallocation if it can . It is not possible in all cases (address space fragmentation, and simply the presence of other existing mappings are an issue).

The man page actually says this:

mremap() changes the mapping between virtual addresses and memory pages. This can be used to implement a very efficient realloc(3).

Answer 2

是的，通过映射文件的不同视图，内存映射文件的常见用途是在进程之间“移动”或复制内存

Answer 3

Every POSIX system is able to do this. If you use mmap with a file descriptor (obtained by open or shm_open ) and not anonymously you can unmap it, then truncate (shrink or grow) and then map it again. You may and often will get a different virtual address for the same pages.

Answer 4

I mean, you'd never be able to absolutely guarantee that there would be no active memory in that next 100GB, so you might not be able to make it contiguous.

On the other hand, you could use a ragged array (an array of arrays) where the arrays do not have to be next to each other (or even the same size). Many of the advantages of dynamic arrays may not scale to the 100GB realm.