Tagged articles
copy-on-write
45 articles · Page 1 of 1
Researchers from A*STAR, HKUST, NUS, and NTU introduce CUA-Sandbox, a system that shares execution runtimes across logical environments while isolating only mutable state via state capsules, achieving 2.22–6.20x higher rollout throughput, up to 9.2x memory savings, and 504x storage reduction on WebArena, VisualWebArena, and OSWorld without sacrificing task success rates.
CUA-SandboxOSWorldVisualWebArena
0 likes · 19 min read

This article provides a comprehensive visual guide to Redis architecture, covering single-instance deployment, high-availability setups with Sentinel, Redis Cluster sharding with hash slots, replication mechanics using replication IDs and offsets, and persistence models including RDB snapshots, AOF logging, and the fork/copy-on-write mechanism.
ClusterHigh AvailabilityRedis
0 likes · 20 min read

Linux’s Virtual Memory Area (VMA) is the kernel’s core structure for managing a process’s address space, and this article explains its definition, key fields, linked‑list and red‑black‑tree organization, allocation, protection, page‑fault handling, copy‑on‑write, and practical usage examples.
LinuxVMAcopy-on-write
0 likes · 26 min read

This article explains the fork system call in the Linux kernel, details the copy‑on‑write (COW) mechanism that underpins its efficiency, provides code examples, and explores practical scenarios and performance implications for process creation, memory usage, and concurrent server programming.
COWLinuxProcess Management
0 likes · 36 min read

The article dissects Claude Code’s Speculation system, showing how an AI sub‑agent predicts user intent, runs a full edit‑test pipeline in an overlay filesystem, filters results through twelve safety layers, and only commits changes when the user confirms, effectively turning speculative execution into a safe performance boost.
AI agentClaude CodeOverlay Filesystem
0 likes · 21 min read

This article explains how Paged Attention, introduced by the vLLM team, applies virtual‑memory techniques, non‑contiguous block mapping, copy‑on‑write reuse, distributed scheduling, and hardware‑level optimizations to improve KV‑cache efficiency and reduce memory fragmentation in large language model serving.
Distributed SchedulingGPU memory managementKV-Caching
0 likes · 6 min read

The article examines PHP's current variable handling, proposes treating variables as reusable resources to cut memory usage and boost performance, and outlines practical techniques, benefits, challenges, and future directions for such optimizations.
PHPVariable Managementcopy-on-write
0 likes · 7 min read

This article explains Apache Hudi's architecture, including its timeline mechanism, file layout, indexing strategies, table types (COW and MOR), query options, storage format versioning, backward compatibility, and key configuration settings for managing data lake tables.
Apache HudiMVCCMerge-On-Read
0 likes · 8 min read

This article explains Linux’s Copy‑On‑Write mechanism, detailing how it avoids full memory duplication during process creation, the underlying page‑table workflow, its implementation in the kernel, and real‑world applications such as Redis persistence, Docker image layering, and filesystem snapshots, while also discussing its advantages and drawbacks.
Linuxcopy-on-writememory management
0 likes · 73 min read

This article explains how the fork() system call creates a duplicate process in Linux, walks through a simple code experiment, details the kernel steps—including task_struct creation, PID allocation, copy-on-write memory handling, and resource inheritance—and highlights common use cases, optimizations, and pitfalls.
C++Linuxcopy-on-write
0 likes · 12 min read

The article explains the Copy‑On‑Write (COW) technique, its read‑write separation design, step‑by‑step flow, practical demos, Java's CopyOnWriteArrayList implementation, and MySQL InnoDB MVCC usage, while also discussing its performance benefits and inherent limitations.
COWConcurrencyCopyOnWriteArrayList
0 likes · 21 min read

This article dives deep into Swift's Dictionary implementation, explaining its underlying hash‑table structure, memory layout, bucket calculation, probing strategies, copy‑on‑write semantics, performance optimizations, and conflict‑resolution techniques, all illustrated with real source code and debugging screenshots.
SWIFTcopy-on-writedata structures
0 likes · 27 min read

This article dives deep into Swift's Dictionary implementation, explaining its underlying hash‑table structure, memory layout, variant storage, probing strategies, copy‑on‑write semantics, conflict resolution, load‑factor handling, and automatic resizing, all illustrated with real code and debugger screenshots.
SWIFTcopy-on-writedata structures
0 likes · 26 min read

This article dives deep into Swift's Array implementation, explaining how the language allocates memory, the role of SIL and internal structs like _Array, _ArrayBody, and _ContiguousArrayStorage, and how copy‑on‑write ensures efficient mutation handling, all illustrated with real code snippets and debugger output.
SILSWIFTcopy-on-write
0 likes · 20 min read

This guide explains Docker image layering, the roles of base and scratch images, bootfs and rootfs, the copy‑on‑write mechanism, and walks through building a busybox image with Dockerfile and shell scripts, highlighting common pitfalls and solutions.
Base ImageDockerDockerfile
0 likes · 12 min read

