---
title: 'MELISO+: Distributed RRAM In-Memory Computing'
url: https://www.emergentmind.com/topics/meliso
type: topic
---

# MELISO+: Distributed RRAM In-Memory Computing

Searching arXiv for MELISO+ and related RRAM in-memory computing papers.
MELISO+ is a full-stack, distributed framework for energy-efficient in-memory computing with RRAM crossbar arrays, introduced as an extension of MELISO (“In-Memory Linear Solver”) for large-scale matrix-vector multiplication and linear solves under realistic device non-idealities [2508.13298]. Its design couples algorithm–hardware co-design, a software-driven virtualization layer, and a two-tier error-correction mechanism intended to suppress device variability at runtime while enabling distributed execution of matrices up to \(65{,}000\times65{,}000\) via MPI across \(R\times C\) tiles of RRAM crossbars [2508.13298]. In the broader lineage of RRAM benchmarking and solver design, MELISO+ is situated between the baseline device-aware VMM benchmarking framework MELISO [2409.06140] and later optimization-oriented integrations in distributed in-memory primal-dual hybrid gradient methods [2509.21137].

## 1. Origins and conceptual scope

MELISO+ derives from MELISO, an end-to-end software framework built on top of the NeuroSim+ macro-model for device-aware benchmarking of analog vector–matrix multiplication in RRAM crossbar arrays [2409.06140]. MELISO exposes the relationship between device characteristics such as conductance window, precision, non-linear programming behavior, and cycle-to-cycle variability, and downstream computing accuracy metrics, thereby providing a basis for principled algorithm–device co-design [2409.06140].

Within that trajectory, MELISO+ realizes several directions that MELISO had outlined only as prospective extensions: virtualization and parallelization primitives for arbitrarily sized crossbar arrays, integration with solver workflows, and advanced error-correction layers to trade off energy, latency, and accuracy [2409.06140]. In its defined form, MELISO+ comprises a Python front end called MelisoPy, a C++ engine built on NeuroSim+, first- and second-order error-correction modules implemented in C++ and Python, and a distributed backend using MPI [2508.13298].

Its primary objectives are threefold. First, it co-designs algorithms and hardware, specifically crossbar arrays with host CPU/GPU control, for large-scale matrix-vector multiplication and linear solves beyond the physical limits of a single RRAM tile [2508.13298]. Second, it integrates a two-tier error-correction algorithm that suppresses device nonidealities at runtime, enabling low-precision RRAM devices to match or exceed the accuracy of “best-in-class” high-precision devices such as EpiRAM [2508.13298]. Third, it supports distributed execution through partitioning, virtualization, and aggregation across multiple nodes [2508.13298].

A plausible implication is that MELISO+ should be understood less as a single kernel and more as a cross-layer computational stack: device model, array simulator, runtime correction, distributed orchestration, and application-facing solver interface.

## 2. System architecture and execution pipeline

At the interface level, MelisoPy specifies the problem size \(\mathbf A\in\mathbb R^{m\times n}\), vector \(\mathbf x\in\mathbb R^n\), device type, write-verify tolerance \(\epsilon\), number of write-verify iterations \(N\), and regularization \(\lambda\) [2508.13298]. The C++ engine, built on NeuroSim+, simulates analog MVM on each RRAM crossbar and returns noisy outputs together with energy and latency estimates [2508.13298]. Error-correction modules then denoise the raw crossbar outputs, while the distributed backend partitions \(\mathbf A\) and \(\mathbf x\) across nodes and aggregates partial results via MPI [2508.13298].

The internal pipeline includes adjustableMatWriteAndVerify and adjustableVecWriteAndVerify, raw MVM evaluations for \(A\tilde x\), \(\tilde A x\), and \(\tilde A\tilde x\), a first-order error-correction combiner, second-order denoising through denoiseLeastSquare, per-cell energy and latency accounting, distributed dispatch, and post-processing of relative error norms and scaling curves [2508.13298].

The relationship to the original MELISO pipeline is direct. MELISO already separated a forward pass, in which Python and Cython passed problem data and device parameters to a modified NeuroSim+ C++ backend, from a backward or analysis pass, in which hardware outputs were rescaled and compared against a software baseline \(I_{\rm sw}=A\cdot x\) [2409.06140]. MELISO+ retains that basic separation but adds runtime correction and distributed execution as first-class components [2508.13298].

