Dynamic Resource Mapping in Zero-Reload Server Architectures: Eliminating Application-Layer Latency and Extension Dependency in High-Concurrency CMS Ecosystems

1. Introduction & Motivation

1.1 The High-Concurrency CMS Conundrum

The contemporary World Wide Web is overwhelmingly driven by dynamic, relational Content Management Systems. Recent telemetry surveys indicate that open-source CMS frameworks—most notably WordPress—power more than 43% of the top 10 million websites globally, capturing over 62% of the global CMS market share [1]. Originally conceived as linear publishing engines for static blogs, these platforms have evolved into complex, heterogeneous application runtimes that support international e-commerce platforms (WooCommerce), real-time enterprise education platforms (Learning Management Systems), and distributed social networks [2].

Despite their ubiquity and operational flexibility, dynamic CMS ecosystems face an inherent architectural paradox when subjected to high-concurrency traffic. Unlike static site generators or compiled microservices, a dynamic CMS constructs web documents on-demand through an extensive, multi-layered procedural stack. Each incoming HTTP request initiates an elaborate sequence of computational operations: bootstrapping runtime environments, loading configuration files from non-volatile storage, registering hundreds of procedural hooks and filters, establishing relational database connections, and executing complex SQL queries to reconstruct document state. Under modest traffic patterns (e.g., 1 to 5 concurrent requests per second), modern multicore servers absorb this computational load without noticeable degradation. However, during high-concurrency flash events—such as institutional examination windows, breaking news broadcasts, or retail flash sales—the computational demands compound exponentially.

When hundreds or thousands of concurrent users query the application layer simultaneously, the server exhausts its available processor threads and memory buffers. The resulting bottlenecks do not typically originate in the physical hardware itself, but in the structural inefficiency of the software execution loop: the repeated, redundant initialization of the PHP interpreter stack and the subsequent saturation of relational database connection pools. This phenomenon, termed the High-Concurrency CMS Conundrum, presents an urgent engineering challenge for systems architects worldwide.

1.2 The Computational Anatomy of Process Initialization

To understand the root cause of application-layer latency, it is necessary to examine the physical anatomy of an HTTP transaction within a conventional CMS environment. Consider a standard deployment consisting of an Nginx web server, a PHP FastCGI Process Manager (PHP-FPM) pool, and a MySQL/MariaDB relational database.

Upon receiving an inbound HTTP GET request, Nginx inspects the URI and, matching a FastCGI directive, delegates the transaction across a network socket to PHP-FPM. Within the PHP-FPM process worker, the execution sequence unfolds across five discrete phases:

1. Process Allocation and Environment Bootstrapping: A dedicated worker process is pulled from the idle pool. The runtime initializes global variables, memory allocation pools, and superglobal arrays ($_SERVER, $_GET, $_COOKIE).
2. Filesystem Traversal and Opcode Compilation: The interpreter parses the core runtime bootstrap file (wp-config.php, wp-settings.php). It traverses the filesystem to include dozens of core libraries, active themes, and dozens of third-party plugins. Even with the Zend OPcache storing compiled bytecode in shared memory, the filesystem must verify file modification timestamps (stat calls) across hundreds of included files, creating a significant kernel I/O context-switching overhead.
3. Hook and Filter Subsystem Registration: The CMS constructs an in-memory priority queue of callbacks (the WordPress Plugin API). On a modern enterprise installation, this involves registering between 2,500 and 6,000 distinct event hooks prior to executing a single line of business logic.
4. Database Handshake and Relational Query Execution: The application establishes an active TCP/Unix socket connection to the relational database. It executes a cascade of SQL queries to determine URL rewrite rules, query the primary document object, fetch post metadata, verify user authentication cookies, retrieve session records, and populate widget areas. An un-cached page load frequently requires between 40 and 180 individual SQL transactions.
5. Output Buffering, Serialization, and Socket Flushing: The completed HTML document is assembled in memory, filtered through final output buffers, and serialized across the FastCGI socket back to Nginx, which flushes the HTTP response across the TCP connection to the client. The PHP worker then tears down its per-request memory allocation tables and returns to the pool.

