[Contact][Google Scholar]

Compact Computing (凝练计算)

A Cross-Disciplinary Paradigm for Scaling Data Intelligence

---

Across changing data — genomes, then the graphs of a hundred-million-customer fintech, now knowledge and language in the era of large models — one method has persisted: center on the data, keep its representations compressed and sparse, and co-design the algorithm with the system. That method is Compact Computing.

Abstract

Compact Computing is a data-first, cross-disciplinary computing paradigm whose thesis is that the scalability of intelligence is governed not by raw hardware but by how faithfully computation compresses the intrinsic structure of data. It operates directly on compressed, sparse, and elastic representations and co-designs the algorithm with the system for full-stack performance. This report distils the paradigm into five first principles, then grounds every claim in the author's published work along four eras — sequence intelligence (the genome as a search engine), graph intelligence (from sparse primitives to distributed learning and foundation models), user and trust intelligence, and retrieval-augmented reasoning, agents, and efficient LLM serving. Because the same compactness-preserving moves recur across biological sequences, financial graphs, materials simulation, privacy-preserving learning, and large-model serving, Compact Computing constitutes a unifying technical paradigm rather than a domain technique. It is the enabling physics beneath a unifying ambition — Scaling Data Intelligence — making large-scale data searchable, matchable, and understandable at every scale the data reaches.

1. Introduction: the through-line and the question

Software and data have a tangled history, and most of that history is a history of compaction. Burrows and Wheeler reordered a string so its redundancy became locality; suffix arrays stored the sorted shape of a text without storing the text twice; sparse formats stored the zeros of a graph by not storing them at all. Each of these moves let computation scale past the volumetric growth of the data it described. Compact Computing names the discipline that keeps making this move, deliberately, across data modalities and across the compute stack.

The work surveyed here spans over fifteen years and four data eras. In the first (2009–2017) the data was the genome and the goal was to make it searchable; the pipeline was a search engine — build a compact index (Burrows–Wheeler transform, suffix array, k-mer tables), search it with approximate matching (Smith–Waterman, seed–extend alignment), and turn the hits into understanding (variant calling, metagenomic quantification). In the second (2017–) the data became the graph — the hundred-million-user relationships, transactions, and behaviours of a large fintech platform — and the same three-step pipeline returned as index, traverse, learn. In the third, the representational substrate became the foundation model — a compact, pretrained, transferable object that compresses a whole graph or user population into a reusable embedding. In the fourth and current era the data is language and knowledge, and the pipeline returns once more, as retrieve, match, reason — RAG and agents.

Amid this drift of domains, a single method persisted. Proposed around 2015–2016 and named Compact Computing (凝练计算), it is a style of computing that centers on data and fuses algorithms with systems for full-stack performance, operating directly on compressed, sparse, or elastic representations. The question this report answers is the one a broad claim must justify: is Compact Computing a paradigm — something that generalises across data, hardware, and disciplines — or merely a recurring habit?

The argument that follows is that it is a paradigm, and that the evidence is the published record itself: the same five principles, instantiated with different data on different hardware, produced independent advances in genomics, graph systems, foundation models, and large-model serving. The reach that this paradigm has achieved — Scaling Data Intelligence — is the subject of §10.

2. What Compact Computing is

Compact Computing rests on three components:

The signature of the paradigm is the joint application of the three: operating directly on the compressed/sparse/elastic form rather than materialising a dense, costly intermediate, and doing so portably across the architecture spectrum. Compact Computing is therefore not a single technique but a methodological invariant — a constraint on how any data-intensive computation should be structured.

3. First principles

Five principles, each drawn from the published record, constitute the paradigm.

3.1 Data-first computing

The data — its redundancy, distribution, sparsity, and locality — dictates the computation, never the reverse. A principle stated most crisply in the genome era: a genome is not an arbitrary byte stream but a text with deep internal repetition, and that repetition is the index (CUSHAW, Bioinformatics 2012; parallel/space-efficient BWT & suffix-array construction, IEEE TCBB 2016). The same inversion governs graphs — the sparsity of a billion-edge transaction graph is not a nuisance to be densified but the very structure a CSR-based kernel or a vertex-centric system should exploit (LightSpMV, IEEE ASAP 2015) — and governs attention, whose redundancy across queries is not wasted work but a cache to be reused (Decoupled Attention Fusion, EuroSys 2026 poster).

3.2 Compressive and elastic representation

The paradigm's central act is to not materialise. Four materialisations are refused in the record: (i) the dense string, refused by BWT and suffix arrays; (ii) the dense graph, refused by CSR and by materialization-free community detection (SIGMOD 2025); (iii) the dense attention, refused by KV-cache reuse and by tree speculation over hybrid-attention models (Decoupled Attention Fusion; Bole); (iv) the dense user, refused by quantized tokenizers that compress a user into compact, transferable tokens (FOUNDv2, KDD 2026). Where the data is dynamic — temporal graphs, streaming GNNs, evolving user populations — the representation is elastic: it grows, shrinks, and reshapes with the data rather than being rebuilt (TeGraph/TeGraph+, ICDE 2022 / IEEE TPDS 2024; TEA/TEA+, EuroSys 2023 / ACM TACO 2024; T-GCN, PACT 2022; ATLAS, ICPP 2026).

