The research, published in Frontiers in High Performance Computing, draws an unusual analogy between the world of science and the world of business. Large enterprises long ago abandoned the idea that every application should talk directly to every other application through shared databases. Instead, they adopted event-driven architectures, in which a distributed streaming service such as Apache Kafka acts as a single source of truth. Applications publish immutable events to topics, other applications subscribe to those topics, and the streaming service decouples producers from consumers in both time and space. A faulty application simply restarts and picks up where it left off in the stream. The authors describe such event stores as a database turned inside out, and they pose a provocative question: what would a parallel file system turned inside out look like?

The motivation is rooted in the changing character of HPC workloads. Scientific workflows increasingly integrate multimodal data streams from computations, simulations, and instruments, from small telemetry events to gigabyte-scale scientific datasets. Provenance capture, telemetry, and anomaly detection generate background I/O traffic from many sources. Coupling supercomputers with light sources, telescope arrays, and gravitational wave detectors introduces data-management challenges that neither parallel file systems nor tightly coupled in situ processing handle well. Parallel file systems suffer from a POSIX consistency model that forces locking and synchronization, serialization overheads, and the infamous computation-and-I/O gap that bottlenecks performance at scale. In situ approaches bypass the file system for speed but sacrifice persistence, fault tolerance, and impedance matching between components that produce data at different rates.

Mofka, built on the Mochi suite of HPC data-service components, aims to occupy the middle ground. Its design goals read like a checklist of supercomputer peculiarities: efficient use of high-performance networks such as InfiniBand, Omni-Path, and HPE Slingshot, including native RDMA support that moves data directly from application memory to storage with as few copies as possible; efficient threading on massively multicore nodes, mixing hardware threads with user-level co-routines; handling of event payloads ranging from kilobytes to multiple gigabytes; support for scientific data formats that lets consumers specify interest in only sections of multidimensional arrays before transfer; and high modularity so the network stack, scheduling policies, and storage backends can be fine-tuned per use case. Polaris at Argonne features two network interface cards per node, and Aurora features eight, and Mofka’s Plumber component automatically assigns server processes to their closest NIC to maximize network resources.

The architecture’s most distinctive decision is the division of every event into two parts. A small, structured metadata part, interpretable by both clients and servers, travels through an optimized control path: it is validated by a user-provided validator, routed by a partition selector, and serialized into batches sent via RDMA to a log provider. A potentially much larger data part, opaque to the server, travels by RDMA directly to and from user-provided memory and its final storage destination, bypassing intermediate buffers entirely. On the consumer side, a data selector decides which portion of the data to pull, all, none, or an arbitrary subset, before any transfer occurs, and a data broker tells the client library where to place it. In a weather application, one consumer might select a two-dimensional slice at ground level for a color map while another pulls the full three-dimensional chunk for volume rendering, from the same topic.

Benchmarks on Argonne’s Improv and Polaris supercomputers and Oak Ridge’s Frontier exascale machine compared Mofka against Kafka and Redpanda, which speak the same protocol. The results were revealing, and sometimes humbling. In single producer-consumer tests, Mofka outperformed both rivals in almost all scenarios on Improv, while on Polaris Redpanda performed better in production of events of one kilobyte and up. When one server served increasing numbers of client nodes, Mofka throughput doubled as server nodes doubled on Improv, while Kafka and Redpanda stagnated, apparently capped by their reliance on TCP at roughly one gigabyte per second. When events carried one kilobyte of metadata plus ten megabytes of data, using the separated data path with in-memory storage pushed production to 6,257 megabytes per second and consumption to 8,529 megabytes per second, roughly six times the metadata-only path. The team also learned that swapping glibc’s allocator for jemalloc more than doubled consumer throughput in some configurations, and that Kafka and Redpanda frequently timed out and failed to complete benchmarks as concurrency increased, making them difficult to use on HPC systems without an experienced administrator.

Three real-world applications demonstrated the framework’s utility. TekApp, a streaming tomographic reconstruction mini-app derived from the Trace code, reconstructs three-dimensional volumes from X-ray projections at the Advanced Photon Source. Its original ZeroMQ-based configuration required components to run simultaneously with frequent synchronization; with Mofka, the workflow became loosely coupled and fault tolerant, with per-event overhead reduced by at least twelve times across components and up to five hundred times better performance for large twenty-five-megabyte events between the reconstruction and denoising stages. MOFA, an AI-driven discovery pipeline for metal-organic frameworks for carbon capture, links a diffusion-based generative model with a ladder of physics simulations in a closed learning loop; replacing its single Redis instance with distributed Mofka topics eliminated a single point of failure, although experiments showed that Mofka currently suffers latency in latency-bound, small-message scenarios when Python’s threading limitations force blocking calls. Flowcept, a provenance and performance instrumentation tool, streams profiling data from a multinode, multi-GPU large language model hyperparameter search on Polaris; Mofka’s overhead ranged from 0.22 to 1.33 percent of workflow runtime, against 6.31 to 26.09 percent for Kafka and up to 36.96 percent for Redis, with Mofka spending just 7.30 seconds blocking on communication during a heavyweight profiling run while Kafka blocked for 36.19 seconds and Redis for 265.81 seconds.

