Pith. sign in

REVIEW 4 major objections 5 minor 71 references

VLCs: Managing Parallelism with Virtualized Libraries

T0 review · 4 major / 5 minor · reviewed 2026-08-03 · deepseek-v4-flash

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

Pith's one-line read Library virtualization layer lets parallel libraries share one process without contention, reporting up to 2.85x speedups.

desk verdict A genuinely useful user-space mechanism for partitioning cores among composed libraries, but the resource-virtualization coverage is narrower than claimed and the evaluation lacks repetition statistics. read the letter →

arxiv 2512.04320 v2 pith:5KSPEP4Z submitted 2025-12-03 cs.DC cs.OS

Yineng Yan , William Ruys , Hochan Lee , Ian Henriksen , Arthur Peters , Sean Stephens , Bozhi You , Henrique Fingler
show 6 more authors
Martin Burtscher Milos Gligoric Keshav Pingali Mattan Erez George Biros Christopher J. Rossbach
This is my paper
classification cs.DCcs.OS
keywords VirtualLibraryContextsVirtualizationResourcePartitioningOversubscriptionLinkerNamespacesSystemCallInterpositionThreadSafetyParallelComposition
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

VLCs aim to solve a composition problem: parallel libraries like OpenMP, OpenBLAS, and LibTorch assume they own all cores, so mixing them causes oversubscription and slowdowns. The paper proposes Virtual Library Contexts, per-process execution contexts that bundle a set of libraries with a user-assigned slice of resources, and that virtualize resource queries so each library sees only its assigned cores. By loading a library into multiple VLCs, applications can even run thread-unsafe code in parallel, since each instance has private static state. The system works entirely in user space via linker namespaces and system-call interposition, requires no library or kernel modification, and reports speedups up to 2.85x across benchmarks, 1.41x on a multi-GPU Kokkos Heat3D, and 1.96x on ARPACK. The paper also provides C++ and Python prototypes with low overhead (under 1% in tested applications).

What carries the argument

Linker namespaces (via dlmopen) isolate each VLC, giving each instance of a library its own static state. The VLC Monitor, a user-space process using ptrace with seccomp BPF filtering, intercepts and virtualizes resource-query system calls, redirects /proc/cpuinfo to forged files, and pins CPU affinity. A Service VLC with auto-generated assembly shims forwards calls to dlmopen-incompatible libraries like TBB, CUDA, and older pthreads.

What would settle it

A concrete test: run a library that uses hwloc or reads /sys/devices/system/cpu/online inside a VLC confined to two cores. If it launches more than two worker threads or reports all cores, the virtualization coverage is incomplete and the central claim fails for that class of library.

Watch

Extended reading notes

Core claim

The central claim is that a single process can host multiple libraries, each confined to its own linker namespace and resource view, so that libraries with conflicting resource assumptions can coexist without contention and can be replicated for parallel execution of thread-unsafe code. The mechanism works by interposing resource-query system calls (e.g., sched_getaffinity, open of /proc/cpuinfo) and forging the results per VLC, while pinning thread CPU affinity to the assigned cores. A Service VLC handles libraries that are incompatible with dlmopen by forwarding API calls through generated shims. Evaluations show that VLCs eliminate oversubscription in composed scientific workflows, enable

Load-bearing premise

The core claim presumes that libraries learn about system resources only through the targeted system calls and /proc/cpuinfo that VLCs intercept, so a library that reads CPU topology through other channels (like sysfs or hwloc) would observe the real machine and defeat the allocation.

Editorial extensions

If this is right

  • Applications can compose OpenMP, OpenBLAS, Kokkos, LibTorch, and ARPACK without library modifications or recompilation.
  • Thread-unsafe libraries can be called concurrently by loading per-VLC instances, as demonstrated with ARPACK.
  • Existing MPI-based Kokkos multi-GPU applications can migrate to single-process multi-GPU without rewriting data exchange, matching native multi-GPU performance.
  • Resource partitioning eliminates oversubscription and enables nested parallelism, e.g., running large and small GEMMs concurrently.
  • Adoption requires only 10-27 lines of application code changes in the evaluated benchmarks.

