application programming interfaces

To address the low throughput, high latency, and weak security coupling of HPC-oriented proxy-based RESTful APIs under intensive I/O workloads, this paper proposes a novel API architecture tailored for high-performance computing. Methodologically, we introduce the first end-to-end performance modeling and bottleneck attribution framework; deeply integrate security mechanisms (JWT/OAuth 2.1) into stateless service design—rather than applying them as post-hoc hardening—and implement asynchronous I/O, zero-copy data transfer, and load-aware routing in Rust. Our contributions include a 100× throughput improvement and reduction of P99 latency to the millisecond level; rigorous independent peer review; and production deployment across multiple European supercomputing centers, supporting scientific workflows with over one thousand concurrent clients.

Since the official C++ MPI binding was deprecated in 2008, modern C++ has lacked a standardized, general-purpose interface to MPI. This work addresses this gap by proposing a layered architecture grounded in C++20 concepts, introducing standardizable core abstractions and implementing them in the KaMPIng-v2 library—the first complete realization of concept-based design principles for MPI in C++. The library supports non-intrusive customization points, automatic mapping of STL containers, and a composable pipeline syntax for communication operations. It seamlessly integrates with major HPC ecosystem components such as Kokkos, Thrust, and SYCL, enabling direct passing of their data structures to MPI calls. This integration substantially reduces boilerplate code while enhancing memory safety and performance portability across diverse hardware platforms.

This paper identifies a fundamental semantic tension between MPI and modern C++—manifesting in type safety, RAII-based object lifetime management, and communication buffer semantics (value semantics vs. raw pointers)—and exposes multiple ambiguities and inconsistencies in the MPI standard. Method: We propose a concept-driven design paradigm grounded in C++20 Concepts, constraints, `std::span`, and move semantics, moving beyond syntactic wrapper libraries to formally model and verify semantic consistency across abstractions. Contribution/Results: Our analysis clarifies three core design conflicts, pinpoints several standard ambiguities, and establishes foundational design principles and a theoretical framework for high-performance, portable, and idiomatic C++ MPI bindings. The work provides both a rigorous conceptual foundation and a practical pathway toward community-standardized, semantically sound C++ MPI interfaces.

This work addresses key challenges in migrating existing REST APIs to GraphQL—namely, type unsafety, high performance overhead, and tight coupling to specific data sources. The authors propose an automated migration approach based on static program analysis that accurately infers types to construct a type-safe GraphQL schema. By embedding a GraphQL server that directly reuses the original API logic, the method eliminates network calls and adapter-layer overhead. This approach achieves end-to-end type safety for the first time, demonstrating 100% conversion success and zero type errors across 834 REST endpoints from nine open-source projects. Compared to OASGraph, it substantially improves both correctness and performance, accelerating data retrieval by 2–4×.

This study addresses the low-latency, high-throughput, and scalable data transfer requirements for cross-facility (edge-to-HPC) workflows in AI–HPC convergence scenarios. Method: We systematically compare three streaming architectures—Direct Transfer Streaming (DTS), Proxy-based Streaming (PRS), and Management Service Streaming (MSS)—and propose the DS2HPC taxonomy alongside SciStream, a lightweight in-memory streaming toolkit supporting scientific workflow patterns including work sharing, feedback loops, and broadcast-aggregation. Contribution/Results: Evaluation on real-world advanced computing infrastructures shows that DTS achieves minimal latency and maximal throughput but suffers from deployment constraints; MSS offers strong scalability yet incurs significant overhead; PRS delivers near-DTS performance while maintaining deployment flexibility and scalability, making it the optimal trade-off between efficiency and practicality. Our work provides empirical evidence and methodological support for designing cross-domain scientific data streaming architectures.

Traditional MPI C interfaces lack type safety and generic programming support, hindering the adoption of modern C++ in high-performance computing (HPC). To address this, we propose a layout-agnostic message-passing abstraction that—leveraging the Noarr library—introduces first-class data layout and traversal abstractions into the MPI communication layer for the first time. Our approach decouples communication semantics from memory layout while enabling type-safe, generic, and composable MPI interfaces. By tightly integrating modern C++ template metaprogramming with low-level MPI mechanisms, our design preserves near-native MPI performance while significantly improving interface safety, expressiveness, and modularity. We evaluate the framework using distributed GEMM as a case study: results demonstrate enhanced code reusability, greater development flexibility, and zero computational overhead relative to baseline MPI implementations.

This work addresses interoperability challenges in distributed systems arising from heterogeneous services, multi-version REST APIs, GraphQL endpoints, and IoT devices due to data schema mismatches. The authors propose a FastAPI-based runtime middleware that, for the first time, shifts Bass et al.’s interoperability tactics from design time to runtime. Leveraging large language models (LLMs), the approach dynamically detects structural and semantic discrepancies and implements a dual-path transformation strategy—either generating reusable adapter code or performing on-the-fly request-level conversion—through a five-stage pipeline. It also incorporates a three-tier security mechanism comprising validation, ensemble voting, and rule-based fallback. Evaluated across ten scenarios, the best configuration achieves a pass@1 accuracy of 0.90, with the CODEGEN strategy (mean 0.83) significantly outperforming DIRECT (0.77); notably, the highest-accuracy models also exhibit the lowest inference costs.

Actor-based systems (e.g., Erlang/OTP) suffer from runtime protocol violations and production failures due to the absence of static type guarantees in message protocols. This paper introduces NVLang, a novel statically typed language targeting the BEAM virtual machine, which enables end-to-end compile-time verification of message protocols in the Actor model for the first time. Its core contributions are: (1) modeling message protocols naturally via algebraic data types; (2) introducing typed process identifiers (Pid[T]) and typed futures (Future[T]) to enforce bidirectional type contracts between communicating actors; and (3) extending Hindley–Milner type inference to precisely track protocol state across process boundaries. NVLang compiles to Core Erlang and maintains full interoperability with the Erlang ecosystem. Evaluation demonstrates that our approach eliminates the vast majority of runtime message errors while preserving syntactic concision and seamless interoperation—guaranteeing that well-typed programs never violate Actor communication protocols.

MPI’s low-level interface lacks type safety, leading to runtime errors and debugging challenges. This paper introduces the first static type-safe communication framework for MPI, built atop RSMPI. It defines a `TypedCommunicator` abstraction that enables compile-time type matching verification for point-to-point transfers of both scalar values and memory slices. Innovatively, it leverages Rust’s `Equivalence` trait to enforce static type consistency between communicating endpoints, complemented by lightweight runtime checks to balance safety and performance. The framework fully preserves standard MPI semantics and employs zero-cost abstractions, achieving throughput nearly identical to native MPI in empirical evaluation. This work represents the first systematic integration of static type safety into MPI communication, establishing a foundation for type-safe collective operations and significantly enhancing the reliability and development efficiency of HPC applications.