Copy-on-write

Short description: Programming technique for efficiently duplicating data

Copy-on-write (COW), sometimes referred to as implicit sharing[1] or shadowing,[2] is a resource-management technique used in computer programming to efficiently implement a "duplicate" or "copy" operation on modifiable resources.[3] If a resource is duplicated but not modified, it is not necessary to create a new resource; the resource can be shared between the copy and the original. Modifications must still create a copy, hence the technique: the copy operation is deferred until the first write. By sharing resources in this way, it is possible to significantly reduce the resource consumption of unmodified copies, while adding a small overhead to resource-modifying operations.

## Contents

* 1 In virtual memory management
* 2 In software
* 2.1 Examples
* 3 In computer storage
* 4 See also
* 5 References

## In virtual memory management

Copy-on-write finds its main use in sharing the virtual memory of operating system processes, in the implementation of the fork system call. Typically, the process does not modify any memory and immediately executes a new process, replacing the address space entirely. Thus, it would be wasteful to copy all of the process's memory during a fork, and instead the copy-on-write technique is used.

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.

The copy-on-write technique can be extended to support efficient memory allocation by having a 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.[4]

## In software

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

### Examples

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

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.[7]

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.[8]

## In computer storage

COW may also be used as the underlying mechanism for snapshots, such as those provided by logical volume management, file systems such as Btrfs and ZFS,[9] and database servers such as Microsoft SQL Server. Typically, the snapshots store only the modified data, and are stored close to the original, so they are only a weak form of incremental backup and cannot substitute for a full backup.[10]

## See also

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

## References

1. ↑ "Implicit Sharing". http://doc.qt.io/qt-5/implicit-sharing.html.
2. ↑ Rodeh, Ohad (1 February 2008). "B-Trees, Shadowing, and Clones". ACM Transactions on Storage 3 (4): 1. doi:10.1145/1326542.1326544. http://liw.fi/larch/ohad-btrees-shadowing-clones.pdf. Retrieved 4 August 2016.
3. ↑ 3.0 3.1 Bovet, Daniel Pierre; Cesati, Marco (2002-01-01). Understanding the Linux Kernel. O'Reilly Media. p. 295. ISBN 9780596002138. https://books.google.com/books?id=9yIEji1UheIC&q="copy on write"&pg=PA295.
4. ↑ Abbas, Ali. "The Kernel Samepage Merging Process". http://alouche.net/blog/2011/07/18/the-kernel-samepage-merging-process/.
5. ↑ Meyers, Scott (2012). Effective STL. Addison-Wesley. pp. 64–65. ISBN 9780132979184. https://books.google.com/books?id=U7lTySXdFk0C&pg=PT734.
6. ↑ "Concurrency Modifications to Basic String". http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2534.html.
7. ↑ Pauli, Julien; Ferrara, Anthony; Popov, Nikita (2013). "Memory management". http://www.phpinternalsbook.com/zvals/memory_management.html#reference-counting-and-copy-on-write.
8. ↑ "Threads and Implicitly Shared Classes". http://doc.qt.io/qt-5/threads-modules.html#threads-and-implicitly-shared-classes.
9. ↑ Kasampalis, Sakis (2010). "Copy-on-Write Based File Systems Performance Analysis and Implementation". p. 19. http://sakisk.me/files/copy-on-write-based-file-systems.pdf.
10. ↑ Chien, Tim. "Snapshots Are NOT Backups". Oracle. http://www.oracle.com/technetwork/documentation/rman-fra-snapshot-322251.html.

* v
* t
* e

File systems

* Comparison of file systems
* distributed
* Unix filesystem

Disk|

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

Optical disc|

* HSF
* ISO 9660
* ISO 13490
* UDF

Flash memory and SSD|

* APFS
* FAT
* exFAT
* CHFS
* TFAT
* EROFS
* FFS2
* F2FS
* HPFS
* JFFS
* JFFS2
* JFS
* LogFS
* NILFS
* NILFS2
* NVFS
* YAFFS
* UBIFS

Distributed|

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

NAS|

* AFS (OpenAFS)
* AFP
* Coda
* DFS
* Google File System
* IBM Spectrum Scale
* Lustre
* NCP
* NFS
* POHMELFS
* Hadoop
* SMB (CIFS)
* SSHFS
* more...

Specialized|

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

Pseudo and virtual|

* 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
* 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

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Copy-on-write. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Copy-on-write&oldid=2999522"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template