In solver-oriented deployments, MELISO+ can also function as the physics-based analog MVM backend invoked by higher-level routines. In the distributed PDHG setting, matmulAccel calls MELISO+ to simulate each analog matrix–vector multiplication under realistic non-idealities, while host-side routines perform preprocessing, block-matrix construction, norm estimation, and iterative updates [2509.21137]. In that formulation, MELISO+ supplies the energy, latency, and noisy MVM outputs on which the solver’s performance estimates depend [2509.21137].

## 3. Two-tier error-correction mechanism

The central algorithmic contribution of MELISO+ is a two-stage error-correction scheme that addresses first-order and second-order errors induced by RRAM programming variability [2508.13298]. The framework models programmed quantities as
\[
\mathbf{\tilde A} = \mathcal H(\mathbf A)\approx \mathbf A\,(1+\pmb\epsilon_{\!A}), \qquad
\mathbf{\tilde x} = \mathcal H(\mathbf x)\approx \mathbf x\,(1+\pmb\epsilon_{\!x}),
\]
where \(\mathcal H\) is the device write-verify mapping and \(\pmb\epsilon\) denotes per-element programming errors [2508.13298].

To cancel dominant first-order terms, MELISO+ forms three MVMs on the crossbar:
\[
\mathbf u = A\,\tilde x,\qquad
\mathbf v = \tilde A\,x,\qquad
\mathbf w = \tilde A\,\tilde x.
\]
It then combines them as
\[
\mathbf p=\mathbf v+\mathbf u-\mathbf w,
\]
which yields
\[
\mathbf p = A x\,\bigl(1 - \epsilon_A\,\epsilon_x\bigr),
\]
so that all \(\mathcal O(\epsilon)\) terms vanish and only \(\mathcal O(\epsilon^2)\) terms remain [2508.13298].

The residual vector \(\mathbf p = A x + \boldsymbol\eta\) is then processed by a second-order denoising stage based on Tikhonov-regularized least squares:
\[
\mathbf y \;=\;\underset{\mathbf z}{\arg\min}\;\|\,\mathbf p-\mathbf z\|_2^2\;+\;\lambda\,\|L\,\mathbf z\|_2^2,
\qquad
\mathbf y(\lambda)\;=\;(I+\lambda\,L^\top L)^{-1}\,\mathbf p,
\]
where \(L\in\mathbb R^{n\times n}\) is the first-difference matrix with \(1\) on the diagonal and \(-1\) on the superdiagonal [2508.13298]. With \(\lambda\in(0,1)\), this step is reported to suppress residual second-order errors while preserving the smooth structure of \(Ax\) [2508.13298].

The quantitative effect reported for this two-tier scheme is substantial: first- and second-order error correction reduce \(\epsilon_{||\cdot||_2}\) and \(\epsilon_{||\cdot||_\infty}\) by more than \(90\%\) on all device types compared to no error correction, in experiments averaged over 100 trials and two \(66\times66\) matrices with condition numbers \(\kappa=1.23\) and \(\kappa=4324\) [2508.13298]. This directly addresses a limitation documented in MELISO, where non-linearity and cycle-to-cycle variability could strongly inflate mean error and variance in VMM outputs [2409.06140].

A common misconception is that RRAM accuracy must be obtained solely by moving to intrinsically high-precision devices. MELISO+ does not assume that premise. Instead, it explicitly reports that low-precision TaO\(_x\)-HfO\(_x\) devices can achieve post-EC accuracy equal to EpiRAM while retaining major energy and latency advantages [2508.13298].

## 4. Distributed virtualization and scalability

MELISO+ addresses the physical size limits of a single crossbar tile through a virtualization and partitioning strategy for large matrices [2508.13298]. In a multi-chiplet system of \(R\times C\) RRAM crossbars, each of size \(r\times c\), the native MVM capacity is \((Rr)\times(Cc)\). To process matrices up to \(65{,}025\times65{,}025\), the framework applies zero-padding when \(m<Rr\) or \(n<Cc\), block partitioning into
\[
\Bigl\lceil \frac{m}{Rr}\Bigr\rceil\times\Bigl\lceil \frac{n}{Cc}\Bigr\rceil
\]
subblocks of size at most \(Rr\times Cc\), and further subdivision into \(R\times C\) subchunks aligned to the tile grid [2508.13298].

Each chunk \(\mathbf A^{(i)}\in\mathbb R^{m_i\times n_i}\) with matching \(\mathbf x^{(i)}\in\mathbb R^{n_i}\) is sent to a distinct compute node through MPI, where local “write-verify + two-tier EC” MVM is performed and a partial \(\mathbf y^{(i)}\) is returned; the final output \(\mathbf y\) is assembled via MPI reduce [2508.13298]. The framework reports near-linear weak scaling and strong scaling up to \(65{,}000^2\), with virtualization overhead diminishing as each crossbar approaches the native block size [2508.13298].