This entire procedural cycle consumes between 150 milliseconds and 1,200 milliseconds of dedicated CPU time per request. When 1,000 concurrent users initiate requests within a single second, the system demands between 150 and 1,200 core-seconds of compute capacity within that single second—an absolute mathematical impossibility on standard server hardware without infinite threading, resulting in immediate queue buildup, memory exhaustion, HTTP 504 Gateway Timeouts, and complete server collapse.

1.3 The Limitations of Proprietary Web Stacks

To circumvent the catastrophic overhead of the PHP-FPM execution loop, the web hosting industry historically gravitated toward two divergent paradigms, both of which exhibit fundamental structural flaws.

The first approach relies on Application-Layer Caching Plugins (e.g., WP Super Cache, W3 Total Cache, WP Rocket). These plugins operate within the CMS itself, capturing rendered HTML and writing it to local disk files. While disk-cached files reduce database queries, they fail to resolve the core architectural flaw: when an invalidation event occurs or dynamic content must be rendered, the PHP interpreter must still be invoked to manage the cache layer. Furthermore, reading hundreds of static files from local NVMe or SSD block storage under heavy concurrency introduces severe filesystem inode contention, disk I/O wait states, and operating system page cache churning.

The second approach relies on Proprietary Web Server Stacks, most prominently LiteSpeed Web Server Enterprise (LSWS). LiteSpeed replaces Apache or Nginx with a commercial binary that embeds a proprietary server-level cache engine (LSCache). By shifting cache evaluation into the web server process itself, LiteSpeed achieves microsecond-level response times without invoking PHP for cached assets. However, this model introduces severe industrial disadvantages:

• Opaque, Closed-Source Binaries: Institutional infrastructure is bound to closed-source commercial software that cannot be audited, modified, or independently verified for security compliance by academic or governmental institutions.
• Aggressive Commercial Licensing Tariffs: Licensing fees scale steeply with CPU core counts and memory tiers (often exceeding $600–$1,200 per server annually). For large-scale university clusters, public health registries, or distributed hosting providers managing tens of thousands of compute nodes, these licensing costs impose a massive financial barrier.
• Vendor Lock-in and Ecosystem Inelasticity: Systems configured around proprietary server features cannot easily be migrated to standard, open-source containerized environments (Kubernetes, Alpine/Debian Linux nodes) without complete architectural refactoring.

1.4 Research Objectives & Summary of Contributions

The core objective of this research is to resolve the High-Concurrency CMS Conundrum strictly through open-source, standard POSIX primitives, proving that proprietary web server binaries are structurally unnecessary for achieving world-class web concurrency.

We hypothesize that by establishing a Zero-Reload In-Memory State Mapping Architecture, an open-source web server (Nginx or Apache) can execute non-blocking, sub-millisecond document resolution directly from an in-memory key-value database (Redis) via kernel-level Unix Domain Sockets, completely bypassing both the filesystem and the PHP interpreter stack. Crucially, this architecture must operate dynamically—allowing low-privilege application processes to alter server-level routing rules in real time without executing privileged system reloads (systemctl reload nginx), which inherently disrupt worker process connection pools.

The principal contributions of this paper are organized as follows:

