Some optical neural-network chips store their weights in phase-change materials, films whose optical properties shift as they move between glassy and crystalline states. The appeal is that a programmed weight stays put with no power drawn. The catch is that these chips have only a few physical compute tiles, so each tile is overwritten again and again as the network runs, layer by layer. Each overwrite is a heat pulse that wears the material out. Demonstrated devices survive a little over 1600 switching events (Non-volatile electrically programmable integrated photonics with a 5-bit operation). Existing fixes pick, once and offline, an ordering of weight blocks that minimizes rewrites. They assume every cell behaves nominally. Real cells do not: each fabricated cell has its own step response, its own drift, and its own remaining life.
This note proposes making the tile-assignment decision online, at every reuse step. A scheduler chooses which physical tile receives which weight block based on the state each cell is actually in. The cost of that choice counts two things. The first is how many heat pulses the change will really take, which is asymmetric: nudging a cell toward crystalline is cheap, while moving it back requires a full melt-and-reset. The second is how noisy and how worn that particular cell is. The two-sentence version is this. Offline write-minimization breaks the moment fabrication variation and runtime repair enter the picture. A cheap per-step assignment that sees real cell states and the one-directional physics of programming can keep the accelerator accurate for many more inferences.
Core Claim
In phase-change photonic accelerators with time-multiplexed tiles, lifetime and accuracy depend on three things together: the reuse schedule, device-to-device variation, and the asymmetry of programming. They cannot be optimized separately. Compile-time proxies such as total write count, the metric ELight optimizes, will rank schedules poorly once variation and runtime remapping are present. This is the photonic version of the gap seen in chip design, where logic-level metrics correlate weakly with post-layout results (An Open-Source ML-Based Full-Stack Optimization Framework for Machine Learning Accelerators).
We claim that re-solving a small assignment problem at each reuse step, with a physically grounded cost, extends usable lifetime over the strongest composition of existing offline and runtime methods, measured as inferences until accuracy falls below a set threshold. We further claim the gain grows with the spread of device variation.
The per-step problem assigns weight blocks $b$ to physical tiles $c$ by minimizing $\sum_{(b,c)} C_{b,c}$ over one-to-one matchings, where
$$C_{b,c} = s_b\,\epsilon_c(w_b) + \lambda\,\frac{P(x_c \rightarrow w_b)}{R_c}.$$
The terms are defined as follows. $s_b$ is the block's salience, meaning how sensitive the network output is to errors in that block. $\epsilon_c(w_b)$ is the expected encoding error when tile $c$, with its own measured level curve, represents the target levels $w_b$. $P(x_c \rightarrow w_b)$ is the pulse cost of moving from the tile's current state $x_c$ to $w_b$. $R_c$ is the tile's estimated remaining endurance. $\lambda$ trades accuracy against wear.
The asymmetric pulse cost comes from the growth-dominant crystallization of Sb₂S₃. In that material, identical pulses advance the crystalline front one level at a time, while any decrease needs a melt-quench reset followed by a climb back up (Non-volatile electrically programmable integrated photonics with a 5-bit operation). So $P$ is roughly the level difference when moving upward and the reset cost plus the target level when moving downward. This is not a symmetric distance.
Relation to Prior Work
Two papers define the space, and each fixes a different half of it.
ELight cuts phase-change writes in photonic in-memory computing in three ways: write-aware training, offline column reordering, and non-uniform quantization. It reports a 22.28× reduction in total writes on 5-bit VGG8. However, it treats hardware as deterministic, and its ordering is fixed before deployment. It supplies both the problem setting and the strongest offline baseline.
DOCTOR remaps weight tiles at runtime to the least noisy cores. It does this by solving a linear assignment problem and adding sparse, data-free calibration. It restores CIFAR-10 accuracy from about 57% to over 90% under thermal drift. But it targets volatile micro-ring resonators, where rewriting is free. Its assignment cost has no wear term, so applied naively to phase-change tiles it would spend endurance freely. We reuse its assignment formulation and salience estimate, and its open simulator (github.com/ScopeX-ASU/DOCTOR). What we change is the cost function and the per-step state tracking.
Three further papers play smaller roles. Robust inverse design of Sb₂Se₃ switches (Inverse design of compact nonvolatile reconfigurable silicon photonic devices with phase-change materials) handles variation at the level of a single device, through geometry. It shows 41 levels but also a large simulation-to-silicon gap: extinction ratio above 25 dB in simulation versus above 8.5 dB measured. This motivates treating per-cell behaviour as measured rather than nominal.
Variation-aware training such as ADAPT-pNC hardens a model against a fixed distribution of component values offline. Its stated limitation is that it cannot respond to runtime change. We use it as a competing static defence.
Classical reactive repair (Reactive Plan Revision) supplies the idea of local, stability-preserving fixes over global re-solves. Our "keep the block where it is" default follows that idea.
Research Program
We will build a device-level simulator for phase-change tiles on top of the DOCTOR codebase. Each cell will have three components. The first is a level-transfer curve with per-step variation matching the reported 0.50 ± 0.16 dB step resolution. The second is a pulse accounting that separates incremental crystallization from reset. The third is an endurance budget drawn around the reported 1600-cycle figure.
The file contains no measured distribution of cell failure times. We will therefore treat the endurance spread and slow state drift as swept parameters, not as facts. Retention drift will also be modelled as a swept rate, because the file gives only a qualitative statement that intermediate levels drift (ELight).
On top of the simulator, the runtime works as follows at each reuse step. It reads the tracked state and wear of each tile. It builds the cost matrix above and solves the matching. It then either rewrites a block or leaves it in place and applies a cheap calibration offset.
The scheduling budget is set by the writes themselves. Programming takes sub-millisecond time, so an assignment over tens of tiles is small relative to the write it plans. This avoids the microsecond-latency problem that rules out slower learned schedulers. We will report measured solver time relative to write time to confirm this holds.
The analysis component is a correlation study of the proxy against the realized outcome. Across many candidate schedules, we compare the ranking given by offline total writes with the ranking given by realized lifetime-to-failure under variation. This quantifies the gap the proposal targets.
Baselines
The naive reference is ELight's non-reordered mapping: a fixed block-to-tile assignment with no write minimization and no remapping. It sets the floor for both lifetime and energy.
The strongest offline competitor is full ELight, meaning write-aware training plus column reordering plus distribution-aware quantization. It will be run with its published models (VGG8 and VGG13) and the same quantization bit widths. Its reported figures are a 22.28× write reduction on 5-bit VGG8 and more than 85% CIFAR-10 accuracy at 3 bits (ELight). We expect to reproduce the write reduction under nominal devices first, as a check on our simulator.
The strongest composite competitor is ELight's offline ordering followed by DOCTOR-style runtime remapping and calibration, with DOCTOR's noise-only assignment cost. DOCTOR's reported result is recovery from roughly 57% to over 90% on CIFAR-10, and 34% higher accuracy than on-chip training (DOCTOR). This is the combination a reviewer would assemble from existing parts, so it is the baseline to beat.
A wear-levelling baseline borrowed from memory systems rotates blocks round-robin across tiles, independent of their contents.
All methods will share several conditions: the same trained weights where the method allows it, the same simulated die and variation seeds, the same calibration budget per step, and the same tuning budget for any trade-off parameter. For our method that parameter is $\lambda$; for DOCTOR it is the drift threshold.
Beating the composite baseline means two things. First, a statistically clear increase in inferences-until-accuracy-drops-below-threshold at matched energy per inference. Second, no loss of accuracy at the start of life. We set the threshold at 2 points below clean accuracy, and will also report the full curve.
Two ablations isolate the ingredients. One replaces the asymmetric pulse cost with a symmetric level distance, which isolates the programming-physics term. The other replaces measured per-cell curves with nominal curves, which isolates variation awareness.
Why not just…?
Why not just run ELight offline and DOCTOR at runtime, in sequence? This is the most serious alternative, and it is the composite baseline above. The argument against it is structural. DOCTOR's remapping moves blocks to minimize noise, which discards the adjacency that made ELight's ordering cheap. DOCTOR also has no reason to avoid melt-quench resets. The experiment will settle whether this matters: if the composite matches our lifetime within noise, the proposal's claim fails.
Why not just use standard wear levelling? Rotation spreads writes evenly, but it ignores what is already stored in each tile. A rotation can therefore force resets that a content-aware choice would avoid, and it can place salient blocks on the noisiest cells. The round-robin baseline measures this directly. We expect it to help endurance and hurt accuracy.
Why not just train the network to tolerate variation and skip runtime scheduling? Offline variation-aware training such as ADAPT-pNC is cheap and might absorb static per-cell spread. It cannot account for cells that wear out or drift after deployment. It also does not reduce writes at all. We will add variation-aware training to every method, including ours, so that any remaining lifetime gap is due to scheduling.
Why not just provision spare tiles? Spares extend life linearly at area cost. Our method should be compared at equal tile count, and we will also report how many spare tiles the composite baseline needs to match our lifetime. That converts the gain into chip area.
Proposed Experiments
We will evaluate on MNIST, Fashion-MNIST, CIFAR-10 and CIFAR-100 with VGG8 and VGG13, matching ELight's setup. Bit widths will be 3 and 5, drawn from the 32-level Sb₂S₃ and 41-level Sb₂Se₃ device models. The primary metric is inferences until accuracy falls a set margin below clean accuracy. Secondary metrics are total pulses, split into incremental and reset, energy per inference derived from the reported ~10 fJ/nm³ programming energy density, accuracy over time, and solver time relative to write time.
The first decisive check is a sweep of device variation spread from zero upward. At zero spread, gains from the variation-aware part must vanish, and any remaining gain must come from the asymmetric cost term. If our method outperforms at zero spread only through the variation term, the simulator is flawed.
The second check is the rank-correlation study. If offline write count predicts realized lifetime well once variation is present, the motivating gap is small, and a better offline ordering would suffice.
The third check measures lifetime against the composite ELight-plus-DOCTOR baseline at matched energy. This is the result on which the proposal stands or falls.
References
- Non-volatile electrically programmable integrated photonics with a 5-bit operation
- An Open-Source ML-Based Full-Stack Optimization Framework for Machine Learning Accelerators
- ELight: Enabling Efficient Photonic In-Memory Neurocomputing with Life Enhancement
- DOCTOR: Dynamic On-Chip Temporal Variation Remediation Toward Self-Corrected Photonic Tensor Accelerators
- Inverse design of compact nonvolatile reconfigurable silicon photonic devices with phase-change materials
- ADAPT-pNC: Mitigating Device Variability and Sensor Noise in Printed Neuromorphic Circuits with SO Adaptive Learnable Filters
- Reactive Plan Revision