Compiling a Genetic Algorithm into a Fixed-Depth Network for Sub-Slot Puncturing

When a 5G base station must squeeze an urgent low-latency packet into a channel already carrying a broadband stream, it "punctures" the broadband transmission. Puncturing means overwriting some of the stream's radio resources and hoping its error-correcting code absorbs the damage. Choosing which resources to overwrite is a combinatorial search: genetic algorithms handle it well, but they are too slow and too unpredictable in runtime to fit the scheduler's time budget. That budget is a 125-microsecond transmission slot in the fastest 5G configuration. This note proposes to unroll a genetic algorithm into a fixed number of learned layers. A genetic algorithm (GA) evolves a population of candidate solutions by selecting good ones, recombining them, and randomly mutating them. Unrolling it means each "generation" becomes one network layer whose crossover and mutation behavior is trained offline, while selection keeps the best candidate found so far. The result keeps the GA's strengths: every output is feasible by construction, and the best candidate never gets worse from one generation to the next. It also gains the fixed, short runtime of a feedforward network.

The second idea makes the search aware of what the broadband payload actually is. Image ciphers built to resist differential attacks spread each pixel's influence over the whole ciphertext. Here a differential attack means an adversary who encrypts two images differing in one pixel and studies how the outputs differ. A side effect of that spreading is that a single undecodable code block can make an entire encrypted frame unrecoverable. We give the scheduler a per-payload "dependency span," the set of radio code blocks a frame needs in order to be decrypted. We then test whether span-aware puncturing matters, or whether simply choosing a cipher with a short span makes the problem disappear. Plainly stated, the contribution is a deterministic-latency, learned GA for puncturing, plus a measured answer to how far a cipher's diffusion design should reach into the scheduler.

Core Claim

Our claim concerns a genetic algorithm unrolled to a fixed depth of $K$ generations with a parallel population of $P$ candidates. Each layer has trained mutation rates and crossover masks, which are conditioned on the channel and on the traffic that arrived in the current slot. A learned predictor scores each candidate in place of running the full decoder. We claim this design matches or exceeds deep-reinforcement-learning puncturing in broadband goodput, meaning bits successfully decoded. It should also have a lower worst-case runtime, a tighter runtime spread, and far less offline training.

Elitism means the best candidate is always carried forward unchanged. Because of this, the output is guaranteed under the predictor to be no worse than whatever heuristic seeds the population. That is a feasibility-and-improvement certificate that a policy network does not give.

The decisive test is whether the learned operators beat a plain GA with the same $K$ and $P$. If they do not, the contribution reduces to "run a short GA on a GPU." That is still useful, but it is a different paper.

Where This Sits

The latency problem is documented by two papers. On the Throughput of Large-but-Finite MIMO Networks Using Schedulers uses a "Queen-based" GA for MIMO user selection, the problem of choosing which users each antenna array serves at once. It counts scheduling time as lost transmission time. At a delay-cost factor of $\xi = 0.002$, net throughput peaks at 45 iterations and falls afterwards. That paper motivates our objective, but its GA is an ordinary loop, and it does not address puncturing or service heterogeneity.

Cyrus+ supplies the problem and the strongest competitor. It is a Soft Actor-Critic reinforcement-learning puncturer for O-RAN, the open, disaggregated radio access network architecture. It runs in 94.4 µs inside the 125 µs slot. It needs a separate feasibility-enforcement module, and its offline training takes 21 hours. We keep its goodput objective and its simulator setup, and replace the policy network with an unrolled evolutionary search.

The method comes from the deep-unfolding literature. Unfolding WMMSE Using Graph Neural Networks turns 100 iterations of a power-allocation solver into 4 learned layers, giving an 8× speedup with no loss of sum-rate. Deep FlexQP unrolls ADMM, an iterative splitting method for constrained optimization, and uses small recurrent networks to predict its step parameters at each iteration. Both unroll deterministic numerical solvers. Neither handles discrete, population-based search, and that is the gap we fill.