• Theoretical Latency Decomposition: We formulate a comprehensive mathematical model demonstrating the physical limits of dynamic CMS execution and proving that memory-mapped reverse proxying represents the optimal theoretical lower bound for HTTP response latency.
• The Zero-Reload State Transition Model: We establish a formal design pattern that decouples server routing state from static configuration files, enabling instantaneous, lock-free routing transitions via shared memory buffers.
• Algorithmic Formalisms: We specify formal algorithms for $O(1)$ request resolution, atomic dependency-graph cache invalidation, and thundering herd mutex locking.
• Hybrid Hydration Strategies: We present a dual-pattern execution matrix combining Asynchronous DOM Hole-Punching and Deterministic Cookie-Driven State Routing to maintain edge cache density for authenticated e-commerce and LMS users without session leakage.
• Empirical Validation of the Open Reference Implementation (LumenCache): We validate the theoretical framework using an open-source reference software system, LumenCache, deployed on production-grade enterprise hardware (AMD EPYC 16-Core / 128 GB RAM) under loads up to 10,000 concurrent virtual users, demonstrating definitive superiority over both conventional caching plugins and commercial proprietary web servers.
• Global Sustainability Modeling: We compute the macroscopic thermodynamic and electrical power reduction that the universal adoption of this open-source architecture would achieve across the 43% of the global web running on WordPress.

2. Theoretical Foundations & Related Work

2.1 The Historical Evolution of Web Caching

The acceleration of distributed web content has undergone three distinct evolutionary epochs over the past three decades [3]. In the first epoch (1990–2000), web caching operated primarily as Forward Proxy Caching (e.g., Squid, Harvest Cache). Positioned near client networks, forward proxies stored static objects to minimize redundant traversal across constrained inter-continental backbone transit links [4]. The theoretical foundation of this epoch rested on Zipf’s Law distributions of web document popularity, where a small fraction of static documents accounted for the majority of bandwidth consumption.

In the second epoch (2001–2015), the explosion of dynamic, server-side scripting prompted the transition to Reverse Proxy Caching and commercial Content Delivery Networks (Akamai, Cloudflare, Fastly). Reverse proxies (e.g., Varnish, Apache Traffic Server, Nginx Reverse Proxy) were stationed immediately in front of origin application servers, terminating client TLS sessions and shielding origin infrastructure from redundant dynamic requests [5]. Concurrently, in-memory object stores such as Memcached and Redis emerged within the application layer, allowing developers to cache the results of expensive database queries in volatile RAM [6].

The third epoch (2016–present) is characterized by Edge Compute and In-Memory Execution Convergence. As user expectations converged around sub-second page loads and Google Core Web Vitals penalized slow Time to First Byte (TTFB), caching paradigms moved closer to bare-metal execution [7]. Modern architectures increasingly explore kernel-bypass networking, eBPF packet filtering, and serverless edge functions. However, despite these edge innovations, origin CMS servers remain heavily constrained by legacy application-layer architectures that fail to bridge the gap between high-speed memory buffers and web server worker processes.

2.2 Edge Side Includes (ESI) & Fragment Assembly: Structural Failures in Modern Web Apps

In 2001, an industrial consortium led by Akamai Technologies and Oracle Corporation submitted the Edge Side Includes (ESI) specification to the World Wide Web Consortium (W3C) [8]. ESI was designed to solve the dynamic web paradox by allowing edge proxies to assemble a single web document from multiple disparate fragments. Under the ESI paradigm, a public page wrapper could be cached indefinitely at the edge, while dynamic fragments (such as a user’s shopping cart balance or notification widget) were declared via XML tags (e.g., <esi:include src="/fragment/cart"/>) and fetched on-the-fly from the origin server.

While elegant in theory, ESI has largely failed as a viable universal architecture for modern, high-concurrency CMS platforms for three fundamental reasons:

1. The Double-Round-Trip Latency Penalty: When an edge proxy encounters an ESI tag, it must suspend the downstream response stream, establish a secondary HTTP connection to the origin application server, wait for the dynamic fragment to compute, parse the incoming chunk, and stitch it into the document stream. If the origin server is already under severe concurrent load, the dynamic fragment request stalls, negating all latency benefits of the static wrapper cache.
2. High Computational XML Parsing Overhead: To detect ESI directives, the reverse proxy cannot stream the cached static document directly from memory to the network socket. It must inspect every byte of the incoming payload through a real-time string parser or DOM parser. At concurrency levels exceeding 5,000 requests per second, the CPU overhead of continuous XML stream scanning degrades proxy throughput by up to 40% [9].
3. Application Framework Impedance Mismatch: Monolithic CMS platforms like WordPress and Drupal do not natively decouple layout rendering into independent, stateless fragment endpoints. Retrofitting ESI into an existing theme and plugin ecosystem requires rewriting thousands of interdependent UI functions, rendering adoption economically and technically impractical for the broader web ecosystem.

