Hub-Aware Sparse Topological Overlap on Multi-Chiplet Packages

Gene co-expression network analysis turns a table of gene activity measurements into a weighted graph of genes and groups that graph into modules of genes that rise and fall together. Its most expensive step multiplies the gene-by-gene adjacency matrix by itself to count shared neighbours. Chip designers are meanwhile splitting large processors into several smaller dies, called chiplets, connected inside one package. On such systems, the traffic between dies, not the arithmetic, becomes the cost that decides performance. This proposal joins the two with one claim. If the co-expression graph is made sparse in a controlled way, by dropping only the very weak edges that the method's own power transform already pushes toward zero, then the expensive step becomes a sparse matrix product dominated by a few highly connected "hub" genes. On a multi-chiplet package, that product can run with far less cross-die traffic by copying the hubs' rows to every die once, instead of sending them repeatedly.

The claim only pays off if two things hold. The sparsified network must recover the same modules and trait associations as the standard dense analysis. The hub-copying layout must also beat both a general-purpose GPU running the dense computation and the best existing chiplet mapping method. We state early where we expect to lose: for a single bulk dataset of about 20,000 genes, the dense product is an ordinary matrix multiply that a GPU handles comfortably. The proposal targets the regime where that stops being true. That regime is many condition-specific networks built from a large single-cell atlas, or networks that include non-coding transcripts, where the dense $N \times N$ matrices no longer fit on one device. Part of the work is measuring where the crossover actually lies.

Background and the gap

Weighted gene co-expression network analysis (WGCNA) computes correlations $s_{ij}$ between genes $i$ and $j$ and raises them to a power $\beta$ to form adjacencies $A_{ij} = s_{ij}^\beta$. It then computes the topological overlap $\text{TOM}_{ij} = (l_{ij} + A_{ij})/(\min(k_i,k_j) + 1 - A_{ij})$. Here $l_{ij} = \sum_u A_{iu}A_{uj}$ counts shared neighbours and $k_i = \sum_u A_{iu}$ is a gene's total connection weight. Modules come from clustering $1-\text{TOM}$, and each module is summarised by its first principal component, the "eigengene," which is correlated with clinical traits. The method is widely applied: to cortical development proteomics by Breen et al., to RNA-binding protein modules and tumour stage by Lian et al., to the centromere-linked MMP1/TFPI breast cancer signature of Lu et al., and to the cutaneous squamous cell carcinoma module of Zou et al., which anti-correlates with CD8⁺ T cell infiltration and pointed to KLRD1. All of these papers use the method as a fixed dense pipeline. None asks what the computation costs, or whether its structure can be exploited.

Two algorithmic lines modify the pipeline without touching its cost. A graph neural network applied to cattle WGCNA replaces the module-finding step downstream of the network. Weighted clique decomposition recasts module finding as an exact combinatorial problem. Both take the dense overlap matrix as given; we change how it is computed. Multi-view methods such as HetFCM and robust multi-view co-expression inference use "heterogeneous integration" to mean merging data types. That sense of the phrase is not ours, although their larger multi-omic networks are one motivation for the high-gene-count regime.

On the hardware side, three papers motivate the work. Musavi et al. show that on arrays of up to 18 chiplets, communication between dies takes 72.6% of Transformer execution time. They attribute much of this to one-to-many broadcast messages. Gemini shows that a search over where work is placed (simulated annealing) can cut that traffic sharply for neural networks. Its search, however, encodes work as a sequence of layers with regular tensor shapes. A scale-free graph, in which a few hubs touch thousands of genes, has no such shape. Occamy, a two-chiplet RISC-V system with two stacks of high-bandwidth memory (HBM), supplies the kind of hardware we target. It has streaming units built for indirect, sparse memory access and reaches 187 GCOMP/s on sparse-times-sparse matrix products. It has never been run on a co-expression workload.

The research file claims a "cubic bottleneck" for the overlap step. We treat that claim with care. The dense $l = A^2$ is a matrix multiply, so its cubic cost is exactly the operation GPUs are best at. The honest gap is therefore not "WGCNA is too slow." It is that no one has checked whether WGCNA's own soft thresholding permits a sparse formulation. If it does, the resulting hub-skewed sparse product becomes a workload class that neither dense GPUs nor current chiplet mapping tools handle well.

Core Claim

Soft thresholding drives most adjacencies toward zero; for example, $0.5^6 \approx 0.016$. Suppose we keep every adjacency above a small cutoff $\varepsilon$ with its continuous weight, rather than setting kept edges to one as hard thresholding does. The error this introduces into the shared-neighbour count is bounded by the dropped weight:

$$|\,l_{ij} - \tilde l_{ij}\,| \le \varepsilon\,(k_i + k_j),$$

where $\tilde l_{ij}$ is the count computed from the sparsified matrix. The bound follows because each dropped term $A_{iu}A_{uj}$ has at least one factor below $\varepsilon$, and the other factor sums to at most $k_i$ or $k_j$. For peripheral genes, whose connection weight $k$ is small, this error is negligible. For hub genes it can matter, which ties the accuracy question and the hardware question to the same genes.

Scale-free structure means a small set of $h$ hub rows appears in a large fraction of all products $A_{iu}A_{uj}$. We propose three ingredients. The first is a cutoff chosen per network, controlled by module agreement rather than fixed in advance. The second is a partitioning that copies the $h$ hub rows into every chiplet's local memory once and splits the peripheral genes across chiplets. It balances work by the total degree of the genes each chiplet receives, not by their count. The third is an execution schedule under which, after the copying step, the only remaining cross-die traffic is point-to-point exchange of peripheral rows. The hypothesis is that this removes most of the broadcast traffic that Musavi et al. identify as dominant. The cost is memory, roughly $h$ times the average hub row size per chiplet, and the choice of $h$ is the central tradeoff we study.

