Copy-on-write

Programming technique for efficiently duplicating data

Copy-on-write (COW), also called implicit sharing[1] or shadowing,[2] is a resource-management technique[3] used in programming to manage shared data efficiently. Instead of copying data right away when multiple programs use it, the same data is shared between programs until one tries to modify it. If no changes are made, no private copy is created, saving resources.[3] A copy is only made when needed, ensuring each program has its own version when modifications occur. This technique is commonly applied to memory, files, and data structures.

## In virtual memory management

[edit]

Copy-on-write finds its main use in operating systems, sharing the physical memory of computers running multiple processes, in the implementation of the fork() system call. Typically, the new process does not modify any memory and immediately executes a new process, replacing the address space entirely. It would waste processor time and memory to copy all of the old process's memory during the fork only to immediately discard the copy.[4]

Copy-on-write can be implemented efficiently using the page table by marking certain pages of memory as read-only and keeping a count of the number of references to the page. When data is written to these pages, the operating-system kernel intercepts the write attempt and allocates a new physical page, initialized with the copy-on-write data, although the allocation can be skipped if there is only one reference. The kernel then updates the page table with the new (writable) page, decrements the number of references, and performs the write. The new allocation ensures that a change in the memory of one process is not visible in another's.[citation needed]

The copy-on-write technique can be extended to support efficient memory allocation by keeping one page of physical memory filled with zeros. When the memory is allocated, all the pages returned refer to the page of zeros and are all marked copy-on-write. This way, physical memory is not allocated for the process until data is written, allowing processes to reserve more virtual memory than physical memory and use memory sparsely, at the risk of running out of virtual address space. The combined algorithm is similar to demand paging.[3]

Copy-on-write pages are also used in the Linux kernel's same-page merging feature.[5]

## In software

[edit]

This section needs expansion. You can help by adding to it. (October 2017)

|

COW is also used in library, application, and system code.

### Examples

[edit]

The string class provided by the C++ standard library was specifically designed to allow copy-on-write implementations in the initial C++98 standard,[6] but not in the newer C++11 standard:[7]

std::string x("Hello");

std::string y = x;  // x and y use the same buffer.

y += ", World!";    // Now y uses a different buffer; x still uses the same old buffer.

In the PHP programming language, all types except references are implemented as copy-on-write. For example, strings and arrays are passed by reference, but when modified, they are duplicated if they have non-zero reference counts. This allows them to act as value types without the performance problems of copying on assignment or making them immutable.[8]