Those four sit inside a wider family of compressed representations the work keeps returning to. An embedding — a graph encoder's output, as in GraphCLIP, or FOUNDv2's quantised user tokens — compacts a population of relationships into a few coordinates that still transfer across tasks, and a foundation model packages that whole population as one reusable pretrained object. The numeric form of the model is compaction territory too: rounding gradients to integers (“Integer is Enough”), re-using gradient differences (AGD), and regularising the optimizer state (weighted sharpness-aware minimization) are compressions of the parameter bookkeeping, not of the data. The family has well-known siblings the record does not claim to have produced — low-rank factorisation, pruning, and distillation all shrink a model for the same reason Compact Computing compresses its data — but the instances named here are the ones this author's work supplies.

3.3 Algorithm–system co-design for full-stack performance

Algorithms are designed against the architecture and systems are designed around the algorithm's data-access pattern; the frontier is full-stack, from representation to kernel to distributed system to serving layer. The genome years instantiated this across the full hardware spectrum of the day — CUDA GPUs, Xeon Phi coprocessors, UPC++ clusters — within a single tool family (CUDASW++ 3.0, BMC Bioinformatics 2013; SWAPHI-LS, IEEE Cluster 2014; CUSHAW2-GPU, IEEE Design & Test 2014; DecGPU, BMC Bioinformatics 2011). At Ant the same principle scaled from a single CSR kernel (LightSpMV) to the first distributed, scalable graph-learning system on the vertex-centric paradigm, GeaLearning/GraphTheta, which became a core component of GeaGraph (TuGraph), recognised as a World's Leading Internet Scientific and Technological Achievement at the World Internet Conference 2021, and broke the world record on the Stanford Open Graph Benchmark proteins leaderboard in 2021. In the LLM era the co-design target is the serving stack: declarative auto-optimisation of RAG pipelines (AutoRAGTuner, EuroSys 2026 poster), compiler-driven long-context prefilling (CutAttn, NeurIPS 2026), and tree speculation for hybrid-attention models (Bole).

3.4 Generality through primitive distillation (凝练)

A small set of compute primitives — sparse matrix–vector multiplication, the scan/reduction family, indexing and search, and approximate matching — once compactly optimised across the hardware spectrum, transfers across domains. LightSpMV distils the workhorse of graph analytics, CSR-based sparse matrix–vector multiplication on GPUs, into a general-purpose kernel that is reused from graph processing through GNN training (IEEE ASAP 2015, Best Paper Award; J. Signal Processing Systems 2018). LightScan distils the scan primitive on many-core processors; the SIMD-vectorised Kendall's tau computation distils a statistical primitive, and parallel pairwise-correlation computation extends to Intel Xeon Phi clusters (SBAC-PAD 2016). These are not tied to genomics or graphs — they are the compaction of a primitive, which is why a genome-alignment kernel and a GNN-aggregation kernel can share an ancestry. Even genome assembly, retrospectively, was a graph problem: de Bruijn graph assembly of large genomes was the first large-graph compute problem tackled (BMC Bioinformatics 2011), and OpenGraphAssembly recast the building blocks of graph-based assembly as modular, parallel, reusable components — an explicit act of distillation.

3.5 Comprehension as the terminal operation (searchable → matchable → understandable)

A compact computation is not complete until it produces understanding. The pipeline always ends in a decision: an aligned read becomes a called variant (SNVSniffer, IEEE BIBM 2015 / BMC Systems Biology 2016); a traversed graph becomes a risk flag or a recommendation (FAF, CIKM 2023; GraphRPM, ECML PKDD 2024; path-based candidate matching, SIGIR 2021); a retrieved subgraph becomes an answer (subgraph retrieval enhanced by graph–text alignment, ECML PKDD 2024; M3GQA, ACL 2025; GTA-RAG, EMNLP 2026). Compact Computing therefore spans the full index → retrieve → match → understand stack; the comprehension layer is what makes the compaction “intelligence” rather than compression.

4. Era I — Sequence Intelligence: the genome as a search engine

The first act, 2009–2017, reads in retrospect as building a search engine for the genome, and it is where the habits of Compact Computing were internalised.

Compact index. The CUSHAW line built a CUDA-compatible short-read aligner to large genomes on the Burrows–Wheeler transform (CUSHAW, Bioinformatics 2012) and extended to color-space and hybrid seeding (CUSHAW2-GPU, IEEE Design & Test 2014; CUSHAW3, PLOS ONE 2014); the BWT and suffix array were constructed in parallel and space-efficient form for big genome data (IEEE TCBB 2016); k-mer indexing was generalised on distributed memory as Kmerind (ACM-BCB 2016; IEEE/ACM TCBB 2019). Approximate search. Smith–Waterman protein database search was accelerated by coupling CPU and GPU SIMD (CUDASW++ 3.0, BMC Bioinformatics 2013), pushed onto Xeon Phi (SWAPHI-LS, IEEE Cluster 2014), and hybridised across CPU+GPU for large-scale protein search (SWhybrid, IEEE IPDPS 2017); seed-verification was parallelised for ungapped alignment (PUNAS, IEEE IPDPS 2017). Error correction and assembly treated sequencing noise compactly: Musket, a multistage k-mer spectrum error corrector (Bioinformatics 2013), and DecGPU, distributed error correction on massively parallel GPUs using CUDA and MPI (BMC Bioinformatics 2011), with parallelised de Bruijn-graph assembly of large genomes (BMC Bioinformatics 2011) — the first large-graph compute problem in the record. Understanding. SNVSniffer integrated germline and somatic variant calling on Bayesian models (BIBM 2015 / BMC Systems Biology 2016); AFS performed metagenomic identification and quantification of species composition (Bioinformatics 2017). Multiple alignment and motif discovery — MSAProbs (Bioinformatics 2010) and CUDA-MEME (Pattern Recognition Letters 2010) — rounded out the toolkit; three of these tools were rated by NVIDIA as popular GPU-accelerated applications, and DecGPU was reported by GenomeWeb.