Research Program

The first stage is purely statistical and decides whether the rest is worth doing. On each dataset we run standard dense WGCNA, then the sparsified version across a range of cutoffs $\varepsilon$ and exponents $\beta$. We measure agreement of module assignments using adjusted Rand index, eigengene-trait correlations, and whether specific published findings survive. If modules degrade before sparsity becomes substantial, for instance if fewer than 90% of entries can be dropped at an adjusted Rand index of 0.9, the hardware program stops. In that case we report the negative result, which in itself informs whether WGCNA can be made sparse.

The second stage characterises the workload. We record the degree distribution of the sparsified networks and the fraction of products that pass through the top $h$ hubs. We then generate communication traces for the sparse product under several partitionings on simulated chiplet arrays of 1×2, 3×3 and 6×3 dies with four memory modules, matching the configurations of Musavi et al. This makes our traffic numbers directly comparable to theirs.

The third stage builds the hub-copying partitioner and schedule. It is implemented as an alternative placement engine inside a Gemini-style co-exploration loop, so the search over chiplet count and size is shared across methods. We run it in two settings. One is a cycle-level model of the network between dies. The other maps the kernel onto an Occamy-class two-chiplet model using its streaming units, where the actual Occamy hardware is available.

Baselines

The naive reference point is the standard dense pipeline, run in two ways: as the reference WGCNA R implementation on a multi-core server, and as a dense matrix multiply in single and double precision on one high-memory GPU. This is the strongest practical competitor. It is what biologists would actually do, and a dense multiply of a 20,000-gene matrix is a well-optimised operation. We give it the same input matrices and exclude data loading from both sides. We report wall-clock time and energy per network. No reported result for WGCNA runtime on a GPU or any accelerator was found on Lacuna, so we measure this baseline ourselves. Beating it means lower time or energy per network at equal module agreement, above a gene count or network count we identify empirically. We expect to lose below that point and will say so.

The strongest existing chiplet method is Gemini's simulated-annealing placement, applied to the same sparse product, on the same array sizes, with the same number of search iterations. Gemini reports a 74% reduction in cross-die traffic and a 34.2% reduction in hop count on Transformer workloads. Those figures come from regular tensor workloads, and we do not assume they transfer. Beating Gemini means lower cross-die traffic and runtime on scale-free co-expression graphs under an equal search budget. For the sparse kernel itself, Occamy's 187 GCOMP/s on sparse-times-sparse products is the throughput reference. We will report our achieved fraction of that figure on WGCNA matrices rather than on its original benchmarks.

Two ablations isolate the key ingredient. The first uses the same partitioner with hub copying turned off, so hubs are placed like any other gene. The second uses hub copying with naive equal-count gene splits instead of degree-balanced ones. If the first ablation matches the full method, hub copying is not what matters. If the second matches, load balancing is not what matters.

Why not just…?

Why not just run dense WGCNA on a GPU? For a single bulk network this is a real threat, and we expect it to win. The proposal only claims an advantage when dense storage exceeds device memory, or when thousands of networks must be built. An example is one network per cell line and drug combination in the Tahoe-100M atlas, which spans 50 cell lines, 380 drugs and 3 doses according to scDataset. There, the total dense work and memory traffic add up. The crossover experiment below either establishes this regime or shows that it does not exist.

Why not just keep the top 2,000 highly variable genes? This shrinks the dense problem so far that hardware stops mattering, and a reviewer would reasonably prefer it. The risk is biological: markers such as KLRD1 matter in small cell subsets but need not be highly variable across a whole dataset. We test this directly. We run filtered WGCNA on the cutaneous squamous cell carcinoma data and check whether the module that anti-correlates with CD8⁺ T cells (r = −0.76 in Zou et al.) and KLRD1's membership in it survive. If they do, the filtering alternative wins in bulk settings and our claim narrows to the single-cell and multi-omic regime.

Why not just use Gemini's placement search unchanged? Its layer-based encoding does not describe graph rows, but a generic annealing search over row placement might still discover hub-aware layouts on its own. The ablation with equal search budget settles this. If annealing finds layouts within 10% of ours in cross-die traffic, our contribution reduces to the sparsification result plus a faster heuristic, and we will report it that way.

Proposed Experiments

The datasets are TCGA-BRCA (1,118 tumour samples), with the GSE20685 validation cohort and the published MMP1/TFPI signature from Lu et al. as a biological check. The cutaneous squamous cell carcinoma collection (GSE42677 for bulk profiles, GSE144236 for single-cell T cell profiles) is used with the published module-trait correlation. Condition-specific networks come from Tahoe-100M, which supplies the many-network, large-scale regime.

The first decisive check is the accuracy–sparsity curve: how much of the adjacency matrix can be dropped while adjusted Rand index stays above 0.9 against dense modules, the key trait correlations stay within 0.05 of their dense values, and the published genes keep their modules. We will also check that the survival AUCs obtained from the rebuilt MMP1/TFPI model stay near the reported 0.648, 0.609 and 0.624 at 1, 3 and 5 years.

The second check is traffic. On the 6×3 array, we measure the fraction of runtime spent on cross-die communication under hub copying, with Musavi et al.'s roughly 70% for neural networks as the context. We compare cross-die bytes against Gemini placement and against both ablations.

The third check is the crossover plot: time and energy per network against gene count and against number of networks, for the dense GPU baseline and for the sparse chiplet method. The proposal succeeds if three things hold together: sparsification preserves the published biology at high sparsity, hub copying clearly beats Gemini-style placement on cross-die traffic, and a crossover exists at a problem size that current single-cell or multi-omic studies actually reach. It fails informatively if any one of these does not hold.