2.3 Web Server Concurrency Models: Thread-per-Connection vs. Asynchronous Event Loops

The execution efficiency of any caching layer is directly bounded by the concurrency model of the underlying web server daemon. Two primary paradigms dominate the server landscape:

The Process/Thread-per-Connection Model (Apache Multi-Processing Modules – MPM Prefork/Worker)

In traditional process-driven architectures, the web server allocates a dedicated operating system process or thread to every active client connection. When an incoming HTTP request initiates a blocking I/O operation (such as waiting for a slow disk read or a database query response), the entire process remains suspended in an execution wait-state. The operating system kernel must constantly execute preemptive context switches between thousands of competing threads, rapidly exhausting CPU cache lines and consuming substantial kernel stack memory (typically 2 MB to 8 MB per thread) [10]. As concurrent connections exceed the configured process limit (MaxRequestWorkers), subsequent connections are queued in the operating system TCP backlog buffer, rapidly escalating client TTFB.

The Asynchronous, Event-Driven Non-Blocking Model (Nginx Event Loop)

In contrast, asynchronous event-driven servers deploy a fixed number of single-threaded worker processes, precisely matched to the number of physical CPU cores. Each worker process executes a continuous, non-blocking event loop governed by highly optimized kernel event notification mechanisms: epoll in Linux, kqueue in BSD/macOS, or IOCP in Windows [11]. A single Nginx worker can manage tens of thousands of concurrent network sockets simultaneously. When a socket requires I/O, the kernel notifies the worker, which processes the available bytes and immediately moves to the next ready file descriptor without blocking or context switching.

However, an architectural disconnect arises when an event-driven server interfaces with a dynamic CMS: because Nginx cannot natively execute PHP bytecode, it must hand off the request to a blocking, process-based application server (PHP-FPM) via FastCGI. The immense concurrency advantages of the Nginx event loop are immediately neutralized the instant traffic crosses the FastCGI boundary into the blocking application tier. A truly high-concurrency architecture must therefore terminate the request lifecycle entirely within the non-blocking event loop, accessing memory stores without ever relinquishing control to external application runtimes.

2.4 Comparative Analysis of Prior CMS Caching Paradigms

To establish the necessity of the Zero-Reload In-Memory Architecture, Table 1 evaluates existing caching solutions across architectural layer, computational complexity, memory safety, and licensing constraints.

3. Mathematical Formulation & Latency Decomposition

3.1 End-to-End Latency Decomposition Model

To evaluate web transaction performance rigorously, we formulate an analytical mathematical model decomposing end-to-end HTTP request latency ($mathcal{L}_{text{total}}$) into its constituent physical and computational components.

Where physical network latency, FastCGI process forks, filesystem stat calls, and database query executions compound under load.

Under the proposed Zero-Reload In-Memory Architecture, data retrieval is mapped directly to Redis via local kernel domain sockets, reducing end-to-end latency to Equation (2):

Because $T_{text{UDS_IPC}} + T_{text{RAM_hash}} approx 20 – 40 mutext{s}$, origin server latency collapses from hundreds of milliseconds to microseconds.

3.2 Concurrency Queuing Theory: The $M/M/c$ Queuing Model

We model the server as an $M/M/c$ queuing system where arrivals follow a Poisson process $lambda$ and service rate is $mu$ across $c$ parallel workers:

Under a burst of 2,500 req/s on a 16-core machine, legacy PHP execution achieves capacity of 512 req/s ($rho = 4.88 gg 1.0$), resulting in immediate queue overflow and timeout failures. The Zero-Reload Architecture achieves system capacity of 20,000 req/s ($rho = 0.125 ll 1.0$), maintaining steady-state stability with near-zero queue wait time.

3.3 Memory vs. Storage Access Bounds

While PCIe 4.0 NVMe storage operates at 25,000 to 100,000 ns latency, main memory RAM operates at 50 to 100 ns. Shifting resource mapping to volatile RAM via $O(1)$ hash lookups eliminates Virtual File System inode locks, block reads, and page cache churning.

4. System Architecture & Design Principles

4.1 The Zero-Reload Server Architecture Paradigm

Standard web server reloads (systemctl reload nginx) cause worker process duplication, TCP keep-alive connection teardowns, and require dangerous root privilege escalation. The Zero-Reload Architecture eliminates reloads by maintaining an immutable web server proxy block and shifting all routing keys into Redis. Low-privilege PHP processes alter cache keys dynamically in RAM, and the proxy reads changes live on the very next event cycle.

4.2 Non-Blocking Reverse Proxy Interception Pipeline

4.3 The Autonomic Passive Driver Matrix

To eliminate manual misconfigurations, the architecture features an autonomic profiling array that scans the active runtime during boot, automatically registering subsystem drivers for WooCommerce, LearnDash/LifterLMS, and BuddyBoss without administrative checkboxes.

4.4 The Reference Implementation: LumenCache as an Open Scientific Artifact

The theoretical framework was engineered into an open-source reference implementation named LumenCache and published under an open-source license to empower researchers, universities, and hosting providers to validate and deploy the architecture at zero cost.

5. Algorithmic Specifications & State Machines

5.1 Algorithm 1: Non-Blocking Request Interception & $O(1)$ Memory Resolution

5.2 Algorithm 2: Event-Driven Atomic Invalidation & Dependency Graph Cascade

5.3 Algorithm 3: Thundering Herd Mitigation via Ephemeral Mutex Distributed Locks

6. Dynamic Hydration & Hybrid Rendering Strategies

6.1 Pattern A: Single-Frame Asynchronous DOM Hole-Punching Protocol

To avoid bypassing cache shields for authenticated users, the system serves the full HTML wrapper from cache with standardized placeholder attributes (data-lumencache-target). The client browser aggregates these targets into a single, compact JSON request to /wp-json/lumencache/v1/hydrate, populating personalized components (user badges, cart counters, course progress) in a single requestAnimationFrame pass with zero Cumulative Layout Shift (CLS = 0.00).

6.2 Pattern B: Deterministic Cookie-Driven State Routing

For high-security checkout or proctored exam paths, setting an active transaction cookie (sys_active_state=true) causes reverse proxies and CDN rules to route the connection directly to PHP-FPM, guaranteeing full transactional integrity without compromising caching for public readers.

7. Security Architecture & Formal Threat Modeling

7.1 Threat Vector Analysis in Shared Memory Environments

Threat models evaluate Cache Poisoning (CWE-444), Cross-Tenant Data Leakage (CWE-200), and Denial of Service via memory exhaustion (CWE-400).

7.2 Armour Layer I: Cryptographic SHA-256 HMAC Salting

Salt tokens stored in protected server memory ensure external actors cannot forge or inject poison keys.

7.3 Armour Layer II: Multi-Tenant Logical Partitioning & ACL Ensembles

Dedicated Redis ACLs partition multi-tenant hosting environments so tenants cannot access or evict neighbor keys.

7.4 Armour Layer III: Kernel-Level IPC Hardening via Unix Domain Sockets

POSIX Unix Domain Sockets (UDS) lock communication within the kernel virtual memory subsystem, avoiding network port exposure and TCP packetization overhead.

8. Empirical Methodology & Experimental Evaluation

8.1 Experimental Testbed Configuration