The through-line is unmistakable: domain problem → compact data structure → parallel algorithm → open-source tool (CUSHAW book chapter, Springer 2017). Every step is an instance of the five principles on a single data modality, across a full hardware spectrum. The era handed to the next the conviction that compaction, not volumetric force, is the lever.

5. Era II — Graph Intelligence: from sparsity to distributed learning

The second act began at Ant Group in 2017, when “the database being searched” became the graph — and the graph had in fact been present since the genome years. Two bridging works made the continuity explicit: de Bruijn graph assembly of large genomes (BMC Bioinformatics 2011) as the first large-graph compute problem, and LightSpMV (IEEE ASAP 2015, Best Paper Award; J. Signal Processing Systems 2018) which distilled CSR-based sparse matrix–vector multiplication on GPUs into the general-purpose kernel that vertex-centric graph processing would later build on. OpenGraphAssembly recast genome assembly's building blocks as modular, parallel, graph-native components — the conceptual hinge from sequence to graph.

Distributed graph learning systems. GeaLearning (alias GraphTheta) was the first distributed, scalable graph learning system built on the vertex-centric graph processing paradigm; its landing on Zhima Credit in Alipay was listed in Ant Technology Memorabilia 2020, it is a core component of GeaGraph (TuGraph), recognised at the World Internet Conference 2021, and the team broke the OGB proteins world record in 2021. The system was supported by a general information-propagation algorithm, GIPA.

Temporal and streaming graphs — the elastic representation. TeGraph (ICDE 2022) and TeGraph+ (IEEE TPDS 2024) provided a general-purpose temporal graph computing engine with flexible edge modifications; TEA (EuroSys 2023) and TEA+ (ACM TACO 2024) gave a temporal-graph random-walk engine with hybrid storage; TeMatch (ICDE 2025) added fast temporal subgraph matching; T-GCN (PACT 2022) delivered a sampling-based streaming GNN with hybrid architecture; ATLAS (ICPP 2026) an asynchronous state-aware pipeline for temporal GNN training.

Compiler and GPU co-design for GNNs. G-Sparse (PACT 2023) gave compiler-driven acceleration for generalised sparse computation for GNNs on modern GPUs; the GPC poster (EuroSys 2023) added compiler-based optimisation for sparse GNN computation; distributed GNN inference used just-in-time compilation for industry-scale graphs (EuroSys 2025 poster). The same hardware-aware discipline reached into query primitives at scale: Gem pushed scalable monotonic graph processing beyond billion-scale on a single machine (SIGMOD 2026); BCCE introduced a block-centric GPU co-design for real-time range-top-k query at scale (HPDC 2026); PGMiner attacked load-aware dynamic graph pattern matching on GPUs (IEEE TKDE 2026); DGS gave a GPU-based adaptive graph sampling framework (ACM TACO 2026); OTM delivered efficient k-order core maintenance in large-scale dynamic hypergraphs (ACM TKDD 2025); GraphGen and GraphGen+ provided distributed graph sample generation on industry-scale graphs (EuroSys 2024, 2025).

Graph learning methodology — compaction at the model level. Community detection in heterogeneous information networks without materialisation (SIGMOD 2025) is the principle of refusing dense intermediates applied to algorithms themselves. The methodology thread spans heterogeneous graph neural architecture search (ICDM 2021), multi-aspect heterogeneous graph augmentation (WWW 2023), graph triple attention networks from a decoupled perspective (KDD 2025), and a line on text-attributed graphs: robustness, trade-offs, and defences (ICLR 2026), the GDGB benchmark for generative dynamic text-attributed graph learning (ICLR 2026), taxonomy-informed representation learning in text-rich networks (KDD 2026), a comprehensive benchmark for attributed graph clustering bridging academia and industry (NeurIPS 2026), tabular foundation models as strong graph anomaly detectors (WWW 2026), and explorations of large language models as predictors in dynamic text-attributed graphs. The Graph+AI white paper (2024) surveyed the confluence that this methodology now navigates.

In this era the three components are all visibly load-bearing: the hardware spectrum (distributed clusters, GPUs, single-machine multicore), the elastic representation (temporal, streaming, sampled, hypergraph), and the service-oriented systems (GeaLearning, TeGraph, TEA) that ship the compaction to production.

6. Era III — Foundation Models: compact representations that transfer

