Pith. sign in

REVIEW 4 major objections 6 minor 61 references

Scaling Unmodified Multithreaded Applications with Elastic CXL-based Distributed Shared Memory

T0 review · 4 major / 6 minor · reviewed 2026-08-01 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read xDSM shows a CXL-connected cluster can run unmodified multithreaded programs by sharing every memory segment and varying page size on the fly.

desk verdict Plausible design, honest but limited evidence: the full-space cross-OS claim is asserted, not tested, and the 1.5–2.2× numbers rest on single-OS NUMA emulation. read the letter →

arxiv 2607.15569 v1 pith:BOK2IT7L submitted 2026-07-17 cs.OS

Guowei Liu , Kang Chen , Laiping Zhao , Yiming Li , Hanwen Liu , Chen Peng , Yichi Chen , Sheng Chen
show 2 more authors
Zhiyuan Su Wenyu Qu
This is my paper · ORCID
classification cs.OS
keywords distributedsharedmemoryCXLelasticpagegranularityplacementfull-spacesharingmultithreadedprogramslatencyhistogramtiering
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper presents xDSM, a distributed shared memory system that lets ordinary pthread programs run unchanged across CXL-connected machines. It mounts three challenges that earlier DSM systems left open: share every memory segment (not just heap), replace static page placement with a latency-driven policy that balances data between local DRAM and CXL memory, and manage memory at variable granularity from 4 KB to 2 MB to cut page-fault overhead while avoiding false sharing. Evaluated across five benchmarks and 15 system configurations, xDSM reports 1.5x to 2.2x speedups over CXL-only execution, 1.1x to 2.2x over state-of-the-art hybrid DSMs, and near-linear scaling from 1 to 4 nodes. A sympathetic reader can care because it promises to scale existing multithreaded applications across machines without rewriting them into message passing or manually partitioning data.

What carries the argument

The central object is the elastic page: a variable-sized unit from 4 KB to 2 MB that the runtime forms by coalescing contiguous base pages that share the same accessors and consistency state, and that it splits on write faults. It carries metadata, fault resolution, and migration, so it determines the system's performance. Three mechanisms support it: VMA-anchored page transfers, which update only page table entries and leave the VMA pointing at the CXL backing store, making fast-path migration cheap; exp-binned latency histograms with P90-bin alignment and gap-proportional, asymmetric migration volume, which drive placement by measured latency rather than static rules; and the xdsm_database

What would settle it

Run the same five benchmarks on a genuine CXL 3.0 multi-node system with 4 nodes, comparing xDSM against CXL-only and a fixed-granularity hybrid. If xDSM's advantage over CXL-only drops below about 1.1x, or if the measured page-fault processing time does not drop and amortize as the paper assumes, the central claim would be falsified.

Watch

Extended reading notes

Core claim

The paper's central claim: an OS-runtime co-design can turn CXL shared memory into a full-space DSM that runs unmodified pthread programs. xDSM maps the entire application layout to shared CXL memory and assigns disjoint virtual ranges per node, so globals, statics, heap, and stack are shared. Placement follows latency equilibrium: sampled latencies go into exponentially scaled bins, and pages migrate between local DRAM and CXL in proportion to the 90th-percentile bin gap, with aggressive promotion and throttled demotion. The management unit is an elastic page that coalesces contiguous base pages with matched accessors and consistency state, and splits on write faults. The author's claim: th

Load-bearing premise

The evaluation assumes that four NUMA domains of a single server with a CXL 1.1 memory expander behave like a real CXL 3.0 multi-node cluster; if switch latencies or back-invalidation coherence overheads differ on genuine hardware, the reported speedups may not hold.

Editorial extensions

If this is right

  • Unmodified pthread programs, including their global and static variables, can execute across CXL-connected machines with no code rewriting.
  • Latency-driven placement keeps both local DRAM and CXL memory working, giving read-shared workloads a path around the latency penalty of placing all shared data on CXL.
  • Elastic pages amortize page-fault costs by batching up to 512 contiguous pages per fault, which yields faster warm-up and steadier throughput than fixed 4 KB pages.
  • Workloads larger than the aggregate local DRAM of all nodes become runnable, since CXL memory serves as a shared overflow tier.
  • In the paper's trace-driven LLM inference test, the design raises goodput by 1.13x over a fixed-page hybrid and 1.91x over CXL-only execution.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If real CXL 3.0 multi-node deployments present higher remote latency than the NUMA emulation used here, as the paper itself notes, the benefit of promoting hot pages locally should grow rather than shrink, but the 1.5x-2.2x numbers are not guaranteed to transfer intact.
  • A natural test outside the DSM setting is to bolt the gap-proportional P90-bin migration policy onto an ordinary two-tier memory manager and measure whether it beats frequency-based promotion on real CXL hardware.
  • The elastic-page idea could generalize to other coherence protocols or to object-granularity DSM: the same coalesce-on-quiet/split-on-write rule may reduce protocol traffic in non-CXL contexts as well.
  • The design assumes the shared metadata in CXL memory is trusted; before multi-tenant or untrusted deployments, that state needs hardware-enforced protection, which the paper leaves to future work.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. xDSM is a CXL-based distributed shared memory system that aims to run unmodified multithreaded (pthread) applications across multiple nodes. The paper makes three architectural claims: (1) a full-space shared execution environment that shares .text/.data/.bss/heap/stack without code modification; (2) a latency-driven dynamic placement policy based on exponentially binned latency histograms and P90-bin alignment; and (3) elastic page management that coalesces and splits pages between 4 KB and 2 MB to amortize page-fault costs and avoid false sharing. The evaluation uses four NUMA domains of a single AMD EPYC server with a CXL 1.1 Type-3 memory expander, compares 15 configurations across five benchmarks plus an LLM inference workload, and reports speedups of 1.5–2.2× over CXL-only baselines, 1.1–2.2× over hybrid DSMs, and near-linear to superlinear scaling.