Reading between the lines

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

  • The virtualization-coverage assumption is untested for libraries that enumerate CPUs via sysfs (/sys/devices/system/cpu/online) or topology libraries like hwloc/libnuma; these channels are not listed as intercepted, so such libraries could silently see all cores and defeat the allocation.
  • The glibc namespace limit (rtld.nns, default up to 16) caps the number of simultaneous VLCs; the paper's suggested glibc patch would violate the 'no OS modification' selling point.
  • If VLCs hold up, a natural extension is virtualizing memory capacity and network interfaces, as the paper lists as future work; one could test whether per-VLC memory limits reduce allocator contention.
  • The auto-tuner's grid search is exponential in the number of VLCs; a learned pruner could make adoption practical for more than a few contexts.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes Virtual Library Contexts (VLCs), a user-space library-virtualization layer that partitions CPU and GPU resources among libraries loaded into a single process. VLCs use linker namespaces (dlmopen) for library and static-state isolation, interpose selected system calls via ptrace/Seccomp BPF, virtualize /proc/cpuinfo via openat redirection, and enforce CPU affinity. A Service VLC with generated shims handles dlmopen-incompatible dependencies such as pthreads. The authors present C++ and Python prototypes, an auto-tuner for choosing core partitions, and an evaluation covering overhead microbenchmarks, synthetic composed workflows, ARPACK, and Kokkos multi-GPU Heat3D. Reported results include up to 2.85x speedup on composed benchmarks, 1.96x on ARPACK, 1.46x on Kokkos over MPI, and end-to-end overhead below 0.54%.

Significance. If the claimed level of generality holds, VLCs would be a practical and broadly applicable technique for managing library composition in HPC and ML workloads, requiring neither library source changes nor OS/kernel modifications. The paper's strengths are its clear RQ structure, honest acknowledgment of dlmopen incompatibilities and the 16-namespace limit, open-source code, and a useful comparison against Kokkos native multi-GPU support. The central idea—intra-process, library-granular resource virtualization—is novel relative to Lithe, Bolt, LwCs, and containers. However, the prototype's resource-query interception surface is narrow, and the evaluation's performance claims lack statistical support and may reflect post-hoc selection of tuned partitions. These issues need to be addressed before the paper's broad claims can be accepted.

major comments (4)
  1. [§4.2, §5.1] The paper's central claim is that VLCs control the resource utilization of unmodified libraries by virtualizing resource queries. The implementation, however, intercepts only 'targeted system calls like sched_getaffinity' and openat for /proc/cpuinfo, plus environment variables and CPU affinity. Many real libraries query core counts through glibc sysconf(_SC_NPROCESSORS_ONLN), /sys/devices/system/cpu/online, /sys/devices/system/node, hwloc, or libnuma. Such libraries will observe the full machine and size their thread pools / make load-balancing decisions incorrectly, silently defeating the intended resource partition. None of the Section 6 experiments uses such a library, and Section 7.2's limitation list does not enumerate resource-query channels. The authors should either extend interposition to these channels or explicitly narrow the Abstract/Introduction claims and add a limitation
  2. [§6 (Tables 2-4, Figures 8-11)] The macrobenchmark results—2.85x, 1.96x, 1.46x, and the sub-0.54% overheads—are reported as single numbers without error bars, confidence intervals, or even an explicit statement of the number of runs. Table 2 reports means of 120,000 samples, but Figures 8-11 and Table 4 appear to be single executions. Given the variability typical of multi-threaded workloads and partition tuning, the central empirical claims need a stated measurement methodology and variance information (or statistical tests) to be reproducible and reliable.
  3. [§6.2-6.3, Figure 2] The auto-tuner performs an exhaustive grid search over core partitions and reports the optimal configuration; the subsequent speedup numbers appear to use those same tuned partitions on the same benchmarks. This is a post-hoc maximum rather than an out-of-sample prediction. To support the claim that VLCs 'improve performance' in general, the paper should either validate the tuned partitions on held-out runs or quantify the selection bias (e.g., by comparing tuned vs. default/random partitions with error bars). As written, the 'up to' speedups may substantially overstate expected benefit.
  4. [§4.4] The Service VLC shim forwards API calls to a globally loaded library and is claimed to be transparent. However, the cited dlmopen incompatibilities (TBB, CUDA, pthreads before glibc 2.34; refs [21][22][60]) are precisely cases where thread-local storage, errno, or pthread_key semantics are known to break under namespace duplication. The shim cannot virtualize per-VLC static state for these libraries, so if a dlmopen-incompatible library is itself the target of parallel thread-unsafe calls, VLCs cannot provide safe replication. The paper should state this limitation explicitly and, if possible, test the shim with TLS-sensitive APIs such as pthread_key_create/pthread_setspecific.