The third act turns compact representations into a reusable object: the foundation model, pretrained once and transferred across domains, scenarios, and tasks. GraphCLIP (WWW 2025) brings the pretrain-then-transfer playbook to text-attributed graphs, making graph foundation models transferable across domains. The same idea, applied to users, yields the FIND/FOUND series: the first transferable and forecastable user-targeting foundation model (WWW 2025 industry track), FOUNDv2's unified user quantized tokenizers for user representation (KDD 2026, oral), and Query-as-Anchor's scenario-adaptive user representation via an LLM (KDD 2026). FOUNDv2 is principle 3.2 (compressive representation) at the granularity of an entire user population: a user is compacted into quantised tokens that transfer.

Foundation models are, in the language of Compact Computing, the most compact representation yet — a single pretrained object that compresses a whole graph or user population and is reused cheaply thereafter. They are also where the graph and language eras begin to fuse, since text-attributed graphs (GraphCLIP) and LLM-driven user anchors (Query-as-Anchor) point forward to Era IV.

Read across these two eras, large models are where compressed, sparse, and elastic representations become unmistakable, and where the paradigm shows it did not change for the new era — the era caught up with it. A foundation model compresses a whole graph or user population into a single reusable object — a pretrained graph encoder in GraphCLIP, quantised user tokens in FOUNDv2 — that transfers elastically across domains, scenarios, and tasks. An LLM's attention is compressed by reusing the KV cache instead of recomputing it (Decoupled Attention Fusion) and by quantising the tokens it keeps. It is sparse because genuine long-context access touches only a small fraction of the sequence — the cognitive transition layers CutAttn identifies — and because retrieval attends to a sparse set of subgraphs rather than the whole corpus (Graph RAG). It is elastic because the cache and the speculative tree grow, are reused, and are pruned at serving time as the conversation evolves (Bole). Vision–language models carry the same three modes across modalities. The cross-modal token stream is compressed by sharing the language backbone's cache across visual and textual tokens. It is sparse because a multimodal batch is reached only through a few salient patches or frames plus retrieved visual–graph evidence rather than the full pixel mass. It is elastic because the multimodal context grows with every added modality or turn — which is how vision-guided graph reasoning with an LLM, as in Foresight-on-Graph, keeps retrieval tractable. Across foundation models, LLMs, and VLMs, the same compressed, sparse, and elastic representations that served the genome and the graph now shape the transformer's context and the multimodal token stream — large models are the newest shape Compact Computing takes, not an exception to it.

7. Era IV — Retrieval-augmented reasoning, agents, and efficient LLM serving

When the data became language and knowledge, the index→retrieve→match→understand through-line re-emerged as RAG. The anchor of the era is the globally recognised survey “Graph Retrieval-Augmented Generation: A Survey” (ACM TOIS 2026, ESI Highly Cited Paper), which positions graph-structured retrieval as a first-class component of RAG. The thread extends it in both directions.

Reasoning quality. GTA-RAG augments multi-turn retrieval-augmented reasoning with graph-trajectory-augmented reinforcement learning (EMNLP 2026); M3GQA benchmarks multi-entity, multi-hop, multi-setting graph question answering (ACL 2025); subgraph retrieval is enhanced by graph–text alignment for commonsense QA (ECML PKDD 2024); Foresight-on-Graph brings vision-guided knowledge-graph reasoning with LLMs (EMNLP 2026); scalable and accurate graph reasoning is achieved with LLM-based multi-agents (AAAI 2026 Workshop); and a multi-agent framework scales graph chain-of-thought reasoning with efficient LLM serving.

Serving efficiency — Compact Computing applied to LLMs. This is where the paradigm's machinery visibly crosses into the foundation-model stack: AutoRAGTuner provides a declarative framework for automatic optimisation of RAG pipelines (EuroSys 2026 poster); Decoupled Attention Fusion accelerates RAG with efficient KV-cache reuse (EuroSys 2026 poster); CutAttn discovers cognitive transition layers for efficient long-context prefilling (NeurIPS 2026); and Bole provides efficient tree speculation for hybrid-attention language models. KV-cache reuse and tree speculation are principle 3.2 (compressive/elastic representation) applied to attention: the dense recomputation is refused, and the already-computed structure is reused — exactly the move the BWT made for strings and LightSpMV made for graphs, now made for transformers.

Era IV closes the loop: the same refusal of materialisation that compressed the genome and the graph now compresses the transformer's context, and the same full-stack co-design — from representation (cache, tokens) through kernel (prefilling, speculation) to system (RAG pipeline optimisation) — governs the LLM serving stack.

8. Cross-disciplinary reach

The four data eras are one axis on which Compact Computing generalises. The record shows a second: the same principles hold when the subject itself changes — from sequence and graph to materials, gradient states, and bare compute primitives — and compaction survives the change:

• Materials science. PyCAC, the concurrent atomistic–continuum simulation environment with a Python scripting interface (J. Materials Research 2018; TMS 2018), couples atomistic and continuum scales — a problem whose bottleneck is, again, the compaction of a multi-scale representation onto heterogeneous compute. The instance proves the principles transfer outside any single data type.
• Privacy-preserving learning. DiVerFed, distribution-aware vertical federated learning for missing information (KSEM 2024, Best Student Paper), and “Integer is Enough,” on rounding in vertical federated learning (AAAI 2024), compact the communication and the numeric representation of federated gradients — principle 3.2 applied to a distributed-privacy setting.
• Optimization methodology. AGD, an auto-switchable optimizer using stepwise gradient difference for preconditioning (NeurIPS 2023), and weighted sharpness-aware minimization (KDD 2023), are compactness moves in the optimizer state (reusing gradient differences, regularising sharpness) — proving the principles apply to the learning algorithm itself, not only its data.
• Hardware-aware deep learning. Woodpecker-DL accelerates deep neural networks via hardware-aware multifaceted optimisations — a direct ancestor of the GPU/compiler co-design later applied to GNNs and LLMs.
• Parallel primitives. LightScan (scan on many-core processors), SIMD-vectorised Kendall's tau, and parallel pairwise correlation on Xeon Phi clusters (SBAC-PAD 2016) are pure distillations (principle 3.4) — compaction at the level of the primitive, unbound to any domain.

In every instance compaction survives the change of subject — whether the compacted object is a multi-scale representation, a federated gradient, an optimizer state, or a bare primitive. Compact Computing generalises, then, on two axes at once: across the data eras, and across the disciplines that data happens to live in. That is what makes it a cross-disciplinary paradigm, not a method stitched onto one field.

9. Compact Computing as a unifying paradigm for big data and AI

Two forces define the age: data outgrows the hardware that stores and moves it, and AI, to matter, must cross from research to industry at scale. Compact Computing meets both with one lever, because underneath them is the same cost — materialising data the algorithm does not need.

For big data, the lever is to keep the data in its most compact faithful form and let the hardware chase the structure, not the volume. BWT compresses the genome; CSR compresses the graph; KV-cache reuse compresses attention; quantized tokenizers compress the user. Each compaction is a scaling law in miniature, decoupling useful work from sheer volume.

For AI, the same lever is what makes a model servable, and servability is a compaction problem at the system level. The RAG serving stack — declarative optimisation, cache reuse, long-context prefilling, speculative decoding — is the algorithm–system co-design of Era I reappearing at the transformer frontier. What held for a Smith–Waterman kernel on a GPU in 2013 holds for an attention kernel in 2026: the frontier of intelligence is set by the discipline that compacts it onto the system that runs it.

In this sense Compact Computing is the bridge from big data to artificial intelligence: the invariant that makes large data tractable as models, and models tractable as services. The four eras are not a career trajectory; they are four instances of one invariant, which is why the work can move across all of them without changing its core.

10. Scaling Data Intelligence: the scope of impact and application value

If Compact Computing is the paradigm, Scaling Data Intelligence names the reach it has achieved. The phrase captures the persistent goal behind the work — making large-scale data searchable, matchable, and understandable — at every scale the data reaches. Three properties show why that reach is broad and deep enough to deserve a single name rather than a list of separate projects.

It spans data eras without changing its core. Sequence, graph, foundation-model, and RAG/LLM-serving data are all handled by the same invariant; the mission moves across them without restructuring. Compact Computing is the physics that keeps the through-line intact as the data changes underneath it.

It spans disciplines. The same compactness moves recur in bioinformatics, fintech and trust intelligence, materials simulation, privacy-preserving learning, optimization, and large-model systems. “Scaling Data Intelligence” therefore names an impact that is not confined to one field — genome, graph, LLM, and cross-disciplinary work are different instantiations of the same compaction-driven scaling, with no implicit hierarchy among them.

It is grounded in deployed impact, not only publications. The survey “Graph Retrieval-Augmented Generation” is an ESI Highly Cited Paper; GeaLearning/TuGraph is recognised at the World Internet Conference and broke the OGB proteins world record; the work spans NeurIPS/ICLR/KDD/SIGMOD/WWW/ACL/EMNLP/EuroSys; and the algorithms and systems run behind a hundred-million-customer fintech platform. The application value is concrete: compaction that operates at industrial scale, not only in the lab.

Taken together, Compact Computing's impact is large enough — across data modalities, disciplines, hardware eras, and the research-to-industry gap — that Scaling Data Intelligence is the right name for what it does, and the right ambition to build on from here: the scalability of intelligence is a compaction problem, and the work is to keep solving it across whatever data comes next.

11. Outlook and roadmap

The paradigm points to four forward directions, each already seeded in the record:

1. Compaction as a science of scaling laws. Treat each compact representation (BWT, CSR, sparse GNN kernel, KV-cache, quantized tokens) as an object whose scaling behaviour can be characterised and predicted — an attempt to state, for compaction, what scaling laws state for parameters and compute.
2. Elastic, dynamic, streaming representations as the default. The graph system stack (TeGraph, TEA, ATLAS, OTM) and the streaming-GNN line point toward a world where static materialisation is never assumed; the same default should govern LLM context and user/tokeniser representations.
3. Algorithm–system co-design for the foundation-model serving stack. AutoRAGTuner, Decoupled Attention Fusion, CutAttn, and Bole are early instances; the agenda is a unified serving compiler that treats cache reuse, speculative execution, and retrieval as first-class co-design targets, in the lineage of G-Sparse and Woodpecker-DL.
4. Cross-disciplinary compaction. Materials (PyCAC), privacy (DiVerFed), and optimization (AGD) show the principles holding across subjects beyond the four eras; the agenda is to apply them deliberately to scientific and industrial domains where data growth has outpaced compaction effort — quantitative finance, (bio)medicine, climate and earth observation, and the simulation sciences.