In the Qt framework, many types are copy-on-write ("implicitly shared" in Qt's terms). Qt uses atomic compare-and-swap operations to increment or decrement the internal reference counter. Since the copies are cheap, Qt types can often be safely used by multiple threads without the need of locking mechanisms such as mutexes. The benefits of COW are thus valid in both single- and multithreaded systems.[9]

## In computer storage

[edit]

COW is used as the underlying mechanism in file systems like ZFS, Btrfs, ReFS, and Bcachefs,[10] as well as in logical volume management and database servers such as Microsoft SQL Server.

In traditional file systems, file changes overwrite the original data. With COW, when changes are made, a new version of the file is created while keeping the original intact. This approach enables features like snapshots, which capture the state of a file at a specific time without consuming much additional space. Snapshots typically store only the modified data and are kept close to the original. However, they are considered a weak form of incremental backup and cannot replace a full backup.[11]

## See also

[edit]

* Allocate-on-flush
* Dirty COW – a computer security vulnerability for the Linux kernel
* Flyweight pattern
* Memory management
* Persistent data structure
* Wear leveling

## References

[edit]

1. ^ "Implicit Sharing". Qt Project. Archived from the original on 8 February 2024. Retrieved 10 November 2023.
2. ^ Rodeh, Ohad (1 February 2008). "B-Trees, Shadowing, and Clones" (PDF). ACM Transactions on Storage. 3 (4): 1. CiteSeerX 10.1.1.161.6863. doi:10.1145/1326542.1326544. S2CID 207166167. Archived from the original (PDF) on 2 January 2017. Retrieved 10 November 2023.
3. ^ a b c Bovet, Daniel Pierre; Cesati, Marco (1 January 2002). Understanding the Linux Kernel. O'Reilly Media. p. 295\. ISBN 9780596002138. Archived from the original on 15 September 2024. Retrieved 10 November 2023.
4. ^ Silberschatz, Abraham; Galvin, Peter B.; Gagne, Greg (2018). Operating System Concepts (10th ed.). Wiley. pp. 120–123\. ISBN 978-1119456339.120-123&rft.edition=10th&rft.pub=Wiley&rft.date=2018&rft.isbn=978-1119456339&rft.aulast=Silberschatz&rft.aufirst=Abraham&rft.au=Galvin,+Peter+B.&rft.au=Gagne,+Greg&rfr_id=info:sid/en.wikipedia.org:Copy-on-write" class="Z3988">
5. ^ Abbas, Ali. "The Kernel Samepage Merging Process". alouche.net. Archived from the original on 8 August 2016. Retrieved 10 November 2023.
6. ^ Meyers, Scott (2012). Effective STL. Addison-Wesley. pp. 64–65\. ISBN 9780132979184.64-65&rft.pub=Addison-Wesley&rft.date=2012&rft.isbn=9780132979184&rft.aulast=Meyers&rft.aufirst=Scott&rfr_id=info:sid/en.wikipedia.org:Copy-on-write" class="Z3988">
7. ^ "Concurrency Modifications to Basic String". Open Standards. Archived from the original on 10 November 2023. Retrieved 10 November 2023.
8. ^ Pauli, Julien; Ferrara, Anthony; Popov, Nikita (2013). "Memory management". PhpInternalsBook.com. Archived from the original on 10 November 2023. Retrieved 10 November 2023.
9. ^ "Threads and Implicitly Shared Classes". Qt Project. Archived from the original on 3 December 2023. Retrieved 10 November 2023.
10. ^ Kasampalis, Sakis (2010). "Copy-on-Write Based File Systems Performance Analysis and Implementation" (PDF). p. 19\. Archived (PDF) from the original on 5 May 2024. Retrieved 10 November 2023.
11. ^ Chien, Tim. "Snapshots Are NOT Backups". Oracle.com. Oracle. Archived from the original on 10 November 2023. Retrieved 10 November 2023.

## External links

[edit]

* "A history of copy-on-write memory management". A keen grasp of the obvious. 21 January 2011. Retrieved 18 November 2024.

* v
* t
* e

File systems

* Comparison of file systems
* distributed
* Unix filesystem

Disk and
non-rotating|

* ADFS
* AdvFS
* Amiga FFS
* Amiga OFS
* APFS
* AthFS
* bcachefs
* BFS
* Be File System
* Boot File System
* Byte File System (z/VM)
* Btrfs
* CVFS
* CXFS
* DFS
* EFS
* Encrypting File System
* Extent File System
* Episode
* ext
* ext2
* ext3
* ext3cow
* ext4
* FAT
* exFAT
* Files-11
* Fossil
* GPFS
* HAMMER
* HAMMER2
* HFS (Classic Mac OS)
* HFS (MVS)
* HFS+
* HPFS
* HTFS
* JFS
* LFS
* MFS
* Macintosh File System
* TiVo Media File System
* MINIX
* NetWare File System
* Next3
* NILFS
* NILFS2
* NSS
* NTFS
* OneFS
* OpenZFS
* PFS
* QFS
* QNX4FS
* ReFS
* ReiserFS
* Reiser4
* Reliance
* Reliance Nitro
* RFS
* SFS
* Shared File System (VM)
* Smart File System
* SNFS
* Soup (Apple)
* Tux3
* UBIFS
* UFS/UFS2
* soft updates
* WAPBL
* VxFS
* WAFL
* Xiafs
* XFS
* Xsan
* zFS (z/OS)
* ZFS (Sun)

Optical disc|

* HSF
* ISO 9660
* ISO 13490
* UDF

Flash memory and SSD|

* APFS
* FAT
* exFAT
* TFAT
* EROFS
* F2FS
* JFS
* NVFS

| host-side wear leveling|

* CHFS
* JFFS
* JFFS2
* LogFS
* NILFS
* NILFS2
* YAFFS
* UBIFS

|

Distributed parallel|

* BeeGFS
* Ceph
* CXFS
* GFS2
* Google File System
* OCFS2
* OrangeFS
* PVFS
* QFS
* Xsan
* more...

NAS|

* 9P
* AFS (OpenAFS)
* AFP
* Coda
* DFS
* Google File System
* GPFS
* Lustre
* NCP
* NFS
* POHMELFS
* Hadoop
* SMB (CIFS)
* SSHFS
* more...

Specialized|

* Aufs
* AXFS
* Boot File System
* Compact Disc File System
* cramfs
* Davfs2
* EROFS
* FTPFS
* FUSE
* Lnfs
* LTFS
* NOVA
* MVFS
* SquashFS
* UMSDOS
* OverlayFS
* UnionFS

Pseudo|

* configfs
* devfs
* debugfs
* kernfs
* procfs
* specfs
* sysfs
* tmpfs
* WinFS

Encrypted|

* eCryptfs
* EncFS
* EFS
* Rubberhose
* SSHFS
* ZFS

Types|

* Clustered
* Global
* Grid
* Self-certifying
* Flash
* Journaling
* Log-structured
* Object
* Record-oriented
* Semantic
* Steganographic
* Synthetic
* Versioning

Features|

* Case preservation
* Copy-on-write
* Data deduplication
* Data scrubbing
* Execute in place
* Extent
* File attribute
* Extended file attributes
* File change log
* Fork
* Inode
* Links
* Hard
* Symbolic

Access control|

* Access-control list
* Filesystem-level encryption
* Permissions
* Modes
* Sticky bit

Interfaces|

* File manager
* File system API
* Installable File System
* Virtual file system

Lists|

* Cryptographic
* Default
* Log-structured

Layouts|

* Master Boot Record
* GUID Partition Table
* Apple Partition Map

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template