High-precision definitions for key principles, protocols, and architectural patterns, cross-linked to hands-on lessons and simulations.
The composite distributed training strategy combining intra-node Tensor Parallelism (TP over high-speed NVLink), inter-node Pipeline Parallelism (PP micro-batches across layers), and Data Parallelism / ZeRO (DP across replicas).
An algorithm that emulates a linearizable atomic read/write register over crash-prone asynchronous replicas without a leader by executing a two-phase Read (query quorum for max timestamp, then write-back to quorum before returning).
A memory-compute trade-off during neural network training that discards intermediate forward-pass layer activations and recomputes them on-the-fly during backpropagation, reducing activation VRAM from O(L) to O(sqrt(L)) for ~33% extra FLOPs.
A video delivery architecture that encodes media into short 2-6 second GOP-aligned segments across multiple resolution/bitrate rungs, allowing client players to dynamically switch quality per segment based on measured network throughput.
A server self-protection mechanism (such as CoDel or Little Law concurrency limiters) that proactively drops low-priority or excess incoming requests at the edge when internal queueing delay exceeds a threshold, preserving throughput for critical traffic.
Synchronization primitives: spinlocks busy-wait in user space burning CPU cycles (ideal only for sub-microsecond critical sections), while Linux futex (Fast Userspace Mutex) performs an uncontended atomic CAS in user space and only enters a kernel sleep syscall on contention.
A cluster scheduling policy for tightly-coupled distributed GPU training jobs requiring that all N requested GPU pods be co-scheduled and started simultaneously; otherwise none are allocated, preventing partial-allocation deadlocks.
Amdahl Law bounds parallel speedup by the serial fraction sigma. Gunther Universal Scalability Law (USL) adds a quadratic retrograde term kappa * N * (N - 1) modeling cross-node coherence and lock contention that causes throughput to degrade past peak concurrency.
An open analytical table format providing ACID snapshot isolation, schema evolution, hidden partitioning, and time-travel queries over immutable Parquet/ORC files on cloud object storage via hierarchical manifest trees.
Mohan foundational write-ahead logging recovery algorithm using Log Sequence Numbers (LSNs) on every page and physiological logging: Analysis identifies dirty pages and active transactions at crash time, Redo repeats history to restore the exact pre-crash state, and Undo rolls back uncommitted losers.
A fault-tolerant training pattern that copies sharded ZeRO/FSDP model and optimizer states from GPU HBM to pinned host DRAM in seconds via CUDA D2H streams, flushing asynchronously to parallel object/file storage so multi-thousand-GPU jobs lose < 2 minutes of progress on hardware failure.
A distributed rate-limiting implementation that executes token refill math and counter decrements inside a single server-side Redis EVALSHA Lua script so concurrent API gateways never suffer race conditions between GET and SET.
A progressive delivery safeguard that routes 1-5% of production traffic to a new canary version alongside a baseline control group of identical size, using the Mann-Whitney U test over error rate and p99 latency distributions to trigger automatic rollback on regressions.
The GPU HBM tensor buffer storing historical Key and Value attention projections for all preceding tokens in an active sequence so autoregressive decoding scales linearly O(S) rather than quadratically O(S^2) per generated token.
A self-balancing, page-oriented search tree with high fanout (typically 100-500 keys per 4KB-16KB page) where internal nodes store routing keys only and leaf nodes store sorted data records or row pointers linked sequentially for fast range scans.
Quantitative architectural sizing using powers-of-two byte scales, seconds-per-day (86,400 ~ 10^5), peak-to-average ratios (3x-10x), and Jeff Dean hardware latency numbers (L1 cache 1ns, RAM 100ns, NVMe 20-100us, intra-AZ network 250us, cross-continent RTT 150ms).
The product of a network link data capacity (bits/sec) and its Round-Trip Time (RTT), representing the exact volume of unacknowledged in-flight data required to saturate the physical pipe.
Google model-based TCP congestion control algorithm that paces packet transmission using real-time estimates of bottleneck bandwidth and minimum physical RTT rather than waiting for bufferbloat packet loss like CUBIC.
An edge networking technique where multiple geographically distributed PoPs announce the exact same IP prefix over Border Gateway Protocol (BGP), automatically steering client packets to the topologically nearest healthy edge location.
The two-stage RAG retrieval funnel: Stage 1 uses a fast Bi-Encoder (HNSW dot product over pre-computed embeddings) to retrieve top-100 candidates in < 15ms, and Stage 2 passes concatenated (query, document) pairs through a full cross-attention Transformer to re-score the top-10.
A hardware-sympathetic Bloom filter variant (used in Apache Parquet and RocksDB) that restricts all k hash bit probes for a given key to a single 64-byte CPU cache line (512 bits), executing membership checks in exactly 1 L1/RAM cache miss instead of k misses.
A space-efficient probabilistic data structure that tests set membership. It yields either "definite negative" (element is guaranteed not in the set) or "possible positive" (element might be in the set or a false positive), with zero false negatives.
The mathematical formula minimizing a Bloom filter false positive probability p ≈ (1 - e^(-kn/m))^k for a bit array of size m and n inserted elements: choosing k = (m/n) * ln(2) sets exactly 50% of bits to 1 at capacity (~9.6 bits per key for 1% FPR).
A probabilistic lexical ranking function scoring document relevance via Inverse Document Frequency (IDF), saturating term frequency (k1), and document-length normalization (b).
When joining two unbounded event streams (e.g., Ad Impressions and Ad Clicks), the stream processor must buffer unmatched events in RocksDB state on both sides; configuring explicit watermark-bounded window join intervals and state TTL prevents unbounded disk exhaustion.
Fault-isolation patterns that partition worker pools, connection pools, or stateless server subsets so a poison-pill tenant or slow dependency can only exhaust its assigned subset of shards rather than taking down the entire fleet.
A stampede-prevention mechanism where only one cache-miss worker receives a short-lived lease token to recompute and repopulate a hot key from the database, while concurrent misses wait on the in-flight promise.
Brewer theorem stating that during a network Partition (P), a distributed data store must choose between Linearizable Consistency (C) and 100% Availability (A). PACELC extends this: Even when running normally (E), systems trade off Latency (L) vs Consistency (C).
The strongest consistency model achievable while remaining available under network partitions (CAC theorem). Guarantees that all nodes observe causally related operations in the same order, while concurrent operations may be observed in different orders.
A blast-radius containment topology that packages a complete, self-contained vertical stack of services, databases, and queues into an independent unit ("Cell") serving a fixed maximum number of tenants, so a catastrophic failure inside one cell affects at most 1-5% of customers.
The intermediate aggregation layer in Ceph that hashes millions of objects into a fixed number of Placement Groups (PGs) mapped onto OSDs via CRUSH; Peering is the protocol by which OSDs storing a PG agree on the authoritative state of objects after topology changes.
An asynchronous distributed checkpointing algorithm used by Apache Flink that injects lightweight barrier markers into data streams to capture a globally consistent cut of operator states without halting stream ingestion.
A non-intrusive pattern that tails a database engine commit log (PostgreSQL WAL, MySQL binlog, TiKV Raft log) to stream row-level INSERT, UPDATE, and DELETE mutations downstream in commit order.
An LLM serving scheduling technique that splits long incoming prompt prefills into fixed-size token chunks (e.g., 512 tokens) and piggybacks active decode requests alongside each prefill chunk, eliminating Inter-Token Latency (ITL) generation stalls on mixed-length workloads.
A stability pattern that detects cascading service failures and temporarily fails fast without hitting downstream dependencies. Operates in Closed, Open, and Half-Open states to allow downstream backends time to recover.
In HLC-based distributed SQL databases (CockroachDB, YugabyteDB) without atomic clocks, when a transaction encounters a value written within [T_read, T_read + max_offset], it performs a timestamp bump and checks whether historical reads remain valid to preserve causal ordering.
An engineering discipline that attributes cloud compute, storage tiering (NVMe vs S3), and cross-AZ network egress costs directly to business unit metrics (e.g., cost per 1,000 API calls or cost per 1M tokens).
A cloud-native vector database architecture that decouples stateless Proxy/Coordinator nodes, streaming log brokers (Pulsar/Kafka) for fresh delta inserts, IndexNodes for heavy asynchronous HNSW/DiskANN builds, and QueryNodes for sealed + growing segment search.
In a Clustered Index (MySQL InnoDB), B+ Tree leaf pages store the full table row directly ordered by primary key, making secondary index lookups require a double B+ Tree traversal (secondary leaf -> primary key -> clustered leaf) unless covered; in a Heap Table (PostgreSQL), indexes point directly to physical tuple CTIDs.
The four necessary and sufficient conditions for a resource deadlock: Mutual Exclusion, Hold and Wait, No Preemption, and Circular Wait. Eliminating Circular Wait via strict global lock acquisition ordering guarantees deadlock freedom.
A distributed data structure (G-Counter, PN-Counter, LWW-Element-Set, OR-Set) whose state-merge function is commutative, associative, and idempotent (join-semilattice), guaranteeing strong eventual consistency without coordination.
A distributed partitioning algorithm mapping both nodes and keys to a continuous token ring. Adding or removing a node only redistributes K/N keys on average, avoiding full cluster re-shuffling through virtual nodes (vnodes).
Mirrokni et al. enhancement to ring hashing (used in Envoy and Vimeo) that caps each node capacity at ceil(c * (total_load / N)) where c = 1.25; if the primary hashed node is at capacity, the request spills clockwise to the next node with available headroom, preventing viral key overload.
A consistency guarantee ensuring that if a sequence of writes occurs in order W1, W2, W3, any reader observing W2 is guaranteed to also observe W1—preventing causal inversions across multi-shard snapshots.
The architectural principle that the high-frequency packet/request forwarding path (Data Plane) must continue operating uninterrupted using its last known good local state even if the configuration/coordination brain (Control Plane) suffers a total outage ("Static Stability").
Gil Tene measurement fallacy where a closed-loop benchmark client waits for a stalled server response before sending the next scheduled request, inadvertently omitting the queuing delay experienced by real open-loop arrivals and underreporting p99 latency by orders of magnitude.
An immutable B-Tree storage variant that never overwrites modified disk pages in place; instead, updates write new shadow pages up to a newly swapped root pointer, providing wait-free MVCC readers and instant crash recovery without a separate redo WAL.
A sub-linear space probabilistic frequency table using d independent hash functions mapping onto a d x w counter matrix. Point frequency queries take the minimum across the d hashed buckets, bounding overestimation error with probability 1 - delta.
A secondary index that includes all columns referenced in a query SELECT, WHERE, and ORDER BY clauses (via INCLUDE payload columns), allowing the database engine to answer the query purely from the B+ Tree leaf pages without random heap/clustered table lookups.
A hardware performance pathology where independent threads on different CPU cores modify distinct variables residing on the same 64-byte L1/L2 cache line, forcing continuous MESI cache-coherency invalidations across the interconnect.
CFT protocols (Raft, Paxos) tolerate up to f benign crash/network faults with 2f + 1 nodes; BFT protocols (PBFT, HotStuff) tolerate up to f arbitrary malicious or corrupted nodes sending conflicting signed messages, requiring at least 3f + 1 nodes.
A pseudo-random, deterministic data placement algorithm used by Ceph that computes object storage OSD targets directly from cluster topology maps and failure-domain rules without a central metadata lookup table.
A binary or k-ary hash tree where leaf nodes store cryptographic hashes of data blocks and parent nodes store hashes of their concatenated children, allowing two replicas to isolate divergent key sub-ranges in O(log N) network exchanges.
A compact probabilistic set-membership data structure based on Cuckoo hashing of compact fingerprints that supports dynamic key deletions with lower space overhead than Bloom filters for false positive rates epsilon < 3%.
A holding queue where message brokers route malformed or repeatedly failing messages after exceeding maxReceiveCount, preventing a single unprocessable event ("poison pill") from blocking healthy partition consumption.
A cloud-native messaging architecture that separates stateless topic serving brokers from a distributed ledger-segment storage tier (BookKeeper), enabling instant broker failover and partition expansion without copying historical topic data across nodes.
An ANN vector search architecture designed for billion-scale datasets that keeps compressed PQ codes in RAM while storing full-precision vectors and long-range Vamana graph adjacency lists on NVMe SSDs, achieving < 5ms queries with 10x lower RAM cost.
A columnar Shredding algorithm used by Apache Parquet and Capacitator to Losslessly encode arbitrarily nested and repeated schemas into flat columnar stripes without materializing full parent records.
The standard ML feature platform topology pairing a low-latency key-value online store (< 5ms point lookups for real-time inference) with a columnar data lakehouse offline store (for batch training), synchronized from a single stream/batch transformation definition.
A liveness failure mode in Single-Decree Paxos where two competing proposers continuously preempt each other Phase 1 Prepare promises with higher ballot numbers before either can complete Phase 2 Accept—solved in production via a stable elected Multi-Paxos/Raft leader or randomized backoff.
An orchestration pattern (Temporal / LangGraph) that persists every LLM generation step and external tool-call result into an event-sourced journal so long-running agent workflows recover mid-trajectory after worker crashes without re-executing expensive or non-idempotent tools.
An adaptive 2D spatial tree index that recursively subdivides dense urban quadrants into four child nodes once a bucket exceeds K points (e.g., K = 500 restaurants) while keeping sparse rural oceans as single large leaf nodes, ordered on disk via a continuous Hilbert space-filling curve.
An auto-sharding mechanism (used in TiKV, CockroachDB, and Spanner) that monitors per-range byte size and QPS/CPU heat, automatically bisecting hot contiguous key ranges at the median key and migrating Raft replicas to underutilized nodes.
Linux kernel instrumentation hooks: kprobes dynamically instrument any kernel function entry/exit, uprobes instrument user-space application functions (like OpenSSL SSL_write or Go/JVM runtime functions), and static Tracepoints provide ABI-stable kernel event hooks with near-zero overhead.
A feedback mechanism where a slow downstream consumer signals upstream producers to pause or throttle emission (via bounded blocking queues, TCP window zeroing, or Flink credit-based buffers), preventing unbounded OOM memory growth.
A stream processing guarantee achieved by coordinating replayable source offsets (Kafka), Chandy-Lamport operator state checkpoints (Flink), and transactional sink pre-commits that finalize atomically upon checkpoint completion.
A two-tier cryptographic key management architecture where bulk data is encrypted locally with a fast symmetric Data Encryption Key (DEK), and the DEK itself is encrypted ("wrapped") by a Hardware Security Module (HSM/KMS) Key Encryption Key (KEK).
In Envoy proxy, Circuit Breaking enforces deterministic hard limits on active in-flight requests, pending connection queues, and concurrent retries to prevent resource exhaustion, while Outlier Detection tracks consecutive 5xx/latency failures to temporarily eject unhealthy upstream hosts.
A data protection method partitioning data into K data chunks and M parity chunks over Galois Fields GF(2^8). Any K of the K+M chunks suffice to reconstruct the original data, achieving higher durability at 1.5x storage overhead compared to 3x replication.
The golden ordering rule for multi-column B+ Tree indexes: place exact Equality predicate columns first, followed by Sort (ORDER BY) columns to avoid in-memory filesorts, and Range (<, >) predicate columns last.
Unlike path-based trees, etcd v3 stores a flat multi-version keyspace indexed by a cluster-wide monotonically increasing 64-bit Revision counter, enabling reliable resumable gRPC Watch streams from any historical revision since the last compaction.
A metric of progress in event time stream processing systems (like Apache Flink). A watermark of timestamp T asserts that the system assumes no further records with event time t <= T will arrive, triggering window evaluation.
A multi-phase database evolution pattern (Expand nullable column -> Dual-Write + Background Backfill -> Switch Reads -> Contract old column) that guarantees backward compatibility while old and new application binaries run simultaneously during a rolling deploy.
A retry scheduling algorithm (sleep = random(0, min(cap, base * 2^attempt))) that randomizes retry delays across clients to break synchronized retry waves and prevent self-inflicted DDoS after a transient outage.
A Linux kernel technology running sandboxed, verified bytecode inside kernel space in response to system events, tracepoints, and network sockets without modifying kernel source or loading modules.
The 8 false assumptions engineers make when transitioning from single-node code to distributed systems: the network is reliable, latency is zero, bandwidth is infinite, the network is secure, topology does not change, there is one administrator, transport cost is zero, and the network is homogeneous.
An ultra-compact directed acyclic word graph (used in Lucene and autocomplete engines) that shares both prefixes and suffixes across sorted terms, shrinking dictionary memory by 5x-10x while pre-computing top-K popularity rankings at every node.
An exact attention kernel algorithm that tiles Q, K, V blocks into fast GPU on-chip SRAM and computes online softmax normalization without ever materializing the O(N^2) attention matrix in slow HBM.
The foundational theorem by Fischer, Lynch, and Paterson proving that no deterministic consensus protocol can guarantee both safety and liveness (termination) in a purely asynchronous network if even a single node may crash.
Numerical precision formats for AI accelerators: E4M3 (4 exponent, 3 mantissa bits) maximizes dynamic precision for forward weights/activations, E5M2 preserves range for backward gradients, and AWQ/GPTQ quantizes inference weights to 4-bit integers to halve HBM bandwidth.
Functional requirements specify deterministic domain behavior (what APIs do), whereas Non-Functional Requirements (NFRs) specify quantifiable operational constraints—throughput (QPS), tail latency (p99), durability (11 nines), consistency (linearizable vs eventual), and blast radius.
A monotonically incremented integer incremented every time a new cluster controller or Raft/ZAB leader is elected, included in every RPC to reject stale commands from deposed leaders.
A DNS traffic steering extension (RFC 7871) where recursive resolvers forward the truncated client IP prefix (/24 IPv4) to authoritative nameservers so CDN edge mapping resolves to a PoP near the actual end user rather than the recursive resolver.
A hierarchical spatial indexing scheme that interleaves latitude and longitude bits (Morton Z-order curve) into a Base32 string prefix, mapping 2D bounding boxes onto 1D lexicographically sortable database ranges.
A decentralized two-phase commit protocol layered over multi-version key-value storage (used in TiKV) that designates one mutated key as the Primary Lock and stores secondary lock pointers, eliminating a single central transaction manager bottleneck.
A hardware-assisted clock synchronization subsystem combining GPS receivers and rubidium atomic clocks in every datacenter to expose a bounded time uncertainty interval [earliest, latest] (epsilon <= 7ms), enabling Spanner commit-wait external consistency.
Modern AI accelerator microarchitecture: Streaming Multiprocessors (SMs) use specialized Tensor Cores to execute 4x4 or 16x16 fused matrix-multiply-accumulate (MMA) operations per clock cycle, fed by a 3-tier memory hierarchy—High Bandwidth Memory (HBM3e ~3.3 TB/s), L2 Cache (~50 MB), and on-chip Shared Memory / Register File (~20+ TB/s).
Designing user-facing systems so non-essential dependencies (e.g., personalized ML recommendations or real-time inventory badges) fail open to static cached defaults when overloaded, preserving the core critical path (e.g., checkout).
Attention architectural variants that share a single Key/Value head across a group of Query heads (GQA) or all Query heads (MQA), shrinking KV-cache memory footprint and HBM bandwidth requirements by 4x-8x with negligible quality loss.
A high-performance RPC framework running over HTTP/2 streams using compact binary tag-length-value (TLV) Varint wire encoding and strict .proto interface definition schemas.
Lamport strict partial ordering over distributed events defined by local program order, message send-to-receive causality, and transitivity. Events not ordered by happens-before are causally concurrent.
A wide-column architecture where stateless/ephemeral RegionServers serve single-master key ranges backed by HFiles and HLog (WAL) persisted directly onto a shared 3x-replicated HDFS cluster, enabling RegionServer crash recovery by replaying HLogs on any surviving node without copying SSTables.
The high-availability metadata architecture of Apache Hadoop HDFS where the Active NameNode logs namespace EditLogs to a majority quorum of JournalNodes (with ZKFC fencing) while DataNodes replicate 128MB blocks across rack-aware failure domains.
Logarithmic/centroid-based sketch data structures that accurately aggregate latency distributions (p50, p99, p99.9) across thousands of stateless servers. Unlike averaging per-host p99s (which is mathematically invalid), histograms merge additively without loss of tail fidelity.
A performance stall where a single lost packet or slow request delays independent subsequent requests sharing the same queue or TCP byte stream. HTTP/3 (QUIC) eliminates transport-layer HoL blocking via independent UDP-based streams.
A tail-latency mitigation technique where a client issues a secondary speculative read to an alternate replica if the primary replica has not responded within the p95 latency threshold, cancelling the slower request once the first succeeds.
A multi-resolution discrete global grid system based on regular hexagons. Unlike rectangular Geohashes, every hexagon has 6 equidistant neighbors, eliminating corner-distance distortion in ride-dispatch and surge pricing.
An O(1) timer data structure (used by Kafka, Netty, and Linux kernel) composed of circular arrays of time slots across cascading granularities (ms, sec, min) that advances via a single tick pointer to manage millions of timeouts.
In Apache Kafka and replicated logs, the highest log offset that has been successfully replicated to all members of the In-Sync Replica (ISR) set; consumers are only permitted to read offsets up to the High Watermark.
A sharding design pattern that appends a bounded random salt suffix (0..K-1) or hash prefix to monotonically increasing or celebrity keys (e.g., tenant_id#0..7) to spread write hotspots across K physical partitions, trading scatter-gather reads for parallel write throughput.
Observability dimensions with millions of unique values (e.g., tenant_id, request_id) that cause time-series metric index explosion if attached to Prometheus labels, solved by linking aggregated histograms to distributed trace IDs via OpenTelemetry Exemplars.
A multi-layer proximity graph index for Approximate Nearest Neighbor (ANN) vector search that combines skip-list hierarchy with navigable small-world greedy routing to achieve sub-millisecond O(log N) search at >95% recall.
A clock synchronization mechanism combining monotonic physical time with Lamport logical counters. HLC tracks physical wall clocks within bounded NTP drift while guaranteeing strict causality without requiring specialized hardware like atomic clocks.
The social-feed architecture combining Fan-Out-on-Write (pushing post IDs to follower Redis inbox lists in O(followers) for normal accounts) with Fan-Out-on-Read (merging celebrity posts at query time) to avoid hot-key write amplification.
A probabilistic algorithm for estimating the cardinality of unique elements in massive datasets. Uses the distribution of leading zeros in hashed values, using only 1.5 KB of memory to achieve a standard error of 1.04 / sqrt(m).
To prevent single outlier hash collisions (e.g., 50 leading zeros by chance) from skewing cardinality estimates, HyperLogLog partitions the hash stream into m = 2^b substream registers using the first b bits and computes the bias-corrected harmonic mean across all m registers.
Non-blocking kernel readiness notification interfaces (epoll_wait) and asynchronous ring-buffer submission/completion queues (io_uring) that allow a single event-loop thread to handle 100,000+ concurrent sockets (C100K) in O(active events).
A client-generated UUID attached to mutating requests (such as payment charges) stored atomically alongside the business state mutation so network retries return the cached response without executing duplicate side effects.
A financial database schema pattern where account balances are never updated in-place via mutable floats; instead, every transfer atomically appends paired credit and debit journal entries summing to zero using fixed-point integer minor units.
The dynamic subset of follower replicas in Apache Kafka that have fully caught up with the partition leader within replica.lag.time.max.ms and are eligible to vote on acks=all writes and election.
An Apache Flink optimization for multi-terabyte streaming state: because RocksDB flushed SSTable files are immutable, each Chandy-Lamport checkpoint uploads only newly created SSTables since the previous checkpoint to S3/HDFS rather than copying the full state snapshot.
The foundational full-text search index mapping tokenized terms (dictionary) to sorted posting lists of document IDs, term frequencies, and token positions, enabling sub-millisecond boolean intersection and BM25 scoring.
An LLM serving scheduler that injects newly arrived requests and evicts completed sequences at every single token generation step rather than waiting for the longest sequence in a static batch to finish, boosting GPU throughput by 5x-10x.
A memory-compressed ANN vector index that partitions the vector space into Voronoi K-means centroids (IVF) and decomposes high-dimensional residual vectors into M sub-vectors quantized to 8-bit codebook IDs (PQ), compressing RAM by 16x-64x.
A black-box distributed systems verification methodology that injects nemesis faults (asymmetric partitions, clock skew, SIGSTOP pauses) while recording concurrent client operation histories to check for linearizability or serializability violations.
Lamping & Veach zero-memory O(ln N) consistent hashing algorithm that maps a 64-bit key to one of N numbered buckets with perfectly uniform balance and minimal key movement when N changes at the tail.
When all In-Sync Replicas (ISR) for a Kafka partition become unavailable, operators face a strict CAP choice: wait for an ISR member to recover (preserving durability) or enable unclean.leader.election.enable=true to elect an out-of-sync replica (sacrificing committed messages for availability).
An approximation showing that expected queueing wait time grows non-linearly with utilization (rho / (1 - rho)) and variance in arrival/service times, explaining why p99 tail latency explodes as CPU or disk utilization approaches 80-90%.
To protect etcd from thousands of kubelets and controllers opening direct watches, the Kubernetes kube-apiserver maintains an in-memory cyclic watch ring buffer and periodically emits synthetic BOOKMARK events advancing clients resourceVersion watermarks even when no objects match their filter.
The Kubernetes control-plane pattern where controllers watch etcd resource versions via a Watch/List Reflector into a local DeltaFIFO cache and drive actual cluster state toward desired spec state via idempotent level-triggered reconcile loops.
Lambda maintains dual codebases—a fast approximate stream layer and a periodic batch recomputation layer—whereas Kappa unifies all processing over a single replayable log engine (Kafka + Flink), handling historical backfills by re-reading retained log segments with increased parallelism.
A monotonically increasing scalar counter maintained by each process and piggybacked on messages (L(e) = max(L_local, L_msg) + 1) that captures the partial happens-before relation (a -> b implies L(a) < L(b)).
In Apache BookKeeper, the highest monotonically increasing entry ID confirmed written and acknowledged by a write quorum. Readers safely tail ledger entries up to LAC without reading uncommitted or speculative writes.
A conflict resolution policy that picks the update carrying the highest wall-clock timestamp. In distributed clusters with NTP clock drift, LWW silently drops causally later writes if they originate from a node with a slightly lagging physical clock.
In disaggregated LLM serving (Mooncake / vLLM), as each Transformer layer finishes computing its Prefill Key/Value tensors, those blocks are asynchronously streamed over GPUDirect RDMA to the target Decode node in parallel with the next layer compute, hiding transfer latency.
A traffic shaping algorithm modeled as a FIFO queue of capacity B that drains ("leaks") requests at a strictly constant rate r, smoothing bursty arrival traffic into a uniform downstream outflow.
The strongest recency and single-object consistency model. Operations appear to execute atomically at a discrete point in time between invocation and response, ensuring that once a write completes, all subsequent reads across any client observe that write or a later one.
A fundamental queuing theory theorem stating that the average concurrency L in a stable queuing system equals the long-term average arrival rate λ multiplied by the average latency W: L = λ * W.
An append-only storage architecture optimized for write-heavy workloads. Writes append to a sequential Write-Ahead Log (WAL) and an in-memory MemTable, which periodically flushes to immutable disk SSTables merged via background multi-way compaction.
Google software load balancer hashing algorithm that generates a prime-sized permutation lookup table to guarantee O(1) packet-to-backend mapping with minimal connection disruption during backend pool changes.
Intra-layer model parallelism that shards individual weight matrices column-wise and row-wise across GPUs within a single NVLink domain, requiring two All-Reduce synchronization collectives per Transformer layer.
A two-stage distributed web crawler scheduling architecture where Front Queues prioritize URLs by PageRank/freshness and Back Queues map 1:1 to individual target hostnames gated by a min-heap of robots.txt crawl-delay timestamps.
A persistent congestive collapse state where a transient trigger (e.g., a brief network blip) induces a positive feedback loop (retry storms, cache eviction thrashing, or slow-path fallback) that keeps the system broken even after external load returns to normal.
A sparse model architecture where a gating router activates only top-k experts per token across distributed GPUs via an All-to-All collective dispatch/combine, requiring auxiliary load-balancing loss or capacity factors to prevent hot-expert stragglers.
The ratio of achieved useful training throughput (excluding activation rematerialization overhead) to the theoretical peak hardware dense BF16/FP8 FLOP/s of the GPU cluster, typically 40%-60% on well-tuned frontier training runs.
A strictly increasing epoch or sequence number issued by a lock service (etcd/ZooKeeper) alongside every lease acquisition. Storage servers reject any write carrying a fencing token lower than the highest token seen, neutralizing zombie leaders paused by GC.
A high-throughput notification pipeline that decouples transactional triggers from provider delivery (APNs, FCM, SES, Twilio) using per-channel Kafka priority topics, Redis token-bucket rate limiters, device-token registry caches, and idempotent delivery receipts.
An architecture used by TiKV and CockroachDB that partitions a massive keyspace into contiguous 64MB-512MB key ranges, where each range forms its own independent Raft consensus group with coalesced heartbeats.
A global deployment topology where multiple cloud regions simultaneously accept read and write traffic using latency-based DNS/Anycast routing, resolving cross-region conflicts via CRDTs/HLCs or pinning home-region Raft leaders for GDPR data residency.
The spectrum of SaaS multi-tenancy: Silo (dedicated DB cluster per enterprise tenant), Bridge (shared cluster, separate schemas), and Pool (shared tables enforcing tenant_id isolation via PostgreSQL Row-Level Security policies and per-tenant token buckets).
A database concurrency control technique where writes create new immutable row versions rather than modifying data in place. Reads never block writes and writes never block reads under Snapshot Isolation.
A security model that assumes internal datacenter networks are hostile, requiring every service-to-service connection to cryptographically authenticate both client and server X.509 identities and encrypt traffic in transit.
Because MVCC updates append new row versions without overwriting old ones, a long-running uncommitted transaction pins the oldest active snapshot watermark (xmin), preventing PostgreSQL VACUUM or LSM compaction from reclaiming dead versions and causing table bloat.
NVIDIA Collective Communications Library algorithms: Ring All-Reduce achieves optimal bandwidth utilization for large tensors, while Double Binary Tree All-Reduce reduces latency from O(P) to O(log P) for small-to-medium payload sizes across multi-node clusters.
A distributed AI observability subsystem that records a ring buffer of in-flight collective operation sequence numbers, ranks, and CUDA stream states across GPUs so when a silent GPU hang or RoCE packet drop triggers a NCCL timeout, engineers can isolate the exact straggler rank.
Multi-socket server architecture where each CPU socket has local memory controllers; accessing RAM attached to a remote socket traverses the cross-socket interconnect (UPI/Infinity Fabric) at 1.5x-2x higher latency, requiring thread and buffer-pool NUMA pinning.
High-speed AI interconnect hierarchy: NVLink/NVSwitch provides 900 GB/s intra-node GPU-to-GPU memory fabric, while InfiniBand/RoCEv2 with GPUDirect RDMA transfers tensors directly between NICs and remote GPU HBM bypassing host CPU and PCIe copies.
Brendan Gregg visualization where x-axis width is proportional to stack-frame sample frequency (not time): On-CPU flame graphs sample running threads via perf_events to expose hot compute loops, while Off-CPU flame graphs trace scheduler sched_switch events to expose mutex lock contention, disk I/O waits, and network blocking.
A collaborative editing concurrency control technique that transforms positional index parameters of incoming remote operations against concurrent already-applied operations so all peers converge to identical document text.
The kernel-managed RAM cache of disk blocks. Databases often bypass the OS page cache using O_DIRECT to manage their own buffer pool eviction policies and avoid double-caching and unpredictable kernel writeback stalls.
An LLM serving memory allocation technique inspired by OS virtual memory paging. It partitions KV cache tensors into non-contiguous physical memory blocks, slashing KV memory fragmentation from 70% to under 4%.
An Envoy proxy resilience mechanism that ejects backend endpoints exhibiting consecutive 5xx errors or anomalous latency variance from the load-balancing pool, but disables ejection ("panic threshold", default 50%) if too many hosts fail simultaneously to avoid cascading overload on the survivors.
Lamport foundational asynchronous consensus protocol guaranteeing safety under arbitrary network delays and non-Byzantine crash failures via two-phase Prepare/Promise and Accept/Accepted quorums.
A failure detection algorithm that outputs a continuous scale of suspicion Φ rather than a binary up/down state. Calculated from historical heartbeat inter-arrival time distributions, allowing adaptive thresholding based on network conditions.
Inter-layer model parallelism that assigns contiguous blocks of Transformer layers to different GPU stages and schedules One-Forward-One-Backward (1F1B) micro-batches to minimize the idle pipeline bubble fraction (P - 1) / M.
A dual-tier feature store temporal join that matches historical training labels at timestamp T_label with the latest feature value recorded strictly at or before T_label, eliminating future data leakage (train-serve skew).
The database disaster-recovery architecture combining periodic full/incremental physical block snapshots in object storage with continuous streaming archival of WAL segments, allowing operators to restore cluster state to any exact microsecond prior to an accidental DROP TABLE.
A randomized load balancing algorithm that samples two candidate backends at random and routes the request to the one with lower active concurrency/EWMA latency, exponentially reducing max queue length from O(log N) to O(log log N).
A pessimistic concurrency mechanism (used in MySQL InnoDB under Repeatable Read/Serializable) that locks not only existing index records but also the open key intervals ("gaps") between B+ Tree entries, preventing concurrent phantom inserts and write skew.
A serving architecture that separates compute-bound prompt processing (Prefill) onto dedicated GPU pools from memory-bandwidth-bound single-token generation (Decode), transferring the computed KV cache over RDMA to prevent long prompts from spiking ITL.
When scaling reads via asynchronous read replicas, a client reading immediately after a write may hit a lagging replica and see stale state; solved by pinning the user session to the Primary for a short window or attaching the write LSN/HLC token so the replica waits until its replay catches up.
In point-to-point work queues (SQS), the time window during which a dequeued message is hidden from other workers. If the worker crashes before deleting the message or extending its lease heartbeat, the visibility timeout expires and the message is redelivered.
A multiplexed transport protocol built over UDP that integrates TLS 1.3 cryptographic handshakes (1-RTT / 0-RTT), connection migration across IP changes, and per-stream flow control without kernel TCP HoL blocking.
An LLM inference optimization that organizes PagedAttention KV-cache blocks into a reference-counted Radix tree keyed by token prefixes, allowing shared system prompts, few-shot examples, and multi-turn chat histories to skip redundant prefill computation.
A leader-based consensus algorithm designed for understandability. Raft decomposes distributed consensus into leader election, log replication, and commitment safety invariants across an odd-numbered quorum (N/2 + 1).
Safe cluster reconfiguration mechanisms in Raft that prevent two disjoint majorities from electing concurrent leaders during topology changes—either via a two-phase C_old,new joint quorum or by adding/removing one voter at a time.
The two core safety proofs of Raft: (1) if two logs contain an entry with the same index and term, they are byte-for-byte identical up to that index; and (2) once an entry is committed by a majority in term T, every valid leader elected in term > T is guaranteed to possess that entry.
A Raft protocol hardening extension where a partitioned follower must first win a majority Pre-Vote check (proving its log is up-to-date and current members have timed out their leader) before incrementing its term, preventing disruptive term inflation upon partition heal.
A distributed compute framework combining bottom-up decentralizedRaylet task scheduling with an Apache Arrow zero-copy shared-memory object store (Plasma) to orchestrate heterogeneous CPU data preprocessing, GPU training, and RLHF rollout actors.
A synchronization mechanism used heavily in the Linux kernel and high-throughput routing tables where readers access shared data structures without acquiring any locks or atomic counters, while writers publish updated copies and defer reclamation until all pre-existing readers complete a grace period.
The ratio of physical disk bytes read to serve a single logical read query. Uncompacted LSM-Trees exhibit higher read amplification across overlapping L0 SSTables, mitigated by per-SSTable Bloom filters.
Under Read Committed, each individual SQL statement takes a fresh MVCC snapshot (permitting Non-Repeatable Reads and Phantom Reads within the same transaction), whereas Repeatable Read / Snapshot Isolation pins a single snapshot across the entire transaction lifetime.
Two mechanisms for healing replica divergence in leaderless databases: synchronous/asynchronous Read Repair on stale quorum reads, and background Anti-Entropy exchanging cryptographic hash trees (Merkle trees) of key ranges.
Client-centric session guarantees ensuring that a user always sees their own submitted updates immediately (Read-Your-Writes) and never observes state revert to an older version when switching read replicas (Monotonic Reads).
Raft read optimizations that serve linearizable reads without appending a full log entry to disk—either by confirming leadership via a lightweight heartbeat quorum (ReadIndex) or relying on bounded clock-drift leader leases (LeaseRead).
A calibration-free hybrid search score merging formula (RRF_score(d) = sum 1 / (k + rank_i(d)), typically k = 60) that combines dense vector similarity rankings with sparse lexical BM25 rankings without requiring score distribution normalization.
A stateless consistent partitioning algorithm where a client computes hash(key, node_i) for all candidate nodes and routes to the node yielding the maximum hash score, achieving uniform distribution without maintaining a ring structure.
Operational safeguards during node decommissioning or partition rebalancing that cap background data streaming bandwidth (e.g., Kafka follower replication throttles or Cassandra compaction/stream throughput limits) so recovery traffic does not starve foreground p99 client queries.
A bandwidth-optimal collective communication algorithm for distributed GPU neural network training. GPUs form a logical ring exchanging tensor chunks in 2(P-1) steps with total data transferred independent of cluster size P.
A long-context training and prefill technique (for 128K-1M+ token sequences) that partitions the sequence dimension across P GPUs arranged in a logical ring, overlapping P2P KV-block communication with local FlashAttention block computation.
Post-training alignment pipelines: PPO orchestrates 4 concurrent models (Actor, Critic, Reference, Reward) alternating between autoregressive generation rollouts and gradient updates, while Direct Preference Optimization (DPO) optimizes policy weights directly over preference pairs.
A compressed hybrid bitmap index that partitions 32-bit integers into 65,536-element chunks stored dynamically as sorted 16-bit arrays, uncompressed 8KB bitsets, or run-length encoded (RLE) intervals for fast bitwise AND/OR intersections.
A hardware performance model plotting attainable FLOP/s against Arithmetic Intensity (FLOPs per byte transferred from HBM). Workloads below the hardware ridge point (like autoregressive LLM decode) are memory-bandwidth bound; workloads above it (prefill/GEMM) are compute bound.
Disaster recovery metrics: RPO measures the maximum age of committed data that may be lost during a regional catastrophe (governed by replication lag), while RTO measures the maximum elapsed time to restore service availability.
A multi-tenant LLM serving technique that keeps a single frozen base model in GPU HBM while dynamically paging thousands of lightweight Low-Rank Adaptation (LoRA) rank matrices (r = 8..64) into unified memory blocks and batching heterogeneous adapter requests viaSegmented Gather-Scatter GEMM.
Two Saga coordination topologies: Choreography relies on decentralized services reacting to domain events on a broker (simple for 2-3 steps, prone to cyclic event spaghetti at scale), while Orchestration uses a durable central state machine to command participants and trigger compensations.
A sequence of local database transactions coordinating distributed workflows without distributed locks. If a step fails, the saga executes compensating transactions backwards to restore eventual consistency.
A relational row-locking clause that allows concurrent worker threads polling a database task queue to immediately skip rows currently locked by other active transactions rather than blocking on lock contention.
Lamport consistency model requiring that all operations appear to execute in some single global sequential order that respects the program order of each individual client, but without requiring alignment to real-time wall clocks.
An optimistic serializability mechanism (used in PostgreSQL and CockroachDB) that runs transactions over MVCC snapshots while tracking rw-antidependency cycles in a conflict graph, aborting transactions that form dangerous structures.
An API authentication architecture where the API gateway or microservice validates stateless short-lived JSON Web Tokens (5-15 min TTL) locally using cached public keys from a JSON Web Key Set (JWKS) endpoint, avoiding a central database round-trip on every request.
In leaderless vector-clock stores (Dynamo/Riak), when two concurrent writes produce incomparable vector clocks, the database preserves both values as siblings and returns them to the application (or applies a CRDT merge) rather than silently dropping data via LWW.
A dimensionality-reduction fingerprinting technique where similar documents produce 64-bit hashes with small Hamming distances (<= 3 bits), enabling web crawlers to detect near-duplicate pages at billion-document scale.
Two LSM-Tree compaction trade-offs: Size-Tiered merges similarly sized SSTables (optimizing for low write amplification on write-heavy workloads, at the cost of 50% space amplification), while Leveled maintains disjoint key ranges per level (minimizing read and space amplification).
An operational reliability framework where Service Level Indicators (SLIs) measure quantitative user telemetry, Service Level Objectives (SLOs) set target thresholds (e.g., 99.95%), and the remaining 100% - SLO defines the Error Budget for velocity vs stability.
Rate-limiting algorithms that eliminate the 2x boundary-burst flaw of fixed time windows by interpolating the previous window request count weighted by the overlap percentage with the current window counter.
A Dynamo-style availability optimization where writes during a node outage are temporarily accepted by healthy non-owner stand-in nodes as "hints" and replayed back once the primary replica recovers (trading strict quorum linearizability for write availability).
An MVCC isolation level where each transaction reads from a consistent committed snapshot taken at its start timestamp and aborts on first-committer-wins write-write conflicts, but remains vulnerable to Write Skew anomalies across disjoint rows.
A coordination-free distributed ID generation scheme packing a 41-bit millisecond timestamp epoch offset, a 10-bit datacenter/worker ID, and a 12-bit per-millisecond sequence counter into a 64-bit integer that sorts chronologically in B+ Tree indexes.
An immutable, disk-resident file of key-value pairs sorted by key, paired with an index block and a Bloom filter. Multiple SSTables across levels are merged asynchronously via background compaction.
The ratio of total on-disk storage footprint (including obsolete row versions, tombstones, B-Tree page fragmentation, and compaction staging space) to the logical size of live keys.
In Apache Spark, Narrow transformations (map, filter) execute pipelined in-memory within a single stage, whereas Wide transformations (groupByKey, join) introduce stage boundaries requiring an all-to-all disk-persisted network Shuffle optimized by Catalyst/Tungsten.
An lossless inference acceleration technique where a small, fast draft model autoregressively proposes gamma candidate tokens that are verified in a single parallel forward pass by the target frontier model, achieving 2x-3x lower latency.
Secure Production Identity Framework for Everyone. Standardizes cryptographic identity URIs (spiffe://domain/ns/name/sa/user) embedded into X.509 certificates (SVIDs) for Zero Trust mutual TLS between microservices.
A catastrophic failure mode where a network partition causes two isolated sub-clusters to simultaneously believe they hold leadership, accepting conflicting writes that corrupt state upon partition heal. Prevented via strict majority quorums and fencing.
The real-time chat/presence delivery architecture where millions of persistent client WebSocket connections terminate on stateful gateway pods, and a partitioned Redis/Kafka routing table maps user_id to the owning gateway node for targeted message push.
The replication quorum rule requiring the write replica ack count W plus the read replica query count R to strictly exceed the replication factor N, guaranteeing at least one overlapping replica holds the latest write.
The gold-standard multi-object transactional isolation level combining Serializability (transactions appear to run one at a time with no concurrency anomalies) with Linearizability (transaction order respects real-time wall-clock completion order).
A pessimistic concurrency control protocol where transactions acquire shared (read) and exclusive (write) locks during execution and hold all locks until transaction commit or abort, preventing dirty reads, lost updates, and write skew.
A classic distributed lock failure mode where a client holding a time-bounded distributed lease experiences a Stop-The-World (STW) JVM/Go GC pause longer than the lease TTL; the lock service expires the lease and grants it to another worker before the paused process wakes up and writes.
Scalable Weakly-consistent Infection-style Process Group Membership Protocol combining constant-overhead randomized direct/indirect ping-req probing with piggybacked infection-style cluster membership dissemination.
Connection establishment overhead: TCP requires 1 RTT (SYN, SYN-ACK, ACK) before data transfer, and TLS 1.3 adds 1 RTT for Diffie-Hellman key exchange. SYN Cookies encode connection state cryptographically in the sequence number to defend against SYN flood queue exhaustion.
Dean & Barroso principle demonstrating that when a root request fans out to N parallel backend shards, the aggregate p99 latency is governed by the slowest single shard (1 - (1 - 0.01)^N), requiring hedged requests and canarying.
3NF eliminates data redundancy and update anomalies by ensuring every non-key attribute depends solely on the primary key; high-scale read systems selectively denormalize pre-joined views to avoid distributed cross-shard joins.
An extension of 2PC that inserts a Pre-Commit phase and timeouts to avoid blocking on coordinator crash in synchronous networks, but fails to preserve safety under asynchronous network partitions—motivating Paxos-Commit and Raft-backed 2PC instead.
An LSM compaction strategy tailored for immutable time-series telemetry that groups SSTables into discrete time buckets (e.g., 1 day) and drops entire expired SSTable files in O(1) via filesystem unlink once TTL elapses.
The hardware CPU cache translating virtual memory addresses to physical RAM page frames. Large database buffer pools and JVM heaps use 2MB/1GB HugePages instead of 4KB pages to drastically reduce TLB misses and multi-level page-table walks.
A rate limiting algorithm where tokens accumulate at a fixed refill rate r up to capacity B. Requests consume tokens and are throttled or dropped (HTTP 429) when the bucket is empty, accommodating bursts up to B.
An explicit deletion marker written in append-only storage engines (LSM-Trees) or replicated logs to mask older versions of a deleted key until background compaction garbage-collects expired versions after grace_seconds.
A proxy layer (PgBouncer, ProxySQL, Vitess VTGate) that maps thousands of ephemeral serverless/microservice client connections onto a small fixed pool of persistent database backend processes (typically 2x-4x CPU cores), avoiding OS process-per-connection context-switch collapse.
An architectural pattern guaranteeing at-least-once message publishing by inserting events into a database outbox table within the same ACID transaction as business mutations, subsequently tailed via Change Data Capture (CDC).
An application-level two-phase distributed transaction pattern where Phase 1 (Try) reserves business resources (e.g., placing a pending hold on inventory/funds) and Phase 2 executes an idempotent Confirm or Cancel.
The two primary LLM serving latency SLIs: TTFT measures queuing plus compute-bound prompt prefill duration before the first output token streams, while ITL (or TPOT) measures memory-bandwidth-bound step latency between consecutive generated tokens.
The three core stream processing window taxonomies: fixed non-overlapping intervals (Tumbling), fixed-duration overlapping intervals advancing by a slide step (Sliding), and dynamic activity-gap-delimited per-key intervals (Session).
An atomic commitment protocol coordinating distributed participants in two steps: Prepare (voting YES/NO) and Commit/Abort. Standard 2PC is a blocking protocol if the coordinator fails during the commit phase.
A dynamic gRPC streaming protocol used by Envoy proxy to discover listeners (LDS), routes (RDS), clusters (CDS), endpoints (EDS), and cryptographic certificates (SDS) without restarting processes.
Random 128-bit UUIDv4 primary keys scatter inserts uniformly across all B+ Tree leaf pages, causing 50% page fragmentation and catastrophic buffer-pool thrashing once the index exceeds RAM; time-prefixed UUIDv7 or Snowflake IDs append sequentially to the rightmost leaf page.
An array of logical clocks maintained across distributed nodes to capture causal order and detect concurrent conflicting updates without physical clock synchronization.
An AI gateway caching layer that embeds incoming user prompts and queries an ANN index for semantically equivalent historical prompts (cosine similarity >= 0.96), serving cached responses in < 10ms while scoping entries by model version and tenant ACLs.
Instead of assigning each physical server a single point on the consistent hash ring (which causes O(log N) load imbalance), assigning M = 128..256 virtual token positions per node reduces partition size standard deviation to ~1/sqrt(M) (~6%) and scatters rebuild load across many peers.
A distributed secondary index mapping table in Vitess that translates non-sharding key predicates (e.g., WHERE email = ?) to the owning Keyspace ID shard, avoiding expensive scatter-gather queries across all MySQL shards.
Distributed tracing propagates traceparent (128-bit trace-id, 64-bit parent-span-id, sampling flags) across RPC/Kafka headers. Unlike Head-Based sampling (which randomly decides at ingress), Tail-Based sampling buffers spans in collector memory to deterministically retain 100% of traces containing 5xx errors or p99 latency spikes.
A database storage engine optimization where a leader thread collects concurrent transaction commit requests waiting in a queue and flushes all of their WAL records in a single batched fsync() call, multiplying commit IOPS by 10x-50x without sacrificing ACID durability.
Real-time media routing architectures: an MCU decodes and mixes N participant video streams into a single composite stream (CPU-intensive), whereas an SFU inspects RTP headers and selectively forwards Simulcast/SVC spatial layers without transcoding, achieving sub-150ms latency.
The ratio of bytes physically written to underlying flash/disk storage to the logical bytes written by the application. Caused by WAL logging, page flushes, and multi-level LSM compaction.
An append-only durability log where every state mutation is sequentially flushed (fsync) to non-volatile storage before the corresponding in-memory data page or MemTable is considered committed, enabling crash recovery via redo/undo replay.
Write-through synchronously updates both cache and backing store before acknowledging the client; write-behind (write-back) acknowledges after updating the cache and asynchronously batches writes to storage, trading crash durability for write throughput.
Static, immutable probabilistic filters used in modern LSM-Tree SSTables (RocksDB) that construct a peeled hypergraph system of equations at compaction time to achieve 20-30% smaller memory footprints than standard Bloom filters.
A crash-fault-tolerant primary-backup consensus protocol used by Apache ZooKeeper that guarantees total FIFO order of state updates using 64-bit zxid identifiers composed of a 32-bit leader epoch and a 32-bit counter.
A memory-efficient distributed training paradigm that partitions optimizer states (ZeRO-1), gradients (ZeRO-2), and model parameters (ZeRO-3) across data-parallel GPUs without incurring model-parallel communication overhead.
A Linux kernel optimization used by Apache Kafka that transfers bytes directly from the OS page cache to the NIC DMA ring buffer without copying data into user-space memory or triggering redundant context switches.
Temporary ZooKeeper nodes tied to a client session heartbeat that enable scalable distributed locking: each contender creates an ephemeral sequential node and watches only the immediately preceding sequence number, avoiding a O(N^2) herd effect when the lock releases.