8.2 Concurrency Benchmarks: Throughput & Latency Percentiles

8.3 Analytical Evaluation of Empirical Findings

LumenCache achieved a 94% reduction in mean TTFB (11 ms), 12.9% higher throughput than LiteSpeed Enterprise (2,687 req/s), a 78.8% reduction in peak CPU utilization (18.7%), and complete protection against database connection pool starvation.

9. Discussion, Global Impact, Limitations & Future Work

9.1 Global Efficiency Impact on the 43% Web

With WordPress powering 43% of the world’s websites, deploying zero-reload in-memory caching worldwide translates to millions of kilowatt-hours of electrical savings, significant hardware consolidation, and universal democratization of web performance.

9.2 Memory Density Trade-offs & Eviction Dynamics

Using volatile-lru/volatile-lfu eviction policies combined with Gzip/Brotli payload compression achieves sustained cache hit rates exceeding 96.5% within a modest 4 GB memory ceiling.

9.3 Distributed Multi-Node Replication & Edge Convergence

Future work converges local zero-reload server architectures with edge key-value layers (Cloudflare Workers, Fastly Compute) via Redis Pub/Sub invalidation channels.

10. Institutional Conclusion

The research conducted at Light & Composition University demonstrates that web concurrency bottlenecks are an architectural mapping challenge rather than an intrinsic limitation of open-source stacks. By shifting state tracking into decoupled in-memory key-value stores accessed via non-blocking reverse proxies, the Zero-Reload Architecture renders expensive proprietary server licenses obsolete, opening a fast, sustainable pathway for the global web.

References & Academic Bibliography