minor comments (5)
  1. [References [8] and [9]] References [8] and [9] appear to be the same paper; one should be removed or differentiated.
  2. [§5.2] The Python prototype patches the dynamic linker (libdl), which is a system component rather than application or library code. The Abstract/Introduction claim of 'no modification' should clarify that the application and target libraries are unmodified, but the runtime may patch the linker.
  3. [§6.1, Table 2] The text states that non-interposed system-call overhead is 'very low (2%)' but Table 2 shows mmap overhead from 0.78 to 0.82 us, about 5%. Please make the stated percentage consistent with the table.
  4. [§4.2] The phrase 'VLC Monitor process' appears as 'VLCs Monitor process' in one place; also, the list of intercepted syscalls and virtualized files is only given as examples ('like sched_getaffinity'). A complete, explicit list in a table would strengthen the paper.
  5. [§6.4] The Python multi-threaded baseline is said to suffer from GIL overhead for short numpy calls; the text reports '1.58x' and '1.17x' over sequential and multithreaded baselines, but the figures and text should be cross-checked for consistency in the reported normalized times.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the paper is a systems measurement paper whose claims are directly benchmarked, with no fitted prediction, imported uniqueness theorem, or self-citation chain carrying the argument.

full rationale

The central claims are empirical rather than derivational: VLCs interpose targeted resource-query system calls and redirect /proc/cpuinfo accesses (Section 5.1), and the reported speedups are measured wall-clock comparisons against non-VLC baselines (Sections 6.3-6.6). There is no fitted parameter that is later renamed as a prediction. The auto-tuner's grid search selects a measured configuration and the paper reports the resulting speedup, which is a tuning/optimism concern, not circular construction of the result. No uniqueness theorem from prior work by the same authors is invoked; the dlmopen incompatibilities are supported by external references [21][22][60], and self-citations such as [18] and [49] appear only in related-work context and are not load-bearing. The coverage assumption that libraries query resources only through targeted system calls and /proc/cpuinfo is an empirical limitation (Sections 4.2, 5.1), and the paper itself notes constraints such as the 16-namespace cap (Section 7.2), but an untested or incomplete assumption about library behavior is a correctness/robustness gap, not a circular derivation. No claimed result reduces to its own inputs by definition or by self-citation.

Assumptions & free parameters 3 free parameters · 4 assumptions · 3 invented entities

The central claim rests on the coverage of the interception layer (which channels libraries use to learn about cores), the correctness of dlmopen isolation, affinity pinning sufficiency, and the representativeness of synthetic workloads. These are domain assumptions, not standard math; none are machine-checked or independently reproduced. The per-benchmark core partitions are fitted via grid search and directly determine the headline speedups.

free parameters (3)
  • Per-benchmark CPU-core partition vector = e.g., 6/18 (LibTorch seq-len 128/256), 17/7 (large/small GEMM), 12/12 (ARPACK)
    Headline speedups (2.85x, 1.96x, 1.58x) are measured at the partition the auto-tuner grid-search selected for each workload (Section 6.2-6.3, Figure 2); these are fitted per experiment and not predicted.
  • Auto-tuner grid resolution = e.g., grid size 3 / 64 runs for an OpenBLAS pair (about 10 minutes)
    Chosen by hand (Section 6.2); coarser or finer grids change the best-found configuration and the reported speedup.
  • Number of VLC instances per process = 3-4 per workflow (Section 6.3); bounded by glibc's 16-namespace cap
    VLC count is an experiment-specific design choice; the 16-limit (Section 7.2) bounds the approach's generality.
assumptions (4)
  • domain assumption Libraries discover and control resources only through intercepted channels (sched_getaffinity-class syscalls, /proc files, env vars) plus affinity pinning.
    Sections 4.2/5.1; if a runtime reads /sys/devices/system/cpu or uses hwloc, VLCs cannot constrain it, and the no-oversubscription claim fails silently.
  • domain assumption dlmopen supplies correct symbol isolation and private static state for target libraries.
    Sections 4.1/4.4; the paper itself documents dlmopen incompatibilities (TBB, CUDA, glibc < 2.34 pthreads; refs [21][22][60]), requiring the Service VLC workaround.
  • domain assumption sched_setaffinity interposition is sufficient to confine all library threads to allocated cores.
    Section 4.2; assumes no thread escapes pinning via un-intercepted affinity paths or threads created outside the VLC.
  • domain assumption Synthetic workloads composed from Rodinia, OpenBLAS kernels, and LibTorch models are representative of multiphysics, N-body, ML-corrected CFD, and data-assimilation workflows.
    Section 6.3; the 2.85x headline is measured on these synthetic compositions, not on the real applications cited ([8][9][10][46]).