The through-line of the work — searchable, matchable, understandable — is also the through-line of the field. Compact Computing is the discipline that has carried it across four eras; Scaling Data Intelligence is the name for carrying it forward.

---

References (selected, formally published work)

Genome / Sequence Intelligence Era I

1. Yongchao Liu, B. Schmidt, D. L. Maskell. “CUSHAW: a CUDA compatible short read aligner to large genomes based on the Burrows–Wheeler transform.” Bioinformatics, 2012.
2. Yongchao Liu, T. Hankeln, B. Schmidt. “Parallel and space-efficient construction of Burrows–Wheeler transform and suffix array for big genome data.” IEEE/ACM TCBB, 2016.
3. Yongchao Liu, A. Wirawan, B. Schmidt. “CUDASW++ 3.0: accelerating Smith–Waterman protein database search by coupling CPU and GPU SIMD instructions.” BMC Bioinformatics, 2013.
4. Yongchao Liu, B. Schmidt, D. L. Maskell. “Parallelized short read assembly of large genomes using de Bruijn graphs.” BMC Bioinformatics, 2011. (first large-graph compute problem)
5. Yongchao Liu, B. Schmidt, D. L. Maskell. “DecGPU: distributed error correction on massively parallel graphics processing units using CUDA and MPI.” BMC Bioinformatics, 2011.
6. Yongchao Liu, J. Schröder, B. Schmidt. “Musket: a multistage k-mer spectrum based error corrector for Illumina sequence data.” Bioinformatics, 2013.
7. Yongchao Liu, M. Loewer, S. Aluru, B. Schmidt. “SNVSniffer: an integrated caller for germline and somatic SNVs based on Bayesian models.” IEEE BIBM 2015 / BMC Systems Biology, 2016.
8. Yongchao Liu, T. Tran, F. Lauenroth, B. Schmidt. “SWAPHI-LS: Smith–Waterman algorithm on Xeon Phi coprocessors for long DNA sequences.” IEEE Cluster 2014 (Best Paper Award Recommendation).
9. H. Lan, W. Liu, Yongchao Liu, B. Schmidt. “SWhybrid: a hybrid parallel framework for large-scale protein sequence database search.” IEEE IPDPS 2017.
10. Y. Chan, K. Xu, H. Lan, W. Liu, Yongchao Liu, B. Schmidt. “PUNAS: a parallel ungapped-alignment-featured seed verification for next-generation sequencing read alignment.” IEEE IPDPS 2017.
11. T. C. Pan, P. Flick, C. Jain, Yongchao Liu, S. Aluru. “Kmerind: a flexible parallel library for k-mer indexing of biological sequences on distributed memory systems.” ACM-BCB 2016 / IEEE/ACM TCBB, 2019.
12. Yongchao Liu, F. Ripp, et al. “AFS: identification and quantification of species composition by metagenomic sequencing.” Bioinformatics, 2017.
13. Yongchao Liu, B. Schmidt, D. L. Maskell. “MSAProbs: multiple sequence alignment based on pair hidden Markov models and partition function posterior probabilities.” Bioinformatics, 2010.
14. Yongchao Liu, B. Schmidt, W. Liu, D. L. Maskell. “CUDA-MEME: accelerating motif discovery in biological sequences using CUDA-enabled graphics processing units.” Pattern Recognition Letters, 2010.
15. Yongchao Liu, B. Schmidt. “CUSHAW2-GPU: empowering faster gapped short-read alignment using GPU computing.” IEEE Design & Test, 2014.
16. Yongchao Liu, B. Popp, B. Schmidt. “CUSHAW3: sensitive and accurate base-space and color-space short-read alignment with hybrid seeding.” PLOS ONE, 2014.
17. Yongchao Liu, B. Schmidt. “CUSHAW Suite: parallel and efficient algorithms for NGS read alignment.” Book chapter, Springer, 2017.

Graph primitives, systems & learning Era II