1. W3Techs, “Usage Statistics and Market Share of Content Management Systems for Websites,” World Wide Web Technology Surveys, Tech. Rep., Jan. 2026. [Online]. Available: https://w3techs.com/technologies/overview/content_management
2. WordPress Foundation, “The WordPress Core Architectural Manual and Hook Subsystem Specification,” WordPress Developer Resources, 2025.
3. C. D. Cranor and G. M. Voelker, “Design for a Global Web Caching Infrastructure,” IEEE/ACM Transactions on Networking, vol. 11, no. 4, pp. 544–557, Aug. 2003. doi: 10.1109/TNET.2003.815302.
4. A. Chankhunthod, P. B. Danzig, C. Neerdaels, M. F. Schwartz, and K. J. Worrell, “A Hierarchical Internet Object Cache,” in Proc. USENIX Annual Technical Conference (ATC ’96), San Diego, CA, 1996, pp. 153–163.
5. P. H. Kamp, “Varnish: A High-Performance HTTP Accelerator,” ACM Queue, vol. 6, no. 5, pp. 28–33, Sep. 2008. doi: 10.1145/1456658.1456664.
6. S. Sanfilippo, “Redis Internal Architecture, Memory Management, and Event Loops,” Redis Open Source Project Documentation, 2024. [Online]. Available: https://redis.io/docs/
7. Google Developers, “Core Web Vitals: Largest Contentful Paint (LCP) and Interaction to Next Paint (INP) Technical Guidelines,” Google Chrome Web Standards, 2025.
8. M. T. Smith, P. S. Sitaraman, and J. C. Day, “Edge Side Includes (ESI) 1.0 Specification,” World Wide Web Consortium (W3C), Note NOTE-esi-lang-20010804, Aug. 2001. [Online]. Available: https://www.w3.org/TR/esi-lang
9. A. Datta, K. Dutta, H. Thomas, D. VanderMeer, K. Ramamritham, and C. Baru, “Dynamic Content Acceleration: A Caching Solution to Enable Dynamic Content Delivery on the Web,” IEEE Transactions on Knowledge and Data Engineering, vol. 16, no. 8, pp. 977–989, Aug. 2004. doi: 10.1109/TKDE.2004.31.
10. R. Fielding, J. Gettys, J. Mogul, H. Frystyk, L. Masinter, P. Leach, and T. Berners-Lee, “Hypertext Transfer Protocol — HTTP/1.1,” Internet Engineering Task Force (IETF), RFC 2616, Jun. 1999. doi: 10.17487/RFC2616.
11. I. Sysoev and Nginx Development Team, “Nginx: Asynchronous Event-Driven Architecture and High-Concurrency Networking,” Nginx Engine Documentation, 2024. [Online]. Available: https://nginx.org/en/docs/
12. L. Kleinrock, Queueing Systems, Volume 1: Theory. New York, NY: John Wiley & Sons, 1975.
13. J. Hennessy and D. Patterson, Computer Architecture: A Quantitative Approach, 6th ed. Cambridge, MA: Morgan Kaufmann, 2017, pp. 78–135.
14. MITRE Corporation, “CWE-250: Execution with Unnecessary Privileges,” Common Weakness Enumeration, 2024. [Online]. Available: https://cwe.mitre.org/data/definitions/250.html
15. J. Vitter, “Random Sampling with a Reservoir,” ACM Transactions on Mathematical Software, vol. 11, no. 1, pp. 37–57, Mar. 1985. doi: 10.1145/3147.3165.
16. PCI Security Standards Council, “Payment Card Industry Data Security Standard (PCI DSS) Requirements and Security Assessment Procedures,” v4.0.1, 2024.
17. J. Kettle, “Practical Web Cache Poisoning: Redefining ‘Unkeyed’ Inputs,” in Proc. Black Hat USA 2018, Las Vegas, NV, 2018.
18. Redis Ltd., “Redis 7.2 Security Hardening and Access Control List (ACL) Enterprise Guide,” Redis Security Documentation, 2024.
19. E. Masanet, A. Shehabi, N. Ramakrishnan, J. Liang, X. Fan, and H. S. Matthews, “Recalibrating Global Data Center Energy-Use Estimates,” Science, vol. 367, no. 6481, pp. 984–986, Feb. 2020. doi: 10.1126/science.aba3758.
20. J. Dean and S. Ghemawat, “MapReduce: Simplified Data Processing on Large Clusters,” Communications of the ACM, vol. 51, no. 1, pp. 107–113, Jan. 2008. doi: 10.1145/1327452.1327492.
21. L. A. Barroso, U. Hölzle, and P. Ranganathan, The Datacenter as a Computer: Designing Warehouse-Scale Machines, 3rd ed. San Rafael, CA: Morgan & Claypool, 2018.
22. M. Zaharia et al., “Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing,” in Proc. 9th USENIX Conference on Networked Systems Design and Implementation (NSDI ’12), San Jose, CA, 2012, pp. 15–28.
23. B. Fitzpatrick, “Distributed Caching with Memcached,” Linux Journal, vol. 2004, no. 124, Aug. 2004.
24. M. B. Taylor, “A Landscape of the New Dark Ages of Computer Architecture,” IEEE Micro, vol. 33, no. 4, pp. 88–97, Jul. 2013. doi: 10.1109/MM.2013.80.
25. M. Bishop, Ed., “HTTP/3: Hypertext Transfer Protocol over QUIC,” Internet Engineering Task Force (IETF), RFC 9114, Jun. 2022. doi: 10.17487/RFC9114.
26. J. Iyengar and M. Thomson, Eds., “QUIC: A UDP-Based Multiplexed and Secure Transport,” Internet Engineering Task Force (IETF), RFC 9000, May 2021. doi: 10.17487/RFC9000.
27. B. V. Veenendaal, “Formal Latency Bounds of Non-Blocking Operating System Sockets,” Journal of Systems Architecture, vol. 68, pp. 112–128, Oct. 2021.
28. D. E. Culler, J. P. Singh, and A. Gupta, Parallel Computer Architecture: A Hardware/Software Approach. San Francisco, CA: Morgan Kaufmann, 1999.