This virtualization strategy corresponds closely to the roadmap anticipated in MELISO, which had identified parallelization and virtualization for arbitrarily sized crossbar arrays as a future extension [2409.06140]. In MELISO+, it becomes operational infrastructure rather than a speculative direction.

In the PDHG-based distributed optimization setting, the same distributed logic is paired with a symmetric block-matrix representation \(M\leftarrow[[0,K];[K^\top,0]]\), a one-time encode step, and repeated calls to matmulAccel without reprogramming the crossbar during the inner loop [2509.21137]. This suggests that MELISO+ is not restricted to stand-alone MVM benchmarking; it can serve as a reusable substrate for iterative optimization algorithms whose dominant kernels are fixed linear operators.

## 5. Device, circuit, and performance model

MELISO+ is built around a physics-based RRAM crossbar model that includes device variability, parasitic circuits, peripheral overhead, and write-endurance considerations [2509.21137]. In the PDHG deployment, each crossbar cell is represented by a conductance \(G_{ij}\) controlled via write pulses, with read current
\[
I_{ij}=G_{ij}\cdot V_{\rm cell}^{\alpha},
\]
where \(\alpha\approx1\) for linear devices or \(\alpha>1\) under nonlinearity [2509.21137]. Device-to-device and cycle-to-cycle variability are modeled multiplicatively,
\[
G_{ij,real}=G_{ij,target}\cdot(1+\xi_{ij}), \qquad E[\xi]=0,\quad Var(\xi)=\sigma_{\rm var}^2,
\]
and read noise is added as
\[
I_{ij,measured}=G_{ij,real}\cdot V_{\rm cell}+\eta_{ij},\qquad \eta\sim N(0,\sigma_{\rm noise}^2)
\]
[2509.21137].

Array-level parasitics are incorporated through row and column wire resistance \(r_w\), with IR-drop handled by nodal analysis, while peripheral DAC and ADC energy and latency are also parameterized [2509.21137]. The ideal analog MVM is
\[
y_i=\sum_{j=1}^n G_{ij,target}\cdot V_j,
\]
and the non-ideal form includes variability, IR-drop, and noise [2509.21137]. Energy and latency per MVM are modeled as
\[
E_{\rm MVM}=nE_{\rm DAC}+mE_{\rm ADC}+E_{\rm crossbar}(G,r_w),
\qquad
T_{\rm MVM}=T_{\rm DAC}+T_{\rm ADC}+T_{\rm read}(m,n)
\]
[2509.21137].

The device-aware basis for this modeling is consistent with MELISO, which parameterized conductance window \(MW=G_{\max}/G_{\min}\), weight precision \(b\), write non-linearity through an exponential update law, and cycle-to-cycle variability through a normal distribution on actual conductance after programming [2409.06140]. MELISO’s benchmarking demonstrated that increasing precision or memory window decreases MSE, while non-linearity and variability strongly worsen error distributions [2409.06140]. MELISO+ can therefore be seen as extending the same device-level realism into distributed execution and corrective runtime computation.

The following table summarizes architectural components explicitly identified for MELISO+.

| Component | Role | Implementation context |
|---|---|---|
| MelisoPy | Problem specification and EC parameters | Python front end [2508.13298] |
| NeuroSim+-based engine | Analog MVM simulation, energy and latency reporting | C++ [2508.13298] |
| Error-correction modules | First- and second-order denoising | C++ and Python [2508.13298] |
| Distributed orchestrator | Partitioning, dispatch, reduction | MPI [2508.13298] |

## 6. Quantitative characteristics and comparative position

MELISO+ reports performance in terms of write energy \(\mathrm E_w\), write latency \(\mathrm L_w\), and relative output error norms
\[
\epsilon_{||\cdot||_p}=\frac{\|\,\mathbf y-\mathbf b\|_p}{\|\mathbf b\|_p},\qquad p\in\{2,\infty\},
\]
where \(\mathbf b=Ax\) is ground truth and \(\mathbf y\) is the corrected output [2508.13298]. Across the reported \(66\times66\) benchmarks, error correction reduces both \(\epsilon_{||\cdot||_2}\) and \(\epsilon_{||\cdot||_\infty}\) by more than \(90\%\) on all device types [2508.13298].