Remote development and CI share an identical Git‑based workflow, and CNB’s git‑clone‑yyds plugin plus declarative Dockerfile configuration enable rapid container startup, shared copy‑on‑write volume caching, and synchronized environment setup, making code preparation, dependency installation, and compile/test phases functionally equivalent across both contexts.
CI/CDCNBDeclarative Configuration
0 likes · 9 min read

CNB speeds up massive AOSP builds by using Docker volumes with a copy‑on‑write overlay cache, turning a 46‑minute compilation into a 90‑second incremental build even with six concurrent pipelines, while simplifying configuration and supporting multiple caching strategies for parallel development.
AOSP CompilationCI/CD optimizationCNB
0 likes · 8 min read

A cloud‑native CI platform called CNB uses a custom git‑clone‑yyds plugin and Copy‑on‑Write overlayfs to reduce cloning of the 124 GB AOSP source tree from 20 minutes to a few seconds while keeping cache safe for high‑concurrency pipelines, dramatically cutting overall build time.
AOSPCI/CDGit Clone Optimization
0 likes · 15 min read

The article reviews pandas 2.0’s major upgrades—including an Apache Arrow backend that speeds up CSV reads by over 30×, new Arrow dtypes, a nullable‑numpy dtype for missing values, a copy‑on‑write memory model, optional dependencies, and benchmark comparisons with ydata‑profiling—highlighting the library’s enhanced performance, flexibility, and interoperability for data‑intensive Python workflows.
Apache ArrowPandasPython
0 likes · 15 min read

This article explains Linux memory mapping (mmap), covering its purpose, API parameters, different mapping types, internal kernel implementation, page‑fault handling, copy‑on‑write semantics, practical use cases, and includes a complete Objective‑C example demonstrating file mapping and manipulation.
Linux kernelVMAcopy-on-write
0 likes · 27 min read

This article walks through a simple C program that forks a parent and child process, explains why they share the same virtual address for a global variable yet see different values, and details how Linux uses virtual memory, page tables, and copy‑on‑write to manage process address spaces.
copy-on-writeforkprocess
0 likes · 10 min read

This article explains Redis’s persistence mechanisms—including RDB snapshots, AOF append‑only logs, and the hybrid approach—detailing how to enable each method, their commands, configuration options, performance trade‑offs, rewrite processes, and recovery procedures to help you choose the right strategy for reliable data durability.
AOFRDBRedis
0 likes · 16 min read

This article provides a comprehensive, low‑level exploration of Swift's Array type, detailing its memory layout, the SIL generation process, buffer allocation, internal structures such as _ArrayBuffer and _ContiguousArrayStorage, and the copy‑on‑write behavior that governs mutation and reference counting.
Low-Level DebuggingSILSWIFT
0 likes · 18 min read


ITPUBNov 22, 2022 · Databases
Redis achieves high speed by keeping data in memory, but to avoid data loss it offers two persistence methods—RDB and AOF; this article explains RDB’s snapshot mechanism, the SAVE vs BGSAVE commands, copy‑on‑write handling, automatic save configuration, and the internal structures that drive periodic backups.
BGSAVERDBRedis
0 likes · 13 min read

This article explains Redis's persistence strategies—including RDB snapshotting with Copy‑On‑Write, AOF command logging with configurable fsync policies, and the hybrid persistence introduced in Redis 4.0—detailing their implementation, performance trade‑offs, configuration options, and practical usage examples.
AOFConfigurationHybrid Persistence
0 likes · 12 min read


ITPUBAug 27, 2022 · Databases
This article explains how Redis uses RDB snapshots, the AOF write‑ahead log, copy‑on‑write forked processes, and configurable fsync policies to achieve rapid recovery after crashes while balancing performance and data safety.
AOFRDBRedis
0 likes · 17 min read

The article explains the copy‑on‑write (COW) concurrency strategy, its suitability for read‑heavy scenarios, and demonstrates how Java implements COW with CopyOnWriteArrayList and CopyOnWriteArraySet, including volatile array handling, write‑locking, snapshot reads, and iterator behavior.
ConcurrencyCopyOnWriteArrayListJava
0 likes · 7 min read


ITPUBApr 26, 2022 · Big Data
This article explains the fundamentals of data lakes and data warehouses, compares their architectures, outlines the challenges of data lakes, and then dives deep into Delta Lake's core features, storage model, ACID guarantees, concurrency handling, and provides step‑by‑step Spark code examples for practical use.
ACIDDelta LakeMerge-On-Read
0 likes · 18 min read

This article explains the copy‑on‑write mechanism in Linux by examining page‑table structures, the fork process, and the page‑fault handling code in Linux 0.11, illustrating how the kernel uses read‑only page mappings and page‑fault interrupts to lazily duplicate memory pages.
Linuxcopy-on-writefork
0 likes · 9 min read