18. Yongchao Liu, B. Schmidt. “LightSpMV: faster CSR-based sparse matrix–vector multiplication on CUDA-enabled GPUs.” IEEE ASAP 2015 (Best Paper Award); journal version J. Signal Processing Systems, 2018.
19. C. Huan, H. Liu, M. Liu, Yongchao Liu, et al. “TeGraph: a novel general-purpose temporal graph computing engine.” IEEE ICDE 2022.
20. C. Huan, Yongchao Liu, H. Zhang, et al. “TeGraph+: scalable temporal graph processing enabling flexible edge modifications.” IEEE TPDS, 2024.
21. C. Huan, S. L. Song, S. Pandey, H. Liu, Yongchao Liu, et al. “TEA: a general-purpose temporal graph random-walk engine.” EuroSys 2023.
22. C. Huan, Yongchao Liu, H. Zhang, et al. “TEA+: a novel temporal graph random-walk engine with hybrid storage architecture.” ACM TACO, 2024.
23. C. Huan, H. Zhang, Yongchao Liu, et al. “TeMatch: a fast temporal subgraph matching framework.” IEEE ICDE 2025.
24. C. Huan, S. L. Song, Yongchao Liu, et al. “T-GCN: a sampling based streaming graph neural network system with hybrid architecture.” PACT 2022.
25. Y. Jin, C. Huan, H. Zhang, Yongchao Liu, et al. “G-Sparse: compiler-driven acceleration for generalized sparse computation for graph neural networks on modern GPUs.” PACT 2023.
26. Y. Jiang, Yongchao Liu, K. Jia, H. Zhang. “ATLAS: enabling an asynchronous state-aware pipeline for efficient training of temporal graph neural networks.” ICPP 2026.
27. C. Huan, Z. Yang, H. Yang, S. Ma, R. Gu, F. Xi, Yongchao Liu, G. Chen, C. Tian. “Gem: scalable monotonic graph processing beyond billion-scale on a single machine.” SIGMOD 2026.
28. C. Huan, Z. Meng, Z. Yang, Yongchao Liu, et al. “BCCE: block-centric GPU co-design for real-time range-top-k query at scale.” HPDC 2026.
29. Y. Zhang, Y. Guo, F. Mao, Yongchao Liu, et al. “PGMiner: a load-aware dynamic graph pattern matching approach on GPUs.” IEEE TKDE, 2026.
30. J. Mei, S. Sun, C. Li, J. Wang, X. Hou, M. Guo, Yongchao Liu, C. Hong. “DGS: a GPU-based adaptive graph sampling framework.” ACM TACO, 2026.
31. X. Fang, C. Huan, H. Zhang, Yongchao Liu, S. Ma, Y. Wu, C. Zhao. “OTM: efficient K-order-based core maintenance in large-scale dynamic hypergraphs.” ACM TKDD, 2025.
32. J. Jiang, S. Yao, Y. Chen, B. He, Y. Niu, Y. Li, S. Sun, Yongchao Liu. “Community detection in heterogeneous information networks without materialization.” SIGMOD 2025.
33. Y. Zhou, Y. Cao, Yongchao Liu, et al. “Multi-aspect heterogeneous graph augmentation.” WWW 2023.
34. Y. Gao, P. Zhang, Z. Li, C. Zhou, H. Yang, Yongchao Liu, Y. Hu. “Heterogeneous graph neural architecture search.” IEEE ICDM 2021.
35. X. Wang, Y. Zhu, H. Shi, Yongchao Liu, C. Hong. “Graph triple attention networks: a decoupled perspective.” KDD 2025.
36. R. Lei, L. Yi, M. He, P. Qiu, Z. Wei, Yongchao Liu, C. Hong. “Robustness in text-attributed graph learning: insights, trade-offs, and new defenses.” ICLR 2026.
37. J. Peng, J. Ji, R. Lei, Z. Wei, Yongchao Liu, C. Hong. “GDGB: a benchmark for generative dynamic text-attributed graph learning.” ICLR 2026.
38. Yunhui Liu, T. He, Yongchao Liu, C. Yi, H. Jin, C. Hong. “Tabular foundation models are strong graph anomaly detectors.” WWW 2026.
39. Yunhui Liu, Yongchao Liu, Y. Chen, C. Hong, T. Zheng, T. He. “Learning hierarchical knowledge in text-rich networks with taxonomy-informed representation learning.” KDD 2026.
40. Yunhui Liu, P. Qiu, Y. Xing, P. Du, Yongchao Liu, C. Hong, J. Zheng, T. Zheng, T. He. “Bridging Academia and Industry: a comprehensive benchmark for attributed graph clustering.” NeurIPS 2026.
41. Ant Group et al. “Graph+AI: 大模型浪潮下的图计算.” White Paper, 2024.
42. Y. Jin, Yongchao Liu. “GPC: compiler-based optimization for sparse computations in graph neural networks.” EuroSys 2023 (poster track).
43. Y. Jin, S. Tian, Yongchao Liu, C. Hong. “GraphGen: a distributed graph sample generation framework on industry-scale graphs.” EuroSys 2024 (poster track).
44. Y. Jin, Yongchao Liu, C. Hong. “GraphGen+: advancing distributed subgraph generation and graph learning on industrial graphs.” EuroSys 2025 (poster track).
45. X. Wu, Yongchao Liu, W. Qin, C. Hong. “Distributed graph neural network inference with just-in-time compilation for industry-scale graphs.” EuroSys 2025 (poster track).

Foundation models Era III

46. Y. Zhu, H. Shi, X. Wang, Yongchao Liu, Y. Wang, B. Peng, C. Hong, S. Tang. “GraphCLIP: enhancing transferability in graph foundation models for text-attributed graphs.” WWW 2025.
47. B. Dou, B. Wang, Y. Zhu, X. Lin, Y. Xu, X. Huang, Y. Chen, Yongchao Liu, et al. “Transferable and forecastable user targeting foundation model.” WWW 2025 (industry).
48. C. He, Y. Chen, B. Dou, W. Huang, B. Wang, Yongchao Liu, et al. “FOUNDv2: learning unified user quantized tokenizers for user representation.” KDD 2026 (oral).
49. J. Yuan, Y. Xu, J. Wen, B. Wang, Z. Gao, X. Lin, Yongchao Liu, et al. “Query as Anchor: scenario-adaptive user representation via large language model.” KDD 2026.