For low-precision TaO\(_x\)-HfO\(_x\) devices, the native write energy and latency are reported as \(\mathrm E_w\approx5\times10^{-8}\,\mathrm J\) and \(\mathrm L_w\approx2\times10^{-4}\,\mathrm s\), while EpiRAM is reported at \(\mathrm E_w\approx1\times10^{-4}\,\mathrm J\) and \(\mathrm L_w\approx4.5\times10^{-2}\,\mathrm s\) [2508.13298]. After error correction, the low-precision devices achieve accuracy equal to EpiRAM while still offering \(2\)–\(5\) orders of magnitude lower energy and \(100\times\) lower latency [2508.13298]. Compared to high-precision alternatives, MELISO+ reports end-to-end energy efficiency improvements of \(10^3\)–\(10^5\times\) and latency reductions of \(100\times\) [2508.13298].

The comparative argument is sharpened against alternative architectures. Conventional von Neumann designs with digital ECC are described as incurring \(2\)–\(3\times\) latency overhead and large area and energy for parity bits, while single-tile RRAM MVM demonstrations are described as limited to \(\le 1{,}024^2\) scales and lacking onboard EC [2508.13298]. High-precision devices such as EpiRAM are described as avoiding EC but at approximately \(10^3\times\) higher energy per write and \(50\times\) higher latency than TaO\(_x\)-HfO\(_x\) combined with MELISO+ [2508.13298].

In the PDHG solver application, MELISO+ is associated with up to three orders of magnitude reductions in energy consumption and latency relative to GPU-accelerated solvers on large-scale linear programs [2509.21137]. More specifically, the paper reports Step 1 energy reductions of \(29\times\)–\(878\times\) with latency speedups up to \(5.3\times\), Step 2 energy reductions up to approximately \(5{,}000\times\) with latency speedups up to approximately \(300\times\), and overall end-to-end savings ranging from \(8\times\)–\(521\times\) for EpiRAM and \(36\times\)–\(1{,}800\times\) for TaO\(_x\)-HfO\(_x\), with corresponding latency speedups [2509.21137].

These results should not be conflated with claims about arbitrary application accuracy. The reported metrics are tied to specific workloads, device models, and benchmark settings. What they establish directly is that MELISO+ can alter the device-selection tradeoff by substituting runtime correction and distributed execution for brute-force hardware precision.

## 7. Applications, design implications, and research context

The most explicit application domain advanced for MELISO+ is high-dimensional AI computation. Large language models and generative AI are identified as depending heavily on large MVMs, including multi-head attention and fully connected layers, as well as iterative solvers such as mixture-of-experts routing [2508.13298]. MELISO+ is described as mapping naturally to these workloads through tile-grid parallelism for very large matrices, low write energy and latency for inference and analog in-memory fine-tuning, two-tier error correction for per-layer numerical fidelity, and software virtualization for dynamic sparsity patterns and MoE sub-routing [2508.13298].

A second application context is large-scale linear optimization. In the PDHG formulation, MELISO+ models device physics, variability, noise, write endurance, IR drop, and ADC/DAC overhead while providing realistic analog MVMs for Lanczos norm estimation and PDHG iterations [2509.21137]. A key co-design principle there is minimizing writes: the symmetric block mapping means \(K\) and \(K^\top\) are never re-encoded, the crossbar is programmed once through closed-loop write-verify, and the inner loop changes only vectors rather than matrix conductances [2509.21137]. Step sizes are then selected with a noise-aware safety margin so that convergence is guaranteed despite analog perturbations [2509.21137].

Several design implications follow directly from the combined MELISO and MELISO+ literature. First, device metrics such as memory window, precision, non-linearity, and variability remain first-order determinants of raw analog error [2409.06140]. Second, MELISO+ demonstrates that runtime algorithmic compensation can partially substitute for intrinsically higher device precision [2508.13298]. Third, scalability in RRAM-based IMC depends not only on larger arrays but also on virtualization, partitioning, and host-level orchestration [2508.13298]. Fourth, optimization and AI workloads benefit when algorithms are reformulated to reduce reprogramming frequency, since write cycles carry both energy cost and endurance implications [2509.21137].

The principal controversy addressed by this body of work concerns whether analog RRAM non-idealities fundamentally preclude accurate large-scale computation. MELISO documented the severity of those non-idealities in benchmark VMM settings [2409.06140]. MELISO+ responds not by denying the underlying device constraints, but by embedding correction, virtualization, and solver-aware scheduling into the execution stack [2508.13298]. This suggests a research program in which device physics, architecture, and numerical algorithms are treated as inseparable layers of the same computational system.

Source: https://www.emergentmind.com/topics/meliso