This article provides a comprehensive overview of Apache Hudi, covering its storage reliance on HDFS, core design principles, table architecture, timeline management, file and index structures, as well as detailed read and write workflows for both Copy‑On‑Write and Merge‑On‑Read table types.
Apache HudiMerge-On-ReadRead/Write
0 likes · 16 min read

This article explores the origins, core features, and installation methods of the advanced ZFS file system, highlighting its storage pool architecture, copy‑on‑write, snapshots, data integrity checks, RAID‑Z, and massive scalability that make it popular among engineers and enterprises.
RAID-ZSnapshotsZFS
0 likes · 9 min read

This article traces ZFS’s origins from its 2001 inception at Sun, outlines its open‑source evolution, and delves into core concepts such as storage pools, block management, copy‑on‑write, snapshots, deduplication, and the intricate transaction model that underpins its reliability.
FilesystemZFScopy-on-write
0 likes · 16 min read

This tutorial walks through PHP 7.4’s internal zend_string and zval structures, explains their role in binary‑safe strings and copy‑on‑write memory management, and demonstrates step‑by‑step debugging with GDB to inspect variable states and reference counts.
Backendcopy-on-writegdb
0 likes · 14 min read

This article explains core Linux I/O concepts—including file systems, I/O types, caching mechanisms, copy‑on‑write, zero‑copy, and performance metrics—then presents practical application, file‑system, and disk‑level optimization techniques to improve throughput and latency.
I/OLinuxcopy-on-write
0 likes · 15 min read

This article explains the evolution from traditional data warehouses to modern lakehouse architectures, introduces the Arctic system’s dynamic hash tree for fast update/delete, describes file splitting with sequence/offset ordering, and compares copy‑on‑write versus merge‑on‑read techniques for achieving low‑latency analytics.
ArcticDELETEData Update
0 likes · 12 min read

This article explains Redis's two persistence mechanisms—AOF (Append Only File) and RDB (snapshot)—detailing their concepts, write‑back strategies, rewrite process, performance trade‑offs, snapshot handling, copy‑on‑write technique, incremental snapshots, and the benefits of combining both approaches.
AOFRDBRedis
0 likes · 14 min read

The article explains how Hudi enables efficient record‑level updates in data lakes by adapting database update concepts such as copy‑on‑write and merge‑on‑read, contrasting them with traditional RDBMS and NoSQL storage mechanisms and their trade‑offs.
HudiMerge-On-ReadRecord Update
0 likes · 11 min read

This article examines the use of Apache Hudi for building a hospital‑wide medical big‑data platform, covering construction background, reasons for selecting Hudi, data synchronization methods, storage mode choices, query optimizations, and future development considerations.
Apache HudiMedical Big DataSpark
0 likes · 7 min read

This tutorial explains LVM snapshot principles, walks through preparing a logical volume, creating and mounting snapshots, handling common XFS UUID errors, restoring data manually or via snapshot merge, and provides practical commands and images for each step.
LVMLinuxcopy-on-write
0 likes · 9 min read

This article explains Linux’s virtual address space, the mmap system call, its prototype and typical applications—including shared file mapping, inter‑process communication, and file I/O optimization—while illustrating concepts with diagrams and code examples, and discusses alignment, copy‑on‑write, and memory swapping considerations.
copy-on-writememory mappingmmap
0 likes · 9 min read

This article explains the Linux mmap system call, covering virtual address space fundamentals, how mmap interacts with the page cache and inode structures, typical use‑cases such as shared memory and anonymous mappings, code examples, and special considerations like alignment, copy‑on‑write and memory swapping.
LinuxShared Memorycopy-on-write
0 likes · 9 min read

This article reviews the history of Sun and Solaris, explains ZFS’s core design as a combined file system and volume manager, and details its key features such as metadata integrity, copy‑on‑write, snapshots, clones, storage pools, RAID‑Z, caching, compression, deduplication, and tunability.
RAID-ZSnapshotsZFS
0 likes · 11 min read


ITPUBMar 3, 2017 · Fundamentals
When power is lost mid‑write, the write command, device caches, and ordering become uncertain, and file systems employ various strategies—ranging from ignoring errors to copy‑on‑write and journaling—to mitigate data loss, each with trade‑offs in performance and reliability.
EXT4copy-on-writedata integrity
0 likes · 9 min read


21CTOFeb 23, 2017 · Backend Development
This article explains PHP's core zval structure, how different variable types are stored, and the mechanisms of reference counting, copy‑on‑write, and garbage collection that enable efficient memory management in the Zend engine.
BackendPHPReference Counting
0 likes · 12 min read

This article explains the differences between code, programs, and processes in Linux, demonstrates how to compile and run a simple program, explores parent‑child relationships, the role of the init process, the process lifecycle, and the copy‑on‑write mechanism.
Linuxcopy-on-writeexec
0 likes · 10 min read