Significance. If the claims hold, xDSM would be a substantial advance: it addresses three real limitations of existing CXL-based DSMs—heap-only sharing, static page placement, and fixed page granularity—with a coherent OS-runtime co-design. The evaluation is broad and thoughtful: five benchmarks with distinct access patterns, 15 system configurations, a dynamic MoE/LLM workload with SLA-based goodput, and comparisons to Memtis+, Colloid+, and Alto+Colloid+. The implementation effort is also significant (~23,800 LOC for xDSM plus ~8,300 LOC for comparison systems). However, the central multi-node, cross-OS capability is never exercised: the four "nodes" are NUMA domains of a single Linux instance, so the headline claim of transparently scaling unmodified applications across independent OSes rests on an untested functional assumption. In addition, the quantitative results are reported from single runs with no error bars or repetition counts. These issues are load-bearing for the paper's main contributions, so a major revision is required.

major comments (4)
  1. [§8.1, §4, §7] The evaluation never exercises the central claim of transparent full-space sharing across independent compute nodes. As stated in §8.1, the four "nodes" are four NUMA domains of one AMD EPYC system running a single Linux instance; all application threads share one address space and one kernel. The startup path in §7 reads /proc/self/maps and uses process_vm_readv, which are single-OS, single-process operations; the "globally coordinated address space" of §4.1 and the VMA-anchored transfers of §4.2 are local PTE operations. Cross-OS issues — independent page tables and VMAs per node, remote thread dispatch, inter-node TLB invalidation, distributed VMA anchoring, cross-OS synchronization of global mappings — are never exercised. The 1.5–2.2× and near-linear scaling claims therefore rest on an untested functional assumption, not merely on a latency-matching difference. Please provide a mult
  2. [§5.1, Eq. (1), Figure 2] Equation (1) as printed is inconsistent with the bin mapping shown in Figure 2. For ℓ in [512,1023], ⌊log2ℓ⌋ = 9; if the first term means 2^{⌊log2ℓ⌋−4}, the bin index is 32, not 10 as shown in the figure; if it means 2(⌊log2ℓ⌋−4), the expression is missing required parentheses. The text describes intervals [2^k, 2^{k+1}) bisected into two bins, but the printed formula lacks the floor/offset structure needed to produce indices 10 and 11 for [512,767] and [768,1023]. Since P90-bin alignment is the core of the placement policy, this must be corrected and the formula made unambiguous.
  3. [§8.3–§8.7, Figures 3–8] No repetition counts or error bars are reported for any end-to-end measurement. Figures 3–8 each show a single trajectory or a single bar per configuration, and the speedup ranges in the abstract and §1 (1.5×–2.2×, 1.1×–2.2×, 5.1×) appear to be computed from these single runs. For runtime measurements on shared hardware, and especially for claims of superlinear scaling, at least 3–5 repetitions with variance (or a justification that results are deterministic) are needed to establish that the reported differences are not noise.
  4. [§8.1, §2.1] The hardware does not match the coherence model assumed by the design. The design in §2.1 relies on CXL 3.0 multi-node BISnp for hardware-managed cache coherence. The evaluation uses a CXL 1.1 Type-3 expander attached to one host; CXL 1.1 does not implement multi-host BISnp. The statement that "CXL 1.1 supports hardware cache coherence within a single machine, satisfying the requirements of our systems" conflates single-host CPU cache coherence with the multi-node coherence assumed by the design. The measured overheads therefore include whatever software consistency the system implements, not the BISnp hardware path. Please clarify what coherence is actually provided by the experimental setup and how it maps onto the assumed CXL 3.0 substrate.