The authors are candid about the lessons learned. Batch size matters enormously, and larger is not always better: for the SIRT component producing twenty-five-megabyte events, increasing batch size actually increased overhead because batching delays transfers whose performance is driven by the data path rather than the number of RPCs. More partitions equal more parallelism, even from a single process to a single server. Python bindings carry significant overhead, with object conversions and the Global Interpreter Lock often costing more than event serialization or transfer. Threading strategies, process placement, and oversubscription frequently mattered more than which streaming system was used at all. In one experiment on Polaris, oversubscribing thirty-two cores with sixteen processes and background threads dramatically changed results, and the use of an Argobots user-level thread combined with librdkafka’s POSIX threads caused interference that made Mofka’s API detrimental to consumption performance.

The comparison the authors ultimately draw is with file systems rather than messaging systems: comparing Mofka with Kafka, they write, is like comparing Lustre with NFS. The former is HPC-ready, uses high-performance networks, and offers the right features for scientific I/O; the latter is useful but will always rely on Ethernet and carry performance limitations. Kafka’s development started in 2011 and Redpanda’s in 2019, each backed by a company and hardened by enterprise use, yet a prototype built with limited resources in a short time outperforms them in many HPC scenarios, which the team sees as an encouraging first step justifying further investment. Future work will add data replication using an RDMA-enabled implementation of the RAFT protocol, authentication and access control to turn Mofka into a multiuser service, and bridges to technologies such as Octopus to form a scientific event fabric spanning instruments, supercomputers, edge devices, and the cloud. If they succeed, the humble event stream, the backbone of internet commerce, may become the backbone of computational science as well.

Subject of Research: Toward a persistent event-streaming system for high-performance computing applications

Article Title: Toward a persistent event-streaming system for high-performance computing applications

Article References: Dorier, M., Gueroudji, A., Hayot-Sasson, V., Nguyen, H. D., Ockerman, S., Souza, R., Bicer, T., Pan, H., Carns, P., Chard, K., Chard, R., Gonthier, M., Huerta, E., Lenard, B., Nicolae, B., Patel, P., Wozniak, J., Foster, I., Rao, N. S., & Ross, R. B. (2025). Toward a persistent event-streaming system for high-performance computing applications. Frontiers in High Performance Computing, 3, Article 1638203. https://doi.org/10.3389/fhpcp.2025.1638203

Image Credits: AI Generated

DOI: 10.3389/fhpcp.2025.1638203

Keywords: Mofka, event streaming, high-performance computing, RDMA, Kafka, Redpanda, Mochi, supercomputers, scientific workflows, data management, exascale, provenance

The core problem the authors identify is semantic fragmentation. Clinical information is recorded using a patchwork of competing standards such as ICD, SNOMED CT and HL7 FHIR, and these vocabularies do not align cleanly with one another. The same medical condition may be recorded differently across systems, an issue the review calls semantic inconsistency, and it directly undermines interoperability and the accuracy of large-scale analysis. On top of this come poor data quality, with missing or noisy entries in electronic health records and sensor streams, privacy risks inherent to sensitive patient records, and the sheer scalability demands posed by real-time intensive care units and the Internet of Things. Without a shared layer of meaning, the review warns, centralized repositories built to handle the volume, variety and velocity of big data risk devolving into repositories of noise.

Ontologies offer a solution by linking raw metadata to healthcare knowledge graphs, formal structures in which concepts such as diseases, drugs, symptoms and procedures are connected by defined relationships. This linkage enhances semantic interoperability, improves data discoverability, and enables expressive, domain-aware access to stored information. Rather than forcing every hospital to adopt identical data entry conventions, an ontology layer acts as a translation bridge: algorithms can reason about what a code in one system means in the vocabulary of another, aligning heterogeneous standards that would otherwise remain incompatible. The review documents how this approach significantly improves query efficiency across distributed datasets and enables scalable, real-time analytics for continuous patient monitoring.

To bring order to a sprawling literature, the researchers formulated key research questions and conducted a structured search across major academic databases, then classified the resulting studies into six categories of ontology-driven healthcare analytics. These are ontology-driven integration frameworks; semantic modeling for metadata enrichment; ontology-based data access, known in the field as OBDA; basic semantic data management; ontology-based reasoning for decision support; and semantic annotation for unstructured data. The classification serves as both a map of the current research landscape and a practical taxonomy that hospital technology teams and vendors can use to position their own tools and projects.