invented entities (3)
  • Virtual Library Context (VLC)
    purpose: Process subunit encapsulating one library copy plus a virtualized resource view (cores, GPUs, env vars).
    Software construct; effectiveness evidence is the paper's own benchmarks (Section 6). Public repo exists but no artifacts or commit hash were reviewed.
  • VLC Monitor
    purpose: Forked ptrace/seccomp-BPF interposer process that forges resource-query results and pins thread affinity.
    Introduced by this paper (Sections 4.2, 5.1); overhead and behavior characterized only in-paper (Section 6.1).
  • Service VLC plus generated shims
    purpose: Global-namespace host for dlmopen-incompatible libraries (TBB, CUDA, old pthreads) with jump-table shims forwarding calls into per-VLC contexts.
    Novel workaround (Section 4.4); assumes shim forwarding preserves TLS/errno semantics, asserted but not demonstrated.

how reviews work

0 comments
Cite this review

Pith. "Pith review of VLCs: Managing Parallelism with Virtualized Libraries." pith.science (2026). https://pith.science/paper/5KSPEP4Z

@misc{pith2026251204320,
  author       = {Pith},
  title        = {Pith review of: VLCs: Managing Parallelism with Virtualized Libraries},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5KSPEP4Z}},
  note         = {Machine review of arXiv:2512.04320}
}
read the original abstract

As the complexity and scale of modern parallel machines continue to grow, programmers increasingly rely on composition of software libraries to encapsulate and exploit parallelism. However, many libraries are not designed with composition in mind and assume they have exclusive access to all resources. Using such libraries concurrently can result in contention and degraded performance. Prior solutions involve modifying the libraries or the OS, which is often infeasible. We propose Virtual Library Contexts (VLCs), which are process subunits that encapsulate sets of libraries and associated resource allocations. VLCs control the resource utilization of these libraries without modifying library code. This enables the user to partition resources between libraries to prevent contention, or load multiple copies of the same library to allow parallel execution of otherwise thread-unsafe code within the same process. In this paper, we describe and evaluate C++ and Python prototypes of VLCs. Experiments show VLCs enable a speedup up to 2.85x on benchmarks including applications using OpenMP, OpenBLAS, and LibTorch. Source code of VLCs is available at https://github.com/pecos/Virtual-Library-Context.

Figures

Figures reproduced from arXiv: 2512.04320 by the authors.