Two further papers supply ingredients. Deep Learning for Distributed Optimization contributes stochastic binarization layers: they output discrete bits in the forward pass and pass a smooth surrogate gradient backward. We reuse this to train the mutation operators. Genetic Algorithms with Neural Cost Predictor for Hierarchical Vehicle Routing shows that a learned scorer can stand in for an expensive fitness function inside a GA, which is how we keep candidate scoring within the slot.

The cipher side is set by three papers. An Image Encryption Scheme Based on the Three-dimensional Chaotic Logistic Map and TDADL-IE reach near-ideal NPCR, the Number of Pixels Change Rate (about 99.61% for 8-bit images). They do so with diffusion across the whole image, and both assume a lossless channel. The GRC lightweight cipher encrypts 512×512 frames in 2 µs on an FPGA, but it was not studied under lossy, punctured links.

Research Program

The search problem. Each slot, we encode a puncturing decision as a binary chromosome over the broadband resource blocks the scheduler is allowed to overwrite. Crossover and mutation act on a representation that is valid by construction: a fixed number of punctured units per arriving urgent packet, placed only within the allowed time and frequency positions. Infeasible schedules therefore cannot arise and no repair step is needed.

The scoring function. Fitness is predicted payload recovery, not raw goodput. Let $x$ be a puncturing pattern. Let $p_b(x)$ be the predicted probability that broadband code block $b$ decodes. Let $S(f)$ be the set of code blocks that frame $f$, of size $|f|$ bytes, needs in order to be decrypted. The fitness is

$$U(x) = \sum_{f} |f| \prod_{b \in S(f)} p_b(x).$$

If $S(f)$ contains one block per frame, $U$ is ordinary expected goodput. If $S(f)$ covers the whole frame, as with whole-image chaotic diffusion, one weak block costs the entire frame. A small network trained on decoder outcomes from the link-level simulator supplies $p_b(x)$. Latency enters as in the MIMO GA paper: we report net utility after subtracting the scheduler's actual runtime, and we choose $K$ by that criterion.

The unrolled GA. Layer $k$ takes the population, the per-candidate scores, and a summary of the channel and traffic. It outputs per-gene mutation probabilities and crossover masks, which are sampled through stochastic binarization layers. Selection is a fixed top-$P$ operation that always keeps the elite candidate. The initial population is seeded with a greedy puncturer plus random feasible patterns.

We train end to end by maximizing $U$ of the final elite over simulated slots. Because the layers are fixed and the population is evaluated in parallel, runtime is set by $K$ and $P$ alone, with no early stopping. We will measure that runtime on a GPU and estimate it for an FPGA.

The diffusion-span study. We encrypt broadband image payloads with each of the following:

  • a nonce-based stream cipher, AES in counter mode (span of one block);
  • GRC (span set by its Feistel block structure);
  • the 3D logistic-map scheme (whole-frame span).

For each cipher we measure the dependency span directly, by corrupting a single code block and counting how many plaintext pixels fail to decrypt. Alongside that we measure NPCR and UACI (Unified Average Changing Intensity, ideal value about 33.46%) under the usual deterministic test.

We expect the study to show three things:

  • which ciphers combine high plaintext sensitivity with contained decryption errors (forward-only chaining can);
  • how much frame recovery span-blind puncturing loses;
  • whether span-aware puncturing recovers that loss.

Baselines

The naive reference point is random puncturing (RP) as implemented in Cyrus+. That paper reports 14.430 Mb/s broadband goodput at an urgent-packet arrival probability of 0.08, against 27.384 Mb/s for its SeF heuristic. Beating random puncturing is necessary but uninformative.

A greedy puncturer chooses the blocks with the most error-correction slack, as estimated by the same predictor $p_b$. It is the cheapest competitor and also our seed. Since elitism guarantees we never fall below it under the predictor, the comparison that matters is how far we rise above it under the true decoder.