Several of these categories are already producing concrete clinical results. In the integration domain, studies demonstrate that ontological models of healthcare data built through metamodeling techniques and natural language processing can unify heterogeneous databases within a single domain, allowing previously siloed systems to exchange meaning rather than just files. Semantic annotation has become particularly powerful in recent years: tools such as the MedCAT clinical natural language processing toolkit map free-text clinical notes onto ontology concepts, while other work applies ontology-driven, weakly supervised models to identify rare diseases buried in clinical narratives. Entity-linking benchmarks for SNOMED CT, such as SNOBERT, show that machine learning can now attach precise terminology codes to messy clinician prose at scale, a task that once required painstaking manual coding.

Ontology-based data access deserves special attention because it changes who can query medical information. In an OBDA architecture, the user poses questions in high-level ontological terms, and the system translates them automatically into queries over underlying relational or NoSQL data stores. The review highlights systems such as ATHENA, which allowed natural language querying over relational databases, and Pathling, which performs analytics directly on HL7 FHIR data. Benchmarking efforts like LUBM4OBDA are now measuring how well these systems handle inference and large-scale query answering. The practical payoff is that clinicians and researchers can ask domain-meaningful questions without mastering the schema quirks of dozens of backend databases, a democratization of information access that the review identifies as a key trend.

The third pillar, ontology-based reasoning for decision support, is where semantics meets patient care most directly. Clinical decision support systems built on reasoning engines can infer context-aware conclusions from patient data, for example flagging prescribing errors, recommending treatment pathways or predicting cardiovascular risk. The review cites studies such as OnTopharma, an ontology-based system shown to reduce medication prescribing errors, and personalized decision support systems for complex chronic patients. Rule languages like SWRL allow medical knowledge to be encoded as executable logic, and the authors’ own prior work demonstrates ontology-driven diagnosis of vector-borne diseases and explainable artificial intelligence for liver disease diagnosis. Fuzzy and probabilistic extensions of ontology reasoning, which handle uncertainty explicitly, are highlighted as an important frontier given how much clinical knowledge is inherently imprecise.

Crucially, the review examines how ontology technologies integrate with the industrial machinery of big data: the frameworks of Hadoop, Spark and Kafka. Kafka’s streaming pipelines can feed real-time sensor and ICU data through ontology-based complex event processing, an approach the authors have explored in their OCEP framework for healthcare decision support. Spark provides distributed in-memory computation for reasoning-heavy workloads, while Hadoop’s storage layer underpins batch processing of longitudinal patient records. Studies of ontology-based IoT healthcare systems, including cardiac e-health models built on the SAREF4health IoT standard, show that semantic models can ride on top of these scalable platforms without sacrificing real-time responsiveness. The combined stack delivers scalable and intelligent analytics, the review concludes, from population-level dashboards to bedside monitoring.

None of this is frictionless, and the review is candid about the challenges. Reasoning over expressive ontologies is computationally expensive, and performance degrades as knowledge bases grow; large-scale deployment remains an open gap. Building and maintaining ontologies requires specialized expertise, and quality assurance of the ontologies themselves is a recognized problem, with dedicated big-data approaches proposed for auditing biomedical ontologies. Privacy-aware semantic modeling is identified as a key research gap, since richer knowledge graphs can paradoxically increase re-identification risk, prompting proposals that combine ontologies with access control models, provenance management and blockchain technology. The authors also flag organizational obstacles: healthcare institutions must invest in governance to prevent even semantically enriched data lakes from lapsing into swamps.

The trajectory, however, points clearly upward. The review identifies artificial intelligence, machine learning, the Internet of Things and real-time analytics as the dominant emerging trends reshaping ontology-driven healthcare analytics, with large language models now being harnessed to automate ontology engineering tasks, from generating competency questions to mapping indicators onto knowledge graphs. Hybrid systems that couple neural networks with symbolic knowledge graphs are attracting particular interest for interpretable medical AI. For each of its six categories, the review catalogs recent techniques, representative case studies, technical and organizational hurdles, and future directions, aiming to guide the development of sustainable, interoperable and high-performance healthcare data ecosystems. In a field drowning in its own data, the message is that meaning, not just capacity, is the resource that medicine must now engineer.

Subject of Research: A systematic review of ontology-driven big data analytics approaches, tools and applications in healthcare

Article Title: A review of ontology-driven big data analytics in healthcare: challenges, tools, and applications

Article References: Chandra, R., Agarwal, S., Singh, N., & Tiwari, S. (2026). A review of ontology-driven big data analytics in healthcare: challenges, tools, and applications. Knowledge and Information Systems, 68(1), Article 258. https://doi.org/10.1007/s10115-026-02864-5

Image Credits: AI Generated

DOI: 10.1007/s10115-026-02864-5

Keywords: ontologies, healthcare big data, semantic interoperability, knowledge graphs, ontology-based data access, clinical decision support, electronic health records, Hadoop, Spark, Kafka, IoT healthcare, semantic annotation