Figure 1
Figure 1. The speedup ratio of parallel hyperparame [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Heatmap of relative execution times for CPU [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Overview of VLCs and other virtualization [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (7 more)
Figure 5
Figure 5. Figure 5: Service VLC Control Flow. OpenMP is loaded [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]
Figure 6
Figure 6. Figure 6: An example of VLCs usage in Python. 1 int main(int argc, char ** argv) { 2 VLC::Runtime monitor; 3 monitor.initialize(); 4 std::async([&]() { /* on thread 1 */ 5 VLC::Context a(1, gettid()); 6 a.set_allowed_cpus("0-11"); 7 VLC::Loader loader(&a, "lib.so", true); 8 comp…
Figure 7
Figure 7. Figure 7: shows the same example using the C++ interface. When the application starts, it initializes the VLC Monitor on Lines 2–3. For illustration purposes, we create two parallel threads using standard C++ on Lines 4 and 10. On Lines 5 and 11 two VLCs are created with the VLC…
Figure 8
Figure 8. Figure 8: Speedup achieved by using VLCs on represen [PITH_FULL_IMAGE:figures/full_fig_p009_8.png]
Figure 9
Figure 9. Figure 9: Normalized execution time of matrix mul [PITH_FULL_IMAGE:figures/full_fig_p010_9.png]
Figure 10
Figure 10. Figure 10: Execution time for computing the eigenval [PITH_FULL_IMAGE:figures/full_fig_p011_10.png]
Figure 11
Figure 11. Figure 11: Normalized execution time of Kokkos multi [PITH_FULL_IMAGE:figures/full_fig_p011_11.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

71 extracted references · 1 canonical work pages

  1. [21]

    Taylor Goodhart. 2023. dlmopen()’ing a shared library that dlopen()’s a non-existent library during initialization returns prematurely. https: //sourceware.org/bugzilla/show_bug.cgi?id=31164

    2023

  2. [22]

    Taylor Goodhart. 2023. libtbb.so cannot be used with dlmopen(). https://github.com/oneapi-src/oneTBB/issues/1283

    2023

  3. [60]

    Florian Weimer. 2019. Bug 24776: pthread_key_create, pthread_setspecific are incompatible with dlmopen. https: //sourceware.org/bugzilla/show_bug.cgi?id=24776

    2019

  4. [1]

    Sparse eigenvalue problems with ARPACK

    2023. Sparse eigenvalue problems with ARPACK. https://docs.scipy. org/doc/scipy/tutorial/arpack.html

    2023

  5. [2]

    Patrick R Amestoy, Iain S Duff, Jean-Yves L’Excellent, and Jacko Koster

  6. [3]

    Iztok Lebar Bajec. 2024. numba.get_num_threads/set_num_threads resets the value of torch.get_num_threads. https://github.com/numba/ numba/issues/9387 VLCs : Managing Parallelism with Virtualized Libraries

    2024

  7. [4]

    Wolfgang Bangerth. 2025. Experience converting a large mathematical software package written in C++ to C++20 modules. arXiv:2506.21654 https://arxiv.org/abs/2506.21654

    arXiv 2025

  8. [5]

    Lorch, Barry Bond, Reuben Olinsky, and Galen C

    Andrew Baumann, Dongyoon Lee, Pedro Fonseca, Lisa Glendenning, Jacob R. Lorch, Barry Bond, Reuben Olinsky, and Galen C. Hunt. 2013. Composing OS Extensions Safely and Efficiently with Bascule. InPro- ceedings of the 8th ACM European Conference on Computer Systems (Prague, Czech Republic)(EuroSys ’13). Association for Computing Ma- chinery, New York, NY, U...

    arXiv 2013

Show all 71 references
  1. [6]

    Beard, Peng Li, and Roger D

    Jonathan C. Beard, Peng Li, and Roger D. Chamberlain. 2015. RaftLib: A C++ Template Library for High Performance Stream Parallel Process- ing. InProceedings of the Sixth International Workshop on Programming Models and Applications for Multicores and Manycores(San Francisco, C...

    2015

  2. [7]

    Shuai Che, Michael Boyer, Jiayuan Meng, David Tarjan, Jeremy W Sheaffer, Sang-Ha Lee, and Kevin Skadron. 2009. Rodinia: A bench- mark suite for heterogeneous computing. In2009 IEEE international symposium on workload characterization (IISWC). Ieee, 44–54

    2009

  3. [9]

    Yu, Hans-Joachim Bungartz, and George Biros

    Chao Chen, Severin Reiz, Chenhan D. Yu, Hans-Joachim Bungartz, and George Biros. 2021. Fast Approximation of the Gauss–Newton Hessian Matrix for the Multilayer Perceptron.SIAM J. Matrix Anal. Appl.42, 1 (2021), 165–184. doi:10.1137/19M129961X

    2021 doi

  4. [10]

    Jong Youl Choi, Choong-Seock Chang, Julien Dominski, Scott Klasky, Gabriele Merlo, Eric Suchyta, Mark Ainsworth, Bryce Allen, Franck Cappello, Michael Churchill, Philip Davis, Sheng Di, Greg Eisenhauer, Stephane Ethier, Ian Foster, Berk Geveci, Hanqi Guo, Kevin Huck, Frank Jen...

    2018

  5. [11]

    Jan Ciesko. 2023. kokkos-remote-spaces Github. https://github.com/ kokkos/kokkos-remote-spaces

    2023

  6. [12]

    Clint Whaley, Antoine Petitet, and Jack J

    R. Clint Whaley, Antoine Petitet, and Jack J. Dongarra. 2001. Auto- mated empirical optimizations of software and the ATLAS project. Parallel Comput.27, 1 (2001), 3–35. doi:10.1016/S0167-8191(00)00087-9 New Trends in High Performance Computing

    2001 doi

  7. [13]

    Dagum and R

    L. Dagum and R. Menon. 1998. OpenMP: an industry standard API for shared-memory programming.IEEE Computational Science and Engineering5, 1 (1998), 46–55. doi:10.1109/99.660313

    1998 doi

  8. [14]

    John R Douceur, Jeremy Elson, Jon Howell, and Jacob R Lorch. 2008. Leveraging legacy code to deploy desktop applications on the web.. In OSDI, Vol. 8. 339–354

    2008

  9. [15]

    Carter Edwards and Christian R

    H. Carter Edwards and Christian R. Trott. 2013. Kokkos: Enabling Per- formance Portability Across Manycore Architectures. In2013 Extreme Scaling Workshop (xsw 2013). 18–24. doi:10.1109/XSW.2013.7

    2013 doi

  10. [16]

    Dawson R Engler, M Frans Kaashoek, and James O’Toole Jr. 1995. Exokernel: An operating system architecture for application-level resource management.ACM SIGOPS Operating Systems Review29, 5 (1995), 251–266

    1995

  11. [17]

    Maurice S Fabien, Matthew G Knepley, Richard T Mills, and Béatrice M Riviére. 2019. Manycore parallel computing for a hybridizable discon- tinuous Galerkin nested multigrid method.SIAM Journal on Scientific Computing41, 2 (2019), C73–C96

    2019

  12. [18]

    Henrique Fingler, Amogh Akshintala, and Christopher J Rossbach

  13. [19]

    Program Generation, Optimization, and Platform Adaptation

    Matteo Frigo and Steven G. Johnson. 2005. The Design and Implemen- tation of FFTW3.Proc. IEEE93, 2 (2005), 216–231. Special issue on “Program Generation, Optimization, and Platform Adaptation”

    2005

  14. [20]

    GNU. 2024. Dynamic Linking Tunables. https://www.gnu.org/ software/libc/manual/html_node/Dynamic-Linking-Tunables.html

    2024

  15. [23]

    Niklas Hambüchen. 2020. Could you elaborate on the combination of OpenBLAS with multi-threading? https://github.com/OpenMathLib/ OpenBLAS/issues/2543

    2020

  16. [24]

    Alan C Hindmarsh, Peter N Brown, Keith E Grant, Steven L Lee, Radu Serban, Dan E Shumaker, and Carol S Woodward. 2005. SUNDIALS: Suite of nonlinear and differential/algebraic equation solvers.ACM Transactions on Mathematical Software (TOMS)31, 3 (2005), 363–396

    2005

  17. [25]

    Atsushi Hori, Min Si, Balazs Gerofi, Masamichi Takagi, Jai Dayal, Pavan Balaji, and Yutaka Ishikawa. 2018. Process-in-process: tech- niques for practical address-space sharing. InProceedings of the 27th International Symposium on High-Performance Parallel and Distributed Compu...

    2018

  18. [26]

    Jon Howell, Bryan Parno, and John R Douceur. 2013. How to Run {POSIX} Apps in a Minimal Picoprocess. In2013 {USENIX} Annual Technical Conference ({USENIX}{ATC}13). 321–332

    2013

  19. [27]

    Itseez 2014.The OpenCV Reference Manual(2.4.9.0 ed.). Itseez

    2014

  20. [28]

    Shintaro Iwasaki, Abdelhalim Amer, Kenjiro Taura, Sangmin Seo, and Pavan Balaji. 2019. BOLT: Optimizing OpenMP parallel regions with user-level threads. In2019 28th International Conference on Parallel Architectures and Compilation Techniques (PACT). IEEE, 29–42

    2019

  21. [29]

    Bart Jacob. 2009. SystemTap: Instrumenting the Linux Kernel for Ana- lyzing Performance and Functional Problems. https://www.redbooks. ibm.com/redpapers/pdfs/redp4469.pdf

    2009

  22. [30]

    Yuxuan Jiang. 2023. Conda Pytorch set processor affinity to the first physical core after fork. https://github.com/pytorch/pytorch/issues/ 99625

    2023

  23. [31]

    Michael Kerrisk. 2024. dlopen(3) — Linux manual page. https://man7. org/linux/man-pages/man3/dlopen.3.html

    2024

  24. [32]

    Samuel Khuvis, Karen Tomko, Jahanzeb Hashmi, and Dhabaleswar K Panda. 2020. Exploring hybrid mpi+ kokkos tasks programming model. In2020 IEEE/ACM 3rd Annual Parallel Applications Workshop: Alterna- tives To MPI+ X (PA W-ATM). IEEE, 66–73

    2020

  25. [33]

    Liam Li, Kevin Jamieson, Afshin Rostamizadeh, Ekaterina Gonina, Jonathan Ben-Tzur, Moritz Hardt, Benjamin Recht, and Ameet Tal- walkar. 2020. A system for massively parallel hyperparameter tuning. Proceedings of machine learning and systems2 (2020), 230–246

    2020

  26. [34]

    Xiaoye S. Li. 2005. An overview of SuperLU: Algorithms, implementa- tion, and user interface.ACM Trans. Math. Softw.31, 3 (Sept. 2005), 302–325. doi:10.1145/1089014.1089017

    2005

  27. [35]

    James Litton, Anjo Vahldiek-Oberwagner, Eslam Elnikety, Deepak Garg, Bobby Bhattacharjee, and Peter Druschel. 2016. Light-Weight Contexts: An OS Abstraction for Safety and Performance.. InOSDI. 49–64

    2016

  28. [36]

    Anil Madhavapeddy, Thomas Leonard, Magnus Skjegstad, Thomas Gazagnaire, David Sheets, Dave Scott, Richard Mortier, Amir Chaudhry, Balraj Singh, Jon Ludlam, et al . 2015. Jitsu: Just-in-time summoning of unikernels. In12th{USENIX} Symposium on Networked Systems Design and Imple...

    2015

  29. [37]

    Anil Madhavapeddy, Richard Mortier, Charalampos Rotsos, David Scott, Balraj Singh, Thomas Gazagnaire, Steven Smith, Steven Hand, and Jon Crowcroft. 2013. Unikernels: Library operating systems for the cloud.ACM SIGARCH Computer Architecture News41, 1 (2013), 461–472

    2013

  30. [38]

    Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher

  31. [39]

    Dirk Merkel et al . 2014. Docker: lightweight linux containers for consistent development and deployment.Linux j239, 2 (2014), 2

    2014

  32. [40]

    Vivek Das Mohapatra. 2019. libcapsule. https://gitlab.collabora.com/ vivek/libcapsule

    2019

  33. [41]

    Donald Nguyen, Andrew Lenharth, and Keshav Pingali. 2013. A light- weight infrastructure for graph analytics. InProceedings of the twenty- fourth ACM symposium on operating systems principles. 456–471

    2013

  34. [42]

    Carlos O’Donell. 2015. RFC: Treat RTLD_GLOBAL as unique to names- pace when used with dlmopen. https://patchwork.ozlabs.org/project/ glibc/patch/55A73673.3060104@redhat.com/

    2015

  35. [43]

    Heidi Pan, Benjamin Hindman, and Krste Asanović. 2010. Composing Parallel Software Efficiently with Lithe.SIGPLAN Not.45, 6 (jun 2010), 376–387. doi:10.1145/1809028.1806639

    2010

  36. [44]

    Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. 2017. Automatic differentiation in PyTorch. (2017)

    2017

  37. [45]

    Donald E Porter, Silas Boyd-Wickizer, Jon Howell, Reuben Olinsky, and Galen C Hunt. 2011. Rethinking the library OS from the top down. InProceedings of the sixteenth international conference on Architectural support for programming languages and operating systems. 291–304

    2011

  38. [46]

    Ilan Price, Alvaro Sanchez-Gonzalez, Ferran Alet, Tom R Anders- son, Andrew El-Kadi, Dominic Masters, Timo Ewalds, Jacklynn Stott, Shakir Mohamed, Peter Battaglia, et al. 2025. Probabilistic weather forecasting with machine learning.Nature637, 8044 (2025), 84–90

    2025

  39. [47]

    Ali Raza, Parul Sohal, James Cadden, Jonathan Appavoo, Ulrich Drep- per, Richard Jones, Orran Krieger, Renato Mancuso, and Larry Wood- man. 2019. Unikernels: The next stage of linux’s dominance. InPro- ceedings of the Workshop on Hot Topics in Operating Systems. 7–13

    2019

  40. [48]

    O’Reilly Media, Inc

    James Reinders. 2007.Intel threading building blocks: outfitting C++ for multi-core processor parallelism. " O’Reilly Media, Inc. "

    2007

  41. [49]

    Christopher J Rossbach, Jon Currey, Mark Silberstein, Baishakhi Ray, and Emmett Witchel. 2011. PTask: operating system abstractions to manage GPUs as compute devices. InProceedings of the Twenty-Third ACM Symposium on Operating Systems Principles. 233–248

    2011

  42. [50]

    Vasily A Sartakov, Lluís Vilanova, and Peter Pietzuch. 2021. Cubicleos: A library os with software componentisation for practical isolation. In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. 546–558

    2021

  43. [51]

    Zhiming Shen, Zhen Sun, Gur-Eyal Sela, Eugene Bagdasaryan, Christina Delimitrou, Robbert Van Renesse, and Hakim Weatherspoon

  44. [52]

    Ahnjae Shin, Joo Seong Jeong, Do Yoon Kim, Soyoung Jung, and Byung-Gon Chun. 2022. Hippo: sharing computations in hyper- parameter optimization.Proc. VLDB Endow.15, 5 (Jan. 2022), 1038–1052. doi:10.14778/3510397.3510402

    2022

  45. [53]

    Claudio E Torres, Hossein Parishani, Orlando Ayala, Louis F Rossi, and L-P Wang. 2013. Analysis and parallel implementation of a forced N-body problem.J. Comput. Phys.245 (2013), 235–258

    2013

  46. [54]

    Christian Trott. 2018. Is it possible to use on-node multiple GPUs without MPI? https://github.com/kokkos/kokkos/issues/1610

    2018

  47. [55]

    InProceedings of the Twenty- Fourth International Conference on Architectural Support for Program- ming Languages and Operating Systems

    X-containers: Breaking down barriers to improve performance and isolation of cloud-native containers. InProceedings of the Twenty- Fourth International Conference on Architectural Support for Program- ming Languages and Operating Systems. 121–135

  48. [56]

    Pauli Virtanen. 2023. scipy.sparse.linalg.eigen.arpack.arpack. https://github.com/scipy/scipy/blob/ 3d3358a7740727fb8ad9cf4740de34c3bf71b287/scipy/sparse/linalg/ _eigen/arpack/arpack.py#L1099

    2023

  49. [57]

    Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, Stéfan J

    Pauli Virtanen, Ralf Gommers, Travis E. Oliphant, Matt Haberland, Tyler Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren Weckesser, Jonathan Bright, Stéfan J. van der Walt, Matthew Brett, Joshua Wilson, K. Jarrod Millman, Nikolay Mayorov, Andrew R. J. Nelson, E...

    2020

  50. [58]

    2014.Intel Math Kernel Library

    Endong Wang, Qing Zhang, Bo Shen, Guangyong Zhang, Xiaowei Lu, Qing Wu, and Yajuan Wang. 2014.Intel Math Kernel Library. Springer International Publishing, Cham, 167–188. doi:10.1007/978-3- 319-06486-4_7

    2014 doi

  51. [59]

    Chia-Che Tsai, Kumar Saurabh Arora, Nehal Bandi, Bhushan Jain, William Jannen, Jitin John, Harry A Kalodner, Vrushali Kulkarni, Daniela Oliveira, and Donald E Porter. 2014. Cooperation and security isolation of library OSes for multi-process applications. InProceedings of the ...

    2014

  52. [61]

    Wheeler, Richard C

    Kyle B. Wheeler, Richard C. Murphy, and Douglas Thain. 2008. Qthreads: An API for programming with millions of lightweight threads. In2008 IEEE International Symposium on Parallel and Dis- tributed Processing. 1–8. doi:10.1109/IPDPS.2008.4536359

    2008

  53. [62]

    Dan Williams, Ricardo Koller, Martin Lucina, and Nikhil Prakash

  54. [63]

    Nicolas Weber. 2023. PyTorch’s packaged libgomp causes significant performance penalties on CPU when used together with other Python packages. https://github.com/pytorch/pytorch/issues/98836

    2023

  55. [64]

    Zhang Xianyi, Wang Qian, and Zhang Yunquan. 2012. Model-driven level 3 BLAS performance optimization on Loongson 3A processor. In2012 IEEE 18th international conference on parallel and distributed systems. IEEE, 684–691

    2012

  56. [65]

    Fan Zhang, Melissa Petersen, Leigh Johnson, James Hall, and Sid E O’Bryant. 2022. Hyperparameter tuning with high performance com- puting machine learning for imbalanced Alzheimer’s disease data. Applied Sciences12, 13 (2022), 6670

    2022

  57. [66]

    Weiqun Zhang, Ann Almgren, Vince Beckner, John Bell, Johannes Blaschke, Cy Chan, Marcus Day, Brian Friesen, Kevin Gott, Daniel Graves, et al. 2019. AMReX: a framework for block-structured adaptive mesh refinement.The Journal of Open Source Software4, 37 (2019), 1370

    2019

  58. [67]

    Yiming Zhang, Chengfei Zhang, Yaozheng Wang, Kai Yu, Guangtao Xue, and Jon Crowcroft. 2021. Kylinx: Simplified virtualization archi- tecture for specialized virtual appliances with strong isolation.ACM Transactions on Computer Systems (TOCS)37, 1-4 (2021), 1–27

    2021

  59. [68]

    Emmett Witchel, Junghwan Rhee, and Krste Asanović. 2005. Mondrix: Memory isolation for Linux using Mondriaan memory protection. In Proceedings of the twentieth ACM symposium on Operating systems principles. 31–44

    2005

  60. [2001]

    Matrix Anal

    A fully asynchronous multifrontal solver using distributed dynamic scheduling.SIAM J. Matrix Anal. Appl.23, 1 (2001), 15–41

    2001

  61. [2016]

    arXiv:1609.07843 [cs.CL]

    Pointer Sentinel Mixture Models. arXiv:1609.07843 [cs.CL]

    arXiv

  62. [2018]

    InProceedings of the ACM Symposium on Cloud Computing

    Unikernels as processes. InProceedings of the ACM Symposium on Cloud Computing. 199–211

  63. [2019]

    InProceedings of the 10th ACM SIGOPS Asia-Pacific Workshop on Systems

    USETL: Unikernels for serverless extract transform and load why should you settle for less?. InProceedings of the 10th ACM SIGOPS Asia-Pacific Workshop on Systems. 23–30

Pith tools

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