The strongest existing method is Cyrus+, which reports 49.852 Mb/s goodput at an arrival probability of 0.08, an average runtime of 94.4 µs, and 21 hours of training (Cyrus+). We will re-run it rather than copy its numbers: same CDL-C and CDL-D channels, same 5G NR numerology 3, same GPU. We match its training budget in GPU-hours to ours and also give it a budget equal to its reported 21 hours. Beating it means either equal or higher goodput at a 99th-percentile runtime below its average, or equal runtime at higher goodput. We must also show lower runtime variance and less than a tenth of its training time. Matching it on goodput while cutting training and tail latency by that margin would already count as a win.

The ablation that isolates our key ingredient is a plain GA with identical $K$, $P$, predictor, seeding, and GPU-parallel evaluation, but with fixed hand-tuned mutation and crossover rates. A second reference is the same GA run to convergence with no time limit. It gives an upper bound and shows how much of that bound the unrolled version captures within the slot.

For the cipher study, the baseline is span-blind fitness (plain expected goodput), compared with span-aware fitness, across all three ciphers.

Why not just…?

Why not just use Cyrus+ or another reinforcement-learning policy? It already fits the slot, and it is the main threat on goodput. Its costs are elsewhere: 21 hours of training, a separate feasibility enforcer because raw policy outputs can be invalid, and no guarantee relative to a heuristic. The head-to-head comparison in the Baselines section settles it. If Cyrus+ wins on goodput by a clear margin at matched runtime, our remaining claims are cheaper training and a guaranteed floor, and we will report it that way.

Why not just run a short ordinary GA on a GPU? GA populations parallelize naturally. The MIMO scheduling paper shows that most of the GA's gain arrives early, about 95% of maximum throughput within 200 iterations. A few generations on a GPU could therefore be enough. This is the most serious threat to the learned operators, and the fixed-rate ablation tests it directly. If the learned operators add nothing at small $K$, we will say so, and the contribution narrows to the latency-aware, span-aware fitness and the deterministic-depth design.

Why not just use a greedy rule? In Cyrus+, the SeF heuristic reaches about 55% of Cyrus+ goodput. That is evidence that simple rules leave substantial goodput unclaimed when urgent traffic is heavy. Greedy is also our seed, so any gain we report is measured against it.

Why not just encrypt with a nonce-based stream cipher and keep cryptography out of the scheduler? This may well be the right engineering answer. With a one-block span, $U$ reduces to plain goodput and span-awareness has nothing to add. A random nonce per frame also achieves what differential-resistance tests aim for, without whole-frame diffusion, even though it scores poorly on the deterministic NPCR test. Our study is built to confirm or refute this. If it holds, the finding is still worth publishing: NPCR-optimal whole-image diffusion is the wrong design target for punctured links. Span-aware scheduling then matters only for legacy chaotic ciphers.

Proposed Experiments

We will reimplement the standards-compliant link-level simulator setup used in Cyrus+ (CDL-C and CDL-D channels, numerology 3), sweeping urgent-packet arrival probability around the reported operating point of 0.08. Broadband payloads will be 512×512 grayscale road frames of the kind used for GRC, the "Peppers" image, and medical images like those used in TDADL-IE.

The metrics are:

  • broadband goodput;
  • recovered-frame rate;
  • urgent-packet deadline satisfaction;
  • scheduler runtime (mean, 99th percentile, and standard deviation against the 125 µs slot);
  • net utility after delay cost;
  • training GPU-hours;
  • for each cipher: NPCR, UACI, and measured decryption-error span.

Three checks decide the outcome. First, the unrolled GA must beat the fixed-rate GA at matched $K$ and $P$. Second, it must match Cyrus+ goodput with a 99th-percentile runtime inside the slot. Third, span-aware puncturing must recover a measurable share of lost frames under whole-frame-diffusion ciphers but not under counter mode. If that third result appears, it shows the cross-layer coupling is real and bounded by cipher design.

A generalization test will train on one channel model and user load and test on the other channel model and unseen loads. It asks whether conditioning the operators on channel and traffic transfers the way the graph-network unfolding of WMMSE did across network sizes.