Skip to content
STIMSMITH

Endless Instruction Stream Generation

Technique WIKI v1 · 5/28/2026

Endless Instruction Stream Generation is a processor-verification stimulus technique that presents a finite generated instruction sequence as an unbounded stream, for example by cyclically repeating entries from a Translation Buffer. In the cited cross-level verification work, this style of single endless stream is discussed as a custom, architecture-specific stimulus-generation approach and contrasted with a coverage-guided fuzzing setup that generates separate test cases.

Overview

Endless Instruction Stream Generation is a technique for processor verification in which a finite generated sequence of instructions is made available to a processor as an effectively unbounded instruction stream. In the documented implementation, a Translation Buffer is reset so that it delivers the same instruction sequence as it did immediately after initialization; by cyclic repetition, the buffer provides an endless instruction stream for verification.

Mechanism

The cited RV32I example describes a fuzzer producing a fixed-size test vector that is loaded into a Translation Buffer. Each buffer entry has the size of a 32-bit instruction. For example, a 160-bit test vector yields five 32-bit instruction entries. Processor instruction fetches are then served from the buffer, and cyclic reuse of the buffer contents makes the finite vector behave like an endless stream.

This makes the technique a form of processor-level input stimulus generation: the generated data is interpreted as processor instructions and supplied to the model or core under verification.

Use in cross-level processor verification

The technique is discussed in the context of comparing processor behavior across abstraction levels, such as a reference instruction set simulator (ISS) and an RTL processor core. The broader co-simulation problem is to feed both models the same instruction sequences while supporting arbitrary instruction sequences and possible infinite loops.

The same source also highlights a verification issue that is adjacent to endless instruction-stream execution: comparing an ISS and a pipelined RTL core requires synchronization. Register values should be compared after the relevant instruction has completed, and comparisons are most useful when a register value has actually changed, because comparing too frequently can cause performance degradation and false mismatches.

Limitations and comparison with testcase-based fuzzing

The paper Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing describes a prior setup that uses a custom instruction stream generator to generate a single endless instruction stream. It characterizes that setup as highly architecture-specific and requiring significant manual effort to support different configurations and to set up effectively.

The paper contrasts this with its own approach, which generates test cases one after another rather than relying on a single endless stream. That approach is described as supporting arbitrary control flows, including self-loops, as well as load/store instructions, while using existing fuzzing algorithms with lightweight domain-specific extensions.

LINKED ENTITIES

2 links
Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing COMPARES_WITH
Processor-level Input Stimuli Generation IMPLEMENTS

CITATIONS

6 sources
6 citations
[1] A Translation Buffer can provide an endless instruction stream by cyclically repeating the same instruction sequence after reset. Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing
[2] In the RV32I example, a 160-bit fuzzer-generated test vector is loaded into a Translation Buffer whose entries are 32-bit instructions, producing five entries. Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing
[3] The broader co-simulation setup must feed the same instruction sequences to a reference ISS and the core under test while supporting arbitrary instruction sequences and potential infinite loops. Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing
[4] Register-value comparison is used to detect functional mismatches, but ISS/RTL comparison requires synchronization because pipelined RTL cores do not generally expose a simple instruction-completion signal. Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing
[5] The paper characterizes a custom generator for a single endless instruction stream as architecture-specific and requiring significant setup effort. Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing
[6] The paper contrasts the single-endless-stream approach with testcase-by-testcase generation that supports arbitrary control flows, including self-loops, and load/store instructions. Efficient Cross-Level Processor Verification using Coverage-guided Fuzzing