← All industry projectsHardware-aware compression
LG DISPLAY · 2023–2024

Hardware-aware compression

Vector quantization and memory dataflow co-design

I co-designed a vector-quantization encoder and memory dataflow to reduce storage and external-memory requirements for display compensation. Compact indices and a shared codebook support reconstruction every frame, with the encoder implemented in Verilog and integrated into an ASIC.

IndustryLG Display · 2023–2024RTL / ASIC
View project flow ↓
Project diagram

From compensation blocks to compact indices

Vector quantization example: the input block 8, 7, 8, 8 matches codebook row 1, which stores 8, 7, 8, 7. The block is stored as index 1; a DDR index retrieves the shared SRAM vector to reconstruct the block.

Each block of compensation values is represented by the index of its nearest shared code vector. During operation, indices in DDR select vectors from the SRAM codebook to reconstruct the values. Green traces one example block; numbers and block sizes are illustrative.

Vector quantization and runtime memory placement

01 / THE PROBLEM

How can a compact representation support per-frame display compensation?

Display compensation maps change during compensation cycles but must be read every frame to generate drive current. Full maps are too large for on-chip SRAM, while NAND can retain them across power cycles but cannot supply the required real-time access. External DDR fills that gap at a cost in channels and board resources. A useful compression method therefore has to reduce stored data while keeping reconstruction simple and predictable in hardware.

02 / THE APPROACH

Design the representation and its memory path together

01

Represent value blocks with shared codewords

Group compensation values into vectors, match each to a representative codebook entry, and store its compact index. At reconstruction time, the index selects the codeword. The slide illustrates the same encoding/decoding idea with image blocks; the deployed application stores compensation data.

02

Replace expensive encoder operations

Conventional VQ relies on multiplier-heavy Euclidean distance, repeated full-dataset passes, and batch accumulation. I adapted the encoder with deterministic codebook construction, shift-based approximate distance calculations, and immediate incremental updates driven by accumulated error. These changes reduce arithmetic and accumulation-buffer demands.

03

Separate persistence from per-frame access

During the power-off compensation cycle, the encoder compresses sensed data and stores codebooks and indices in NAND. At power-on, codebooks load into SRAM and index maps into DDR. Each frame then obtains compensation values through codebook lookup, keeping the reconstruction path simple.

04

Validate the algorithm as an RTL implementation

I implemented the encoder in Verilog and took it through functional simulation, synthesis, and FPGA testing before ASIC integration. This connected the compression algorithm to the actual arithmetic, storage, and access constraints of the display pipeline.

03 / MY CONTRIBUTION

Compression algorithm, dataflow, and Verilog RTL

Co-designed the hardware-oriented vector-quantization algorithm and memory dataflow, implemented the encoder in Verilog, and carried the design through simulation, synthesis, FPGA validation, and ASIC integration.

04 / EVALUATION

Setup and results

The project covered algorithm prototyping, the encoder RTL, memory-dataflow design, and simulation/synthesis/FPGA validation for ASIC integration. The reported compression ratio describes the representation; DDR channel reduction describes the resulting system-memory requirement.

Data reduction
8:1
Compact codebooks and index maps replace the original compensation representation.
DDR channels
2 → 1
Reduced the required external-memory channel count.
Saved per panel
≈$3
Reported implementation cost reduction.
05 / OUTCOME & SCOPE

Compression that changes the memory requirement

The design achieved 8:1 data reduction and reduced DDR requirements from two channels to one, with approximately $3 saved per panel. Its main contribution was aligning the compressed representation, a hardware-feasible encoder, and the per-frame memory path so the algorithm produced a concrete system benefit.