minor comments (6)
  1. [§1] Typo in contributions bullet: "three fundermental limitations" should be "three fundamental limitations."
  2. [§3.1] Typo in "up to 2,MB": should be "2 MB."
  3. [§5.1] The definition of P90 bin as "the lowest index encompassing at least 90% of samples" should specify whether accumulation is from the low end, how ties are broken, and what happens when samples are split across the maximum bin.
  4. [§8.6] The description of Memtis+, Colloid+, and Alto+Colloid+ says they were "adapted to our batch migration runtime" but gives no details of the adaptation. Without this, the reader cannot assess whether the comparison is fair or whether the adaptations disadvantage the baselines.
  5. [§9] Typo: "eptp_database" should be "xdsm_database."
  6. [§7] The paper says "All source code will be open-sourced upon publication," but no artifact or DOI is provided. Given that the evaluation is the main evidence, an artifact appendix with code and configuration scripts would improve reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: xDSM's claims are supported by an implemented system and measured evaluation; its main weaknesses are external-validity limitations, not derivation-by-construction.

full rationale

xDSM is a systems paper whose results come from an implementation and benchmark evaluation, not from a predictive derivation. Checking the six circularity patterns: (1) the placement policy (Eqs. 1-2, §5) is a control heuristic; α=2/4 and P90-bin alignment are tuning/control choices, and no parameter is fitted to data and then renamed as a prediction. The speedups are measured outcomes, not consequences of the policy equation by construction. (2) There is no load-bearing self-citation: references such as TrEnv [16] are related work, while Firework [32], Memtis [25], Colloid+ [51], and Alto+Colloid+ [31] are external baselines. No uniqueness theorem or ansatz is imported from the authors' prior work. (3) 'Full-space sharing' is not a renaming of a known empirical pattern; it is an implemented mechanism (coordinated addressing, VMA anchoring, thread dispatch). The genuine weakness is evaluation validity: §8.1 emulates four nodes with four NUMA domains of a single AMD EPYC server running one Linux OS, and §9 concedes that CXL 3.0 switch latencies are absent. In one OS, all threads already share a single address space, so cross-OS full-space transparency is not exercised, and page-fault/TLB-shootdown costs are single-OS costs. This is a threat to external validity and missing support, not a circular reduction: no result in the paper equals its own input by an equation or by a self-citation chain. Therefore the circularity score is 0.

Assumptions & free parameters 5 free parameters · 5 assumptions · 2 invented entities

The central claims rest on a small set of hand-tuned parameters (α_promote, α_demote, tick duration, sampling rate, P90 threshold) and on the assumption that NUMA emulation captures CXL 3.0 multi-node behavior. There are no invented physical entities. The design also assumes Linux VMA/page-table semantics and a trusted shared metadata database, both stated in the paper.

free parameters (5)
  • α_promote = 2
    Equation (2) volume scaling constant for promotion (§5.3). Hand-chosen to make promotion aggressive; no sensitivity analysis is reported, so the migration volume and hence the reported speedups depend on this choice.
  • α_demote = 4
    Equation (2) volume scaling constant for demotion (§5.3). Hand-chosen to throttle eviction; no sensitivity analysis is reported. The asymmetric pacing is central to the placement policy's stability claims.
  • Epoch/tick duration = 1 s
    Fixed-duration sampling window (§3.1). The adaptation speed of the placement policy depends on this; no sweep over tick durations is reported.
  • Sampling rate = 1 sample per 20,000 macro-ops
    Hardware sampling interval (§3.1). Determines histogram accuracy and migration responsiveness; no sensitivity analysis is provided.
  • P90 threshold = 90th percentile
    Defines the latency equilibrium criterion in §5.1. The choice of 90% instead of another percentile is not justified experimentally.
assumptions (5)
  • domain assumption Four NUMA nodes on a single Linux host faithfully emulate four independent CXL-connected compute nodes with hardware cache coherence.
    Section 8.1 uses NPS2 NUMA domains and a shared CXL 1.1 DAX device instead of a CXL 3.0 multi-headed device with BISnp. All end-to-end performance claims are measured in this emulation.
  • domain assumption CXL access latency is 200–400 ns and the page-fault software pipeline costs 24–30 μs, making page-fault overhead the dominant bottleneck.
    Motivates the elastic page design in §2.2.3; values are cited from prior measurements [9, 46] and not re-measured on genuine CXL 3.0 multi-node hardware.
  • domain assumption P90-bin alignment of local and CXL latency histograms is a sufficient criterion for optimal page placement.
    Section 5.1 defines latency equilibrium as P90-bin alignment; the paper does not prove that this maximizes throughput, only that it works on the evaluated benchmarks.
  • domain assumption Updating only PTEs while leaving the VMA anchored to the CXL backing store preserves correctness across nodes without cross-node VMA coordination.
    Section 4.2 relies on Linux VMA/page-table semantics and the global address-space invariant; this is not formally verified.
  • domain assumption The shared xdsm_database can be treated as trusted.
    Section 9 explicitly states the system 'operates under a trusted-environment assumption' and that hardening against adversarial nodes is left as future work.
invented entities (2)
  • Elastic Page
    purpose: Dynamically coalesced 4KB–2MB unit for fault handling, migration, and consistency tracking.
    Internal abstraction of xDSM; its benefits are shown only through the system's own evaluation, with no external falsifiable handle.
  • Exp-binned latency histogram / P90-bin equilibrium
    purpose: Latency metric guiding page promotion and demotion decisions.
    Internal metric introduced in §5.1; no independent validation outside xDSM's benchmark suite.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Scaling Unmodified Multithreaded Applications with Elastic CXL-based Distributed Shared Memory." pith.science (2026). https://pith.science/paper/BOK2IT7L