Users & trust intelligence cross-era

50. H. Li, Z. Chen, C. Li, R. Xiao, H. Deng, P. Zhang, Yongchao Liu, H. Tang. “Path-based deep network for candidate item matching in recommenders.” SIGIR 2021.
51. Y. Yue, Yongchao Liu, S. Tong, M. Li, Z. Zhang, C. Wen, H. Bao, L. Gu, J. Gu, Y. Mu. “Adaptive optimizers with sparse group lasso for neural networks in CTR prediction.” ECML-PKDD 2021.
52. Y. Luo, G. Wang, Yongchao Liu, J. Yue, W. Cheng, B. Fei. “FAF: a risk detection framework on industry-scale graphs.” CIKM 2023.
53. S. Tian, X. Zeng, Y. Hu, B. Wang, Yongchao Liu, et al. “GraphRPM: risk pattern mining on industrial large attributed graphs.” ECML PKDD 2024.
54. X. Zhu, Z. Fu, Z. Pan, J. Jiang, C. Hong, Yongchao Liu, Y. Fang, W. Chen, C. He. “Taking the Pulse of Financial Activities with Online Graph Processing.” ACM SIGOPS OSR, 2021.
55. Ant Group et al. “图风控行业技术报告.” Industry Technical Report, 2023.

Retrieval-augmented reasoning, agents & efficient LLM serving Era IV

56. B. Peng, Y. Zhu, Yongchao Liu, X. Bo, H. Shi, C. Hong, Y. Zhang, S. Tang. “Graph retrieval-augmented generation: a survey.” ACM TOIS, 2026 (ESI Highly Cited Paper).
57. J. Chen, Yongchao Liu, P. Qiu, J. Zheng, J. Zhang, Y. Zeng, Q. Zhang, X. Luo, Z. Qiao. “GTA-RAG: graph-trajectory-augmented reinforcement learning for multi-turn retrieval-augmented reasoning.” EMNLP 2026.
58. Y. Hu, R. Lei, X. Huang, Z. Wei, Yongchao Liu. “Scalable and accurate graph reasoning with LLM-based multi-agents.” AAAI 2026 Workshop (WMAC).
59. Y. Hu, R. Lei, Z. Wei, Yongchao Liu, C. Hong, J. Zheng, J. Zhang. “Foresight-on-Graph: vision-guided knowledge graph reasoning with large language models.” EMNLP 2026.
60. B. Peng, Yongchao Liu, X. Bo, J. Guo, Y. Zhu, X. Fan, C. Hong, Y. Zhang. “M3GQA: a multi-entity multi-hop multi-setting graph question answering benchmark.” ACL 2025.
61. B. Peng, Yongchao Liu, X. Bo, S. Tian, B. Wang, C. Hong, Y. Zhang. “Subgraph retrieval enhanced by graph-text alignment for commonsense question answering.” ECML PKDD 2024.
62. X. Zeng, Yongchao Liu, Y. Luo, J. Zheng. “AutoRAGTuner: a declarative framework for automatic optimization of RAG pipelines.” EuroSys 2026 (poster).
63. X. Wu, Yongchao Liu, W. Qin, C. Hong. “Decoupled attention fusion: accelerating RAG with efficient KV cache reuse.” EuroSys 2026 (poster).
64. W. Liu, X. Wu, Yongchao Liu, H. Zhang, J. Zheng, R. Zhou. “CutAttn: discovering cognitive transition layers for efficient long-context prefilling.” NeurIPS 2026.

Cross-disciplinary explorations

65. Y. Yue, Z. Ye, J. Jiang, Yongchao Liu, K. Zhang. “AGD: an auto-switchable optimizer using stepwise gradient difference for preconditioning matrix.” NeurIPS 2023.
66. Y. Yue, J. Jiang, Z. Ye, G. Ning, Yongchao Liu, K. Zhang. “Sharpness-aware minimization revisited: weighted sharpness as a regularization term.” KDD 2023.
67. P. Qiu, Y. Pu, Yongchao Liu, W. Liu, Y. Yue, X. Zhu, L. Li, J. Li, S. Ji. “Integer is Enough: when vertical federated learning meets rounding.” AAAI 2024.
68. P. Qiu, Yongchao Liu, X. Zeng. “DiVerFed: distribution-aware vertical federated learning for missing information.” KSEM 2024 (Best Student Paper).
69. Yongchao Liu, T. Pan, S. Aluru. “Parallel pairwise correlation computation on Intel Xeon Phi clusters.” SBAC-PAD 2016.
70. S. Xu, T. Payne, H. Chen, Yongchao Liu, L. Xiong, Y. Chen, D. McDowell. “PyCAC: the concurrent atomistic-continuum simulator with a Python scripting interface.” J. Materials Research, 2018; TMS 2018.

---

This report is a self-contained position document. The full publication list, with every entry tagged by research thread (T1–T5), is maintained on the Publications page; the per-thread narratives live on the Research page.