@misc{pith2026260715569,
  author       = {Pith},
  title        = {Pith review of: Scaling Unmodified Multithreaded Applications with Elastic CXL-based Distributed Shared Memory},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/BOK2IT7L}},
  note         = {Machine review of arXiv:2607.15569}
}
abstract

While CXL presents a promising hardware substrate for Distributed Shared Memory (DSM), seamlessly scaling multithreaded applications across multiple nodes remains a formidable challenge. Existing CXL-based DSMs fall short: they require manual code modifications to share non-heap data, employ rigid data placement policies that fail under diverse and dynamic workloads, and suffer from severe page-fault processing overheads in sub-microsecond ($\mu\mathrm{s}$) environments. We present xDSM, a full-space, elastic DSM system built over CXL that transparently scales unmodified multithreaded applications. To eliminate the burden of manual code rewrites, xDSM employs an OS-runtime co-design that establishes a globally coordinated address space, seamlessly sharing all memory segments. To mask CXL access penalties, xDSM abandons static placement rules in favor of a dynamic, latency-driven policy that actively balances data between local DRAM and CXL memory. Finally, to resolve the fundamental tension between high base-page fault overheads and severe huge-page false sharing, xDSM introduces spatial locality-aware elasticity, dynamically coalescing and splitting pages on the fly to amortize processing costs. Evaluated across diverse workloads using 15 system configurations, xDSM outperforms CXL-only baselines by 1.5$\times$ to 2.2$\times$ and state-of-the-art hybrid DSMs by 1.1$\times$ to 2.2$\times$, while achieving near-linear scalability.

Figures

Figures reproduced from arXiv: 2607.15569 by the authors.

Figure 1
Figure 1. Overview of xDSM architecture. The system employs an OS-runtime co-design. In user space, three types of management threads (Sampling, Decision, and Migration) as well as page fault handlers coordinate memory migration and consistency. In the shared CXL memory, a global xdsm_database maintains three core tables: epte_statistics tracks memory access statistics (e.g., access counts), epte_status manages consistency st… view at source ↗
Figure 2
Figure 2. Per-node latency histograms for local (blue) mem￾ory and CXL (red) from Jacobi (§8.2). Dashed lines mark P90 bins. (a) CXL P90 exceeds local P90, triggering pro￾motion. (b) After promotion saturates local DRAM, lo￾cal P90 exceeds CXL P90, triggering demotion. (c) Bin-to￾latency mapping. Intervals [2 𝑘 , 2 𝑘+1 ) grow by powers of two and each is bisected into two bins: e.g., bin 10 and bin 11 split the interval [512,… view at source ↗
Figure 3
Figure 3. End-to-end execution time.(a) 16 threads (2 nodes), small datasets. (b) 32 threads (4 nodes), medium datasets. • Graph500 [38]: Breadth-first search on a large random graph stored in compressed sparse row (CSR) format. Mul￾tiple BFS traversals run in parallel from independent roots, with each thread reading the shared graph structure and maintaining a private visited set and queue. Access pat￾tern: dominated by shar… view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Per-iteration throughput for the iterative program (private read-write, 4.1 GB, 16 threads / 2 nodes). 0 1500 3000 Round 0 2 TEPS 1e8 Type 1 CXL-Only 0 1500 3000 Round Type 2 SC 0 1500 3000 Round Type 3 Strategy 1 (S1) HSC-S1-F 0 1500 3000 Round Type 3 Strategy 1 (S1) …
Figure 5
Figure 5. Figure 5: Per-round TEPS (traversed edges per second) for BFS (shared read-only, 7.46 GB, 16 threads / 2 nodes). E0 E6143 Expert 0 1 2 4 8 0.0 0.5 1.0 Migrations (pages) 1e5 0 50 100 150 200 250 300 Wall-clock time (s) 100 TPOT (ms) CXL-ONLY HSC-D-F xDSM-SC [PITH_FULL_IMAGE:fig…
Figure 7
Figure 7. Figure 7: Placement policy comparison on 4 nodes (32 threads). (a) Normalized performance relative to xDSM-SC (higher is better). (b) Per-iteration throughput breakdown for the iterative program (3,000 iterations). with lower per-page overhead than fixed granularity. Thus, xDSM-…
Figure 8
Figure 8. Figure 8: Scalability from 1 to 4 nodes (8 to 32 threads) across five benchmarks with large datasets [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

61 extracted references · 3 linked inside Pith

  1. [1]

    Murray, Benoit Steiner, Paul Tucker, Vijay Vasude- van, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng

    Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek G. Murray, Benoit Steiner, Paul Tucker, Vijay Vasude- van, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. 2016. TensorFlow: A System f...

    2016

  2. [2]

    Gulavani, Alexey Tumanov, and Ramachandran Ramjee

    Amey Agrawal, Nitin Kedia, Ashish Panwar, Jayashree Mohan, Nipun Kwatra, Bhargav S. Gulavani, Alexey Tumanov, and Ramachandran Ramjee. 2024. Taming throughput-latency tradeoff in LLM inference with sarathi-serve. InProceedings of the 18th USENIX Conference on Operating Systems Design and Implementation(Santa Clara, CA, USA) (OSDI’24). USENIX Association, ...

    2024

  3. [3]

    Chloe Alverti, Stratos Psomadakis, Burak Ocalan, Shashwat Jaiswal, Tianyin Xu, and Josep Torrellas. 2025. Cxlfork: Fast remote fork over cxl fabrics. InProceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2. 210–226

    2025

  4. [4]

    Aguilera, Aurojit Panda, Sylvia Ratnasamy, and Scott Shenker

    Emmanuel Amaro, Christopher Branner-Augmon, Zhihong Luo, Amy Ousterhout, Marcos K. Aguilera, Aurojit Panda, Sylvia Ratnasamy, and Scott Shenker. 2020. Can Far Memory Improve Job Throughput?. In Proceedings of the Fifteenth European Conference on Computer Systems (EuroSys ’20). ACM, 1–16

    2020

  5. [5]

    Scott Beamer, Krste Asanović, and David Patterson. 2015. The GAP Benchmark Suite.arXiv preprint arXiv:1508.03619(2015)

    arXiv 2015

  6. [6]

    J. K. Bennett, J. B. Carter, and W. Zwaenepoel. 1990. Munin: Dis- tributed Shared Memory Based on Type-Specific Memory Coherence. InProceedings of the 2nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP). ACM, 168–176

    1990

  7. [7]

    Bershad, Matthew J

    Brian N. Bershad, Matthew J. Zekauskas, and Wayne A. Sawdon. 1993. The Midway Distributed Shared Memory System. InProceedings of the IEEE CompCon. IEEE, 528–537

    1993

  8. [8]

    Christian Bienia, Sanjeev Kumar, Jaswinder Pal Singh, and Kai Li. 2008. The PARSEC Benchmark Suite: Characterization and Architectural Implications. InProceedings of the 17th International Conference on Parallel Architectures and Compilation Techniques (PACT). ACM, 72– 81

    2008

Show all 61 references
  1. [9]

    Talha Imran, Ivan Puddu, Sanidhya Kashyap, Hasan Al Maruf, Onur Mutlu, and Aasheesh Kolli

    Irina Calciu, M. Talha Imran, Ivan Puddu, Sanidhya Kashyap, Hasan Al Maruf, Onur Mutlu, and Aasheesh Kolli. 2021. Rethinking software runtimes for disaggregated memory. InProceedings of the 26th ACM International Conference on Architectural Support for Programming Lan- guages ...

    2021

  2. [10]

    Barbara Chapman, Tony Curtis, Swaroop Pophale, Stephen Poole, Jeff Kuehn, Chuck Koelbel, and Lauren Smith. 2010. Introducing OpenSHMEM: SHMEM for the PGAS Community. InProceedings of the 4th Conference on Partitioned Global Address Space Programming Model (PGAS’10). ACM, Artic...

    2010

  3. [11]

    Lei Chen, Shi Liu, Chenxi Wang, Haoran Ma, Yifan Qiao, Zhe Wang, Chenggang Wu, Youyou Lu, Xiaobing Feng, Huimin Cui, Shan Lu, and Harry Xu. 2024. A Tale of Two Paths: Toward a Hybrid Data Plane for Efficient Far-Memory Applications. In18th USENIX Symposium on Operating Systems...

    2024

  4. [12]

    Drongowski

    Paul J. Drongowski. 2007.Instruction-Based Sampling: A New Perfor- mance Analysis Technique for AMD Family 10h Processors. Technical Report. Advanced Micro Devices, Inc. AMD Technical Report

    2007

  5. [13]

    Padmapriya Duraisamy, Wei Xu, Scott Hare, Ravi Rajwar, David Culler, Zhiyi Xu, Jianing Fan, Christopher Kennelly, Bill McCloskey, Danijela Mijailovic, Brian Morris, Chiranjit Mukherjee, Jingliang Ren, Greg Thelen, Paul Turner, Carlos Villavieja, Parthasarathy Ranganathan, and ...

    2023

  6. [14]

    Juncheng Gu, Youngmoon Lee, Yiwen Zhang, Mosharaf Chowdhury, and Kang G. Shin. 2017. Efficient Memory Disaggregation with In- finiswap. InProceedings of the 14th USENIX Symposium on Networked Systems Design and Implementation (NSDI). 649–667

    2017

  7. [15]

    Zhiyuan Guo, Zijian He, and Yiying Zhang. 2023. Mira: A Program- Behavior-Guided Far Memory System. InProceedings of the 29th Sym- posium on Operating Systems Principles(Koblenz, Germany)(SOSP ’23). 13 Association for Computing Machinery, New York, NY, USA, 692–708

    2023

  8. [16]

    Jialiang Huang, MingXing Zhang, Teng Ma, Zheng Liu, Sixing Lin, Kang Chen, Jinlei Jiang, Xia Liao, Yingdi Shan, Ning Zhang, et al. 2024. Trenv: Transparently share serverless execution environments across different functions and nodes. InProceedings of the ACM SIGOPS 30th Symp...

    2024

  9. [17]

    Yibo Huang, Haowei Chen, Newton Ni, Yan Sun, Vijay Chidambaram, Dixin Tang, and Emmett Witchel. 2025. Tigon: A Distributed Database for a CXL Pod. InProceedings of the 19th USENIX Symposium on Oper- ating Systems Design and Implementation (OSDI). USENIX Association, Boston, MA, USA

    2025

  10. [18]

    2017.IEEE Standard for Information Technology—Portable Oper- ating System Interface (POSIX)

    IEEE. 2017.IEEE Standard for Information Technology—Portable Oper- ating System Interface (POSIX). Technical Report IEEE Std 1003.1-2017. IEEE

    2017

  11. [19]

    2024.Intel 64 and IA-32 Architectures Software Developer’s Manual

    Intel Corporation. 2024.Intel 64 and IA-32 Architectures Software Developer’s Manual. Intel. Vol. 3A, Protection Keys for User Pages

    2024

  12. [20]

    Ayal Itzkovitz, Nitzan Niv, and Assaf Schuster. 2000. Dynamic Adapta- tion of Sharing Granularity in DSM Systems.The Journal of Systems and Software55 (2000), 19–32

    2000

  13. [21]

    Sunita Jain, Nagaradhesh Yeleswarapu, Hasan Al Maruf, and Rita Gupta. 2024. Memory Sharing with CXL: Hardware and Software Design Approaches.arXiv preprint arXiv:2404.03245(2024)

    2024 arXiv

  14. [22]

    Cox, and Willy Zwaenepoel

    Pete Keleher, Alan L. Cox, and Willy Zwaenepoel. 1992. Lazy Release Consistency for Software Distributed Shared Memory. InProceedings of the 19th Annual International Symposium on Computer Architecture (ISCA). ACM, Gold Coast, Australia, 13–21

    1992

  15. [23]

    Cox, and Willy Zwaenepoel

    Pete Keleher, Sandhya Dwarkadas, Alan L. Cox, and Willy Zwaenepoel

  16. [24]

    Sang-Hoon Kim, Ho-Ren Chuang, Robert Lyerly, Pierre Olivier, Chang- woo Min, and Binoy Ravindran. 2020. DeX: Scaling Applications Be- yond Machine Boundaries. InProceedings of the 40th IEEE International Conference on Distributed Computing Systems (ICDCS). IEEE, 864–876

    2020

  17. [25]

    Taehyung Lee, Sumit Kumar Monga, Changwoo Min, and Young Ik Eom. 2023. MEMTIS: Efficient Memory Tiering with Dynamic Page Classification and Page Size Determination. InProceedings of the 29th Symposium on Operating Systems Principles(Koblenz, Germany) (SOSP ’23). Association f...

    2023

  18. [26]

    Huaicheng Li, Daniel S Berger, Lisa Hsu, Daniel Ernst, Pantea Zar- doshti, Stanko Novakovic, Monish Shah, Samir Rajadnya, Scott Lee, Ishwar Agarwal, et al. 2023. Pond: Cxl-based memory pooling sys- tems for cloud platforms. InProceedings of the 28th ACM International Conferenc...

    2023

  19. [27]

    Kai Li. 1988. IVY: A Shared Virtual Memory System for Parallel Com- puting. InProceedings of the International Conference on Parallel Pro- cessing. 94–101

    1988

  20. [28]

    Andersen, Jun Woo Park, Alexander J

    Mu Li, David G. Andersen, Jun Woo Park, Alexander J. Smola, Amr Ahmed, Vanja Josifovski, James Long, Eugene J. Shekita, and Bor-Yiing Su. 2014. Scaling Distributed Machine Learning with the Parameter Server. InProceedings of the 11th USENIX Symposium on Operating Systems Desig...

    2014

  21. [29]

    Quanxi Li, Hong Huang, Ying Liu, Yanwen Xia, Jie Zhang, Mosong Zhou, Xiaobing Feng, Huimin Cui, Quan Chen, Yizhou Shan, and Chenxi Wang. 2025. Beehive: A Scalable Disaggregated Memory Run- time Exploiting Asynchrony of Multithreaded Programs. InProceed- ings of the 22nd USENIX...

    2025

  22. [30]

    Linux Kernel Developers. 2024. Concepts overview — The Linux Kernel documentation.https://docs.kernel.org/admin-guide/mm/concepts. html

    2024

  23. [31]

    Jinshu Liu, Hamid Hadian, Hanchen Xu, and Huaicheng Li. 2025. Tiered memory management beyond hotness. InProceedings of the 19th USENIX Conference on Operating Systems Design and Implementa- tion(Boston, MA, USA)(OSDI ’25). USENIX Association, USA, Article 40, 17 pages

    2025

  24. [32]

    2025.Adaptive Memory Management for Memory- Disaggregated Data Centers

    Shi Liu. 2025.Adaptive Memory Management for Memory- Disaggregated Data Centers. Ph. D. Dissertation. University of Cal- ifornia, Los Angeles. Chapter 4: Firework: Efficient and Transparent Compute Scaling with CXL Shared Memory

    2025

  25. [33]

    Yucheng Low, Joseph Gonzalez, Aapo Kyrola, Danny Bickson, Car- los Guestrin, and Joseph Hellerstein. 2012. Distributed GraphLab: A Framework for Machine Learning and Data Mining in the Cloud.arXiv preprint arXiv:1204.60785, 8 (2012), 716–727

    2012

  26. [34]

    Haoran Ma, Yifan Qiao, Shi Liu, Shan Yu, Yuanjiang Ni, Qingda Lu, Jiesheng Wu, Yiying Zhang, Miryung Kim, and Harry Xu. 2024. DRust: Language-Guided Distributed Shared Memory with Fine Granularity, Full Transparency, and Ultra Efficiency. In18th USENIX Symposium on Operating S...

    2024

  27. [35]

    Suyash Mahar et al. 2024. Telepathic Datacenters: Fast RPCs using Shared CXL Memory.arXiv preprint arXiv:2408.11325(2024)

    2024 arXiv

  28. [36]

    Hasan Al Maruf, Hao Wang, Abhishek Dhanotia, Johannes Weiner, Niket Agarwal, Pallab Bhattacharya, Chris Petersen, Mosharaf Chowd- hury, Shobhit Kanaujia, and Prakash Chauhan. 2023. TPP: Transparent Page Placement for CXL-Enabled Tiered-Memory. InProceedings of the 28th ACM Int...

    2023

  29. [37]

    Frank Mueller. 1997. Distributed shared-memory threads: DSM- Threads. InWorkshop on Run-Time Systems for Parallel Programming. 31–40

    1997

  30. [38]

    Murphy, Kyle B

    Richard C. Murphy, Kyle B. Wheeler, Brian W. Barrett, and James A. Ang. 2010. Introducing the Graph 500. InCray User’s Group (CUG)

    2010

  31. [39]

    Jacob Nelson, Brandon Holt, Brandon Myers, Preston Briggs, Luis Ceze, Simon Kahan, and Mark Oskin. 2015. Latency-Tolerant Software Distributed Shared Memory. InProceedings of the 2015 USENIX Annual Technical Conference (ATC). USENIX Association, 291–305

    2015

  32. [40]

    Louis-Noël Pouchet and Tomofumi Yuki. 2016. PolyBench/C 3.2: The Polyhedral Benchmark Suite.https://www.cs.colostate.edu/~pouchet/ software/polybench/

    2016

  33. [41]

    Amanda Raybuck, Tim Stamler, Wei Zhang, Mattan Erez, and Simon Peter. 2021. HeMem: Scalable Tiered Memory Management for Big Data Applications and Real NVM. InProceedings of the ACM SIGOPS 28th Symposium on Operating Systems Principles(Virtual Event, Ger- many)(SOSP ’21). Asso...

    2021

  34. [42]

    Scales and Kourosh Gharachorloo

    Daniel J. Scales and Kourosh Gharachorloo. 1997. Towards Transparent and Efficient Software Distributed Shared Memory. InProceedings of the 16th ACM Symposium on Operating Systems Principles (SOSP). ACM, 157–169

    1997

  35. [43]

    Seung seob Lee, Yanpeng Yu, Yupeng Tang, Anurag Khandelwal, Lin Zhong, and Abhishek Bhattacharjee. 2021. MIND: In-Network Memory Management for Disaggregated Data Centers. InProceedings of the 28th ACM Symposium on Operating Systems Principles (SOSP). ACM, 488–504

    2021

  36. [44]

    2022.Compute Ex- press Link (CXL) 3.0 Specification

    Debendra Das Sharma and Ishwar Agarwal. 2022.Compute Ex- press Link (CXL) 3.0 Specification. Technical Report. CXL Consor- tium.https://computeexpresslink.org/wp-content/uploads/2023/12/ CXL_3.0_white-paper_FINAL.pdf

    2022

  37. [45]

    Julian Shun and Guy Blelloch. 2013. Ligra: A Lightweight Graph Pro- cessing Framework for Shared Memory. InProceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP). ACM, 135–146. 14

    2013

  38. [46]

    Yan Sun, Yifan Yuan, Zeduo Yu, Reese Kuper, Chihun Song, Jinghan Huang, Houxiang Ji, Siddharth Agarwal, Jiaqi Lou, Ipoom Jeong, Ren Wang, Jung Ho Ahn, Tianyin Xu, and Nam Sung Kim. 2023. Demysti- fying CXL Memory with Genuine CXL-Ready Systems and Devices. InProceedings of the...

    2023

  39. [47]

    Tauro, Brian Suchy, Simone Campanoni, Peter Dinda, and Kyle C

    Brian R. Tauro, Brian Suchy, Simone Campanoni, Peter Dinda, and Kyle C. Hale. 2024. TrackFM: Far-out Compiler Support for a Far Memory World. InProceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume...

    2024

  40. [48]

    Qwen Team. 2025. Qwen3 Technical Report.https://qwenlm.github. io/blog/qwen3/

    2025

  41. [49]

    Auburn University. [n. d.]. vSMP (ScaleMP).https://www.eng.auburn. edu/ens/hpcc/vsmp-scale-mp.html

  42. [50]

    Prabhu Vellaisamy, Thomas Labonte, Sourav Chakraborty, Matt Turner, Samantika Sury, and John Paul Shen. 2025. Characterizing and Opti- mizing LLM Inference Workloads on CPU-GPU Coupled Architectures . In2025 IEEE International Symposium on Performance Analysis of Sys- tems and...

    2025

  43. [51]

    Midhul Vuppalapati and Rachit Agarwal. 2024. Tiered Memory Man- agement: Access Latency is the Key!. InProceedings of the ACM SIGOPS 30th Symposium on Operating Systems Principles (SOSP). ACM, Austin, TX, USA, 79–94

    2024

  44. [52]

    Mattias De Wael, Stefan Marr, Bruno De Fraine, Tom Van Cutsem, and Wolfgang De Meuter. 2015. Partitioned Global Address Space Languages.Comput. Surveys47, 4, Article 62 (2015), 27 pages. doi:10. 1145/2716320

    2015

  45. [53]

    Xingda Wei, Fangming Lu, Tianxia Wang, Jinyu Gu, Yuhan Yang, Rong Chen, and Haibo Chen. 2023. No Provisioned Concurrency: Fast RDMA-codesigned Remote Fork for Serverless Computing. In17th USENIX Symposium on Operating Systems Design and Implementation (OSDI 23). USENIX Associa...

    2023

  46. [54]

    Lingfeng Xiang, Zhen Lin, Weishu Deng, Hui Lu, Jia Rao, Yifan Yuan, and Ren Wang. 2024. Nomad: Non-Exclusive Memory Tiering via Transactional Page Migration. InProceedings of the USENIX Sympo- sium on Operating Systems Design and Implementation (OSDI). USENIX Association, Sant...

    2024

  47. [55]

    Franklin, Scott Shenker, and Ion Stoica

    Matei Zaharia, Mosharaf Chowdhury, Tathagata Das, Ankur Dave, Justin Ma, Murphy McCauley, Michael J. Franklin, Scott Shenker, and Ion Stoica. 2012. Resilient Distributed Datasets: A Fault-Tolerant Ab- straction for In-Memory Cluster Computing. InProceedings of the 9th USENIX S...

    2012

  48. [56]

    Jin Zhang, Zhuocheng Ding, Yubin Chen, Xingguo Jia, Boshi Yu, Zheng- wei Qi, and Haibing Guan. 2020. GiantVM: A Type-II Hypervisor Implementing Many-to-One Virtualization. InProceedings of the 16th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments. 30–44

    2020

  49. [57]

    Berger, Carl Waldspurger, Ryan Wee, Ishwar Agarwal, Rajat Agarwal, Frank Hady, Karthik Kumar, Mark D

    Yuhong Zhong, Daniel S. Berger, Carl Waldspurger, Ryan Wee, Ishwar Agarwal, Rajat Agarwal, Frank Hady, Karthik Kumar, Mark D. Hill, Mosharaf Chowdhury, and Asaf Cidon. 2024. Managing memory tiers with CXL in virtualized environments. InProceedings of the 18th USENIX Conference...

    2024

  50. [58]

    Yinmin Zhong, Shengyu Liu, Junda Chen, Jianbo Hu, Yibo Zhu, Xu- anzhe Liu, Xin Jin, and Hao Zhang. 2024. DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving. In18th USENIX Symposium on Operating Systems Design and Implementation, O...

    2024

  51. [59]

    Yijie Zhong, Minqiang Zhou, Zhirong Shen, and Jiwu Shu. 2024. UniMem: redesigning disaggregated memory within a unified local- remote memory hierarchy. InProceedings of the 2024 USENIX Confer- ence on Usenix Annual Technical Conference(Santa Clara, CA, USA) (USENIX ATC’24). US...

    2024

  52. [60]

    Yuanyuan Zhou, Liviu Iftode, and Kai Li. 1996. Performance Evaluation of Two Home-Based Lazy Release Consistency Protocols for Shared Virtual Memory Systems. InProceedings of the 2nd USENIX Symposium on Operating Systems Design and Implementation (OSDI). 75–88. 15

    1996

  53. [1994]

    InProceedings of the USENIX Winter Technical Conference

    TreadMarks: Distributed Shared Memory on Standard Work- stations and Operating Systems. InProceedings of the USENIX Winter Technical Conference. USENIX Association, San Francisco, CA, 115– 131

Pith tools

Reviewed August 1, 2026 · model on record in the stance chip above.