Case Study: ECC in Processor Caches
November 16, 202643 min readbeginner
A 32 KiB cache array spends 12.5 percent on parity or on SEC-DED. The chapter weighs the two, prices byte stores and scrubbing, spreads bursts by interleaving, and checks OpenTitan's open prim_secded codes.
A processor keeps the data it is working on in caches, small and fast memory arrays built on the same die as the logic that reads them. A 32 KiB data cache holds 262,144 data bits, each one a tiny stored charge that a stray particle can disturb. When one of those bits flips, the cache faces a choice that the theory of parity and SEC-DED prepared but never had to make on real hardware. It can store one parity bit per byte and notice the flip, or it can store a SEC-DED code and repair it, and the two choices cost exactly the same number of extra bits.
Like Case Study: Codes in the Wild, this chapter proves little that is new and checks a great deal. It carries the codes of SECDED and Hsiao Codes into caches and register files in the generic terms textbooks use [1], never as a claim about any commercial processor. The one hardware it names is open source, the prim_secded encoders and decoders of the OpenTitan project, whose matrices the chapter checks from the published masks.
Every number in the chapter is recomputed by ch29_case_study_ecc_in_processor_caches.py in the python/ folder of the companion repository ecc-book-lab, and the charts are drawn by ch29_charts.py in the same folder. The GNU Octave twin ch29_case_study_ecc_in_processor_caches.m prints the same lines, as The Octave Route explains.
01.A 32 KiB Array, Two Ways
Take a data array of 32 KiB, which is 32,768 bytes or 262,144 bits, organized as 4,096 words of 64 bits each. Byte parity stores one extra bit beside each byte, which is 32,768 extra bits. A SEC-DED code stores eight check bits beside each word, which is extra bits, the same number. Figure 1 draws one word stored both ways. The overhead of either scheme is
and the array stores 294,912 bits in all.
Proof. A healthy group of nine bits has XOR 0. Flipping one bit changes the XOR of the group, because differs from for either value of . After flips the XOR has changed times, so it is 1 exactly when is odd.
The lemma says what parity buys. It detects every single flip but corrects nothing, because the parity bit says that a byte is wrong without saying which of its nine bits changed, and two flips in one byte pass unseen. A 72-bit stored word has two-bit errors. Under byte parity its bits form eight groups of nine, so of those errors fall inside one group. Byte parity misses those 288, or 11.27 percent, and reports the rest as damage it cannot repair.
A SEC-DED code spends the same eight bits on the whole word. Its minimum distance is four, so by Distance, Detection and Correction its decoder corrects every single flip among the 72 bits and flags every pair. The script confirms the second half by running all 2,556 two-bit errors through the check matrix of OpenTitan's SEC-DED Generator, and every one of them is flagged as a double error, with none passing silently.
02.Clean Lines and Dirty Lines
Suppose a read finds an error in two different caches. In the first, the line holds instructions, which the processor reads but never writes. In the second, it holds data that a store changed a moment ago and that has not yet reached the next level. The same detected error has very different consequences in the two.
Figure 2 follows both cases. A detected error in a clean line costs only time. The cache invalidates the line and fetches it again, as if the access had missed, and the program never sees the error. For an array whose every line is clean, such as an instruction cache or a write-through data cache, detection is enough and parity is a sound choice. A dirty line is different, because the correct value exists nowhere else. Parity can report the loss but cannot repair it, so the error becomes a detected unrecoverable error, the DUE of Error-Control Strategies and Performance [2]. SEC-DED repairs a single flip in place, and the data survives.
Textbook treatments of soft errors draw the same line, with parity where a clean copy always exists and an error-correcting code where it may not [3]. A write-back cache holds clean and dirty lines side by side, so it is protected for its worst line.
03.Partial Writes
Stores do not always write whole words. Take the word 0x0123456789ABCDEF, stored under the OpenTitan code with check bits , written first. A store now writes the byte 0x5A into byte 2, bits 16 to 23, which held 0xAB. The new word is 0x01234567895ACDEF, and encoding it from scratch gives check bits . Five of the eight check bits changed, those in rows 1, 2, 3, 5 and 7, although only one byte of data did.
Under byte parity the same store is simple. The parity bit of byte 2 depends on byte 2 alone, so the cache writes 0x5A, which holds four ones, together with its even-parity bit 0, and touches nothing else. Under SEC-DED every check bit can depend on every byte, so the cache follows the sequence of Figure 3.
The new check bits need not be computed from scratch. A systematic code computes its check bits as over , where is the 64-bit data column and is the data part of the check matrix, an matrix with columns .
Proof. Matrix multiplication over distributes over , so . The product is the sum , in which every term with is zero, leaving the XOR of the columns where has a one. With a single one at position the sum is alone, and XORing into flips exactly the rows where holds a one.
In the example the change in byte 2 is 0xAB XOR 0x5A, which is 0xF1, so data bits 16, 20, 21, 22 and 23 change. Their columns in the OpenTitan matrix, written row 0 first, are
and their XOR is . Then , the same check bits that encoding the new word produced.
The lemma shrinks the encoding but does not remove the read. Computing needs the old byte and updating needs the old check bits, and both must be checked first, which needs the syndrome of all 72 bits. A delta update that trusts an unchecked old byte folds any flip in it into the new check bits, and the first worked example below shows a later read then correcting a bit that was never wrong.
So a partial store into a SEC-DED array costs a read before the write. A buffer can gather stores to one word until all eight bytes are present, or the code can cover a narrower unit that matches the smallest store, at the higher overhead SECDED and Hsiao Codes tabulates for shorter words.
04.Scrubbing
A word that the program never reads can sit in an array for hours. SEC-DED will repair one flipped bit on the next read, but only if a second flip has not landed in the same word first. The danger grows with time, and a scrubber bounds the time.
How long may be? Fix one 72-bit word and let upsets strike it at a steady rate of per hour, so that upsets are expected in one interval. Slice the interval into equal pieces, each so short that it holds one upset with probability and otherwise none, independently of the others. The number of upsets is then a binomial count, as in Probability for Coding, and
As grows, tends to , a standard limit of calculus, and tends to the same value, since the two differ by a factor that tends to 1. So tends to and to , and the same limit for a general count gives the model below.
Proof. The events , and cannot happen together, and between them they cover every outcome, so their probabilities add to 1. Hence , which is the stated form with .
Proof. Write . Then , and the product rule gives , so by the fundamental theorem of calculus . For the factor is at most 1, so . For the lower bound, let . Then and for , so never decreases there and . Hence . Subtracting gives , and dividing by gives the fraction .
For a daily scrub at the assumed rate, , so one word collects two upsets in a day with probability , and the square law is accurate to a fraction of itself. The real question, though, is the whole array over its working life.
Proof. Give each word an indicator that is 1 when the word collects two or more upsets in one interval and 0 otherwise. Each indicator has expectation at , so by linearity of expectation, from Probability for Coding, the expected loss in one interval is . A time that is a whole number of intervals holds of them, and otherwise is the long-run count of intervals per time , so the loss is . Multiplying the bounds of the square-law theorem by , and using , gives the two bounds, which differ only by the factor that tends to 1 as shrinks.
The model ignores repairs by ordinary reads and counts two strikes on the same bit as a loss although they cancel, so it slightly overstates the loss. A word that collects exactly two upsets is a DUE, because SEC-DED flags two flips, while one with three or more can be miscorrected silently, the hazard Lab: Measuring Miscorrection measures, though such words are only about of the loss for a daily scrub, for a 30-day scrub and for a year without scrubbing.
Table 1. A 4,096-word array at an illustrative 1,000 FIT per word over one year of 8,760 hours, for four scrub intervals
| Scrub interval | Words lost a year | ||
|---|---|---|---|
| 1 hour | |||
| 1 day, 24 hours | |||
| 1 week, 168 hours | |||
| 30 days, 720 hours |
Source: reproduced by ch29_case_study_ecc_in_processor_caches.py.
Table 1 and Figure 4 show the corollary at work, with each longer interval multiplying the loss by about the same factor as the interval. With no scrubbing at all for a year, , and an expected 0.15624 of the array's 4,096 words, a fraction of them, hold two or more upsets by the year's end, 363 times the daily-scrub figure. The ratio is 363 rather than 365 because at the larger the factor has fallen to about 0.994.
The loss grows as but only linearly in , so a harsher environment needs a much shorter interval, while a scrubber need not be fast, only regular. Each pass competes with the program for the array, which sets a lower limit on . Saleh, Serrano and Patel analyzed scrubbing for memories under single-error-correcting codes in depth [5].
05.Bursts and Interleaving
The Poisson model treats upsets as independent single flips, but one particle strike can disturb several neighboring cells at once [4]. Beyond SECDED answered this in its section Interleaving Instead of Check Bits, and in a cache the arrangement works as follows. Take one physical row of 288 cells holding four 72-bit words. In the interleaved layout, cell holds bit of word , so cell 9 holds bit 2 of word 1. In the side-by-side layout, word fills cells to . Figure 5 shows the first 16 cells both ways.
Proof. Two of the integers differ by an amount between 1 and . Two integers leave the same remainder on division by 4 exactly when their difference is a multiple of 4, and no number from 1 to 3 is a multiple of 4.
In the interleaved row a cell's word is its remainder on division by 4, so by the lemma a burst of one to four adjacent cells touches each word at most once, and SEC-DED corrects every word. The script checks every position, bursts of one to four cells, and finds no word with more than one flip. Longer bursts lose the guarantee gradually. Any eight consecutive integers hold each remainder exactly twice, so a burst of five to eight cells puts at most two flips in a word, which SEC-DED still detects.
Side by side, a burst of three or four cells spans at most two words, so one takes at least two flips, and a two-cell burst is corrected only when it straddles one of the three word boundaries. In all, 855 bursts of two to four cells leave some word uncorrectable, against none interleaved. Interleaving adds no check bits, and in an array that already stores several words in each row and selects one with a column multiplexer, it changes only which cells feed which word.
06.The Decoder in the Read Path
A SEC-DED decoder works on every read. In the OpenTitan code each syndrome bit is the XOR of 27 inputs, which a tree of two-input gates computes in five levels, since , and the corrector then flips the bit the syndrome names. A read that waits for the corrector pays those levels on every access, even the vast majority with no error.
A generic remedy, shown in Figure 6, is to use the data before it is checked. The raw word goes at once to the instructions that need it while the syndrome is computed in parallel, and a nonzero syndrome cancels the dependent work and replays it with the corrected word. The decoder's delay leaves the common case, at the price of a replay path that verification must reach.
Speculation needs one firm rule. The check must finish before any result computed from unchecked data becomes permanent, such as a store reaching memory or an instruction retiring. An array of clean lines can instead treat any nonzero syndrome as a miss and fetch the line again, so the read path needs no corrector. The Ibex instruction cache of Register Files and the Ibex Core works this way.
07.OpenTitan's SEC-DED Generator
OpenTitan is an open-source silicon root-of-trust project, published on GitHub as lowRISC/opentitan. Its prim_secded primitives are SystemVerilog encoders and decoders that a Python program, secded_gen.py, generates from a configuration file, secded_cfg.hjson [6] [7]. Every file was read at commit 4ced702ca207ad420fbae5226ac8685a17ebef7b, and Table 2 links each one there.
Table 2. The OpenTitan files read for this chapter, each linked at commit 4ced702ca207
| File | What it holds |
|---|---|
util/design/secded_gen.py | The generator |
util/design/data/secded_cfg.hjson | The list of codes to generate |
prim_secded_39_32_enc.sv, prim_secded_39_32_dec.sv | The Hsiao encoder and decoder |
prim_secded_72_64_enc.sv, prim_secded_72_64_dec.sv | The Hsiao encoder and decoder |
prim_secded_inv_39_32_enc.sv, prim_secded_inv_39_32_dec.sv | The inverted encoder and decoder |
prim_secded_inv_72_64_enc.sv, prim_secded_inv_72_64_dec.sv | The inverted encoder and decoder |
security.rst, icache.rst | The Ibex documentation on register-file and cache ECC |
ibex_core.sv, ibex_icache.sv | Where Ibex instantiates the codes |
Source: the lowRISC/opentitan repository at commit 4ced702ca207ad420fbae5226ac8685a17ebef7b.
Each generated encoder computes a check bit as the XOR of the data bits that a mask selects. Line 15 of prim_secded_inv_39_32_enc.sv at that commit reads data_o[33] = (^(data_i & 32'hDEBA8050)) ^ 1'b1;. The & keeps the data bits where the mask 0xDEBA8050 has a one, the leading ^ folds them into one parity bit, and the trailing ^ 1'b1 inverts the result, for a reason Inverted Codes gives. Line 15 of the plain encoder prim_secded_39_32_enc.sv differs only in lacking that inversion. Each mask is one row of the data part of the check matrix, and the script transcribes the masks of both sizes as integers.
Table 3 lists the 22 codes the configuration asks for at that commit, six Hsiao codes, five extended Hamming codes of the kind built in Hamming Codes and Perfect Codes, and an inverted version of each. Every one uses the fewest check bits that SEC-DED allows for its data width. The code leaves no freedom at all, since seven check bits admit exactly 64 distinct odd-weight columns and the code has 64 positions.
Table 3. Every code that secded_cfg.hjson asks the generator for at commit 4ced702ca207
| Kind | Codes |
|---|---|
| Hsiao | , , , , , |
| Extended Hamming | , , , , |
| Inverted Hsiao | , , , , , |
| Inverted extended Hamming | , , , , |
Source: reproduced by ch29_case_study_ecc_in_processor_caches.py.
Proof. This is the theorem of the same name in the section Hsiao's Odd-Weight Columns of SECDED and Hsiao Codes, which shows that no one, two or three such columns can sum to zero [8].
The script checks the three conditions on both matrices, and checks the conclusion directly as well, confirming that no column is the sum of two others. Figure 7 draws the matrix. All 32 of its data columns have weight three, and its rows hold 15, 15, 15, 15, 15, 15 and 13 ones, 103 in all. The matrix mixes data columns of weight three and five, because only columns of length eight have weight three, too few for 64 data bits, and each of its eight rows holds 27 ones, 216 in all.
Counting ones turns into counting gates. A syndrome bit whose row has weight is the XOR of inputs, which takes two-input XOR gates, so the syndrome needs gates and the syndrome needs . The encoder XORs only the data ones of each row, one gate fewer per row, which gives 89 gates and 200. The longest rows, of 15 and 27 inputs, need trees of 4 and 5 levels. No matrix can keep every row below the average, so the fullest row holds at least data ones at and at , and both matrices meet those floors exactly. A synthesis tool may share XOR terms between rows, so these counts are estimates, and Project: A SEC-DED Encoder and Decoder measures a real netlist instead.
SECDED and Hsiao Codes built its own and matrices under the same conditions, and the script imports them from ch20_secded_and_hsiao_codes.py and compares. Table 4 sets out the result.
Table 4. OpenTitan's Hsiao matrices against those of SECDED and Hsiao Codes, at both sizes
| Property | OpenTitan | Earlier | OpenTitan | Earlier |
|---|---|---|---|---|
| Ones in each row | 15, 15, 15, 15, 15, 15, 13 | 14, 14, 15, 15, 15, 15, 15 | 27 in each of 8 | 27 in each of 8 |
| Ones in the matrix | 103 | 103 | 216 | 216 |
| Syndrome XOR gates | 96 | 96 | 208 | 208 |
| Data columns shared | 29 of 32 | 29 of 32 | 57 of 64 | 57 of 64 |
| Shared columns at the same position | 1 | 1 | 56 | 56 |
| Codewords of weight 4 | 1,366 | 1,363 | 8,396 | 8,392 |
Source: reproduced by ch29_case_study_ecc_in_processor_caches.py.
At the two matrices share 29 of their 32 data columns, and only one of the 29 sits at the same position. OpenTitan uses the columns with ones in rows , and , the matrix of SECDED and Hsiao Codes uses , and instead, and the row weights differ even after sorting. At , 57 data columns are shared and 56 of them sit at the same positions, the row weights agree exactly, and the seven columns that differ all have weight five. The weight-five columns still differ in structure, since pairs of them share two, three or four rows 8, 16 and 4 times in OpenTitan's matrix, against 12, 8 and 8 in the earlier one.
Are the matrices the same code in a different order? Rearranging columns keeps every row's weight, so the differing row weights rule out a plain rearrangement of the matrix. But adding one row of a check matrix to another changes the matrix without changing the code, because a word passes the new checks exactly when it passes the old ones, so row weights alone cannot settle the question. The weight distribution can.
Proof. A fixed permutation of positions maps each codeword of the first code to exactly one codeword of the second and back again, so it is a one-to-one correspondence. Moving bits to new positions does not change how many of them are ones, so corresponding codewords have equal weight, and the count of each weight is the same in both codes.
OpenTitan's code has 1,366 codewords of weight four against 1,363 for the code of SECDED and Hsiao Codes, and its code has 8,396 against 8,392. By the lemma, no permutation of positions turns either code into its counterpart. The two are different choices with the same properties, because Hsiao's conditions fix the distance and the total of ones, not the matrix.
Three consequences follow for a designer. An encoder and a decoder must come from the same matrix, since a word encoded under one and checked under the other gives a nonzero syndrome for most good data. Test vectors are matrix-specific, so the check bits of the partial-write example belong to OpenTitan's matrix alone. And the weight-four count is the number of four-bit error patterns that pass with a zero syndrome, as Weight Distributions and Undetected Errors explained, so two valid Hsiao codes of the same size differ slightly in what they let through. Confirming that generated hardware implements its intended matrix is the work of Verifying ECC Hardware.
08.Inverted Codes
The encoder line quoted in OpenTitan's SEC-DED Generator ended in ^ 1'b1, which inverts check bit . The inverted encoder inverts , and the same way, and its decoder inverts them back before computing the syndrome, as Figure 8 shows, by XORing the read word with the constant 39'h2A00000000, whose ones sit at bits 33, 35 and 37. A comment in secded_gen.py at that commit gives the reason, saying that "only odd bits are inverted to avoid all-0 / all-1 encodings", and the generator puts a one at every odd-numbered check bit. For that rule gives 0xAA0000000000000000, with ones at , , and , and the script uses both constants as copied from the two inverted decoders at that commit.
Why would all zeros matter? A linear code always contains the all-zero word. An array that reads back as all zeros, because its cells are stuck, its supply has failed or a fault has cleared it, returns a valid codeword holding data 0, and a plain decoder accepts it without complaint. The inversion moves the code off the all-zero word.
Proof. Distance is the weight of the XOR, and because , so . For the second claim, suppose first that . Closure of a linear code puts in for every , and the map is one-to-one, so it fills all of , and is linear. Suppose instead that . The all-zero word equals only for , which is not in , so the translate does not contain the all-zero word. Every linear code contains it, since for any codeword , so the translate is not linear.
In hardware terms, the first half says that the inverted code keeps every guarantee of the plain one, since the decoder removes the constant and then decodes exactly as before. The second half says when the move works. The constant has syndrome under the matrix, because its ones sit on check positions whose columns are single ones, so it is not a codeword, and the inverted code does not contain the all-zero word.
Proof. The syndrome of the all-one word is , whose entry in row is the XOR of the entries of row , which is 1 when the row has odd weight and 0 when it has even weight. The word is a codeword exactly when every entry of is 0.
Every row of both OpenTitan Hsiao matrices has odd weight, so even the plain codes reject the all-one word, with syndromes and , and the inversion must not let it back in. The script checks this with the real constants. In the inverted codes the all-one read has syndrome at and at , both of weight four, so both decoders flag it as a double error. In the other direction, every row holds an even number of data ones, so all-zero and all-one data store the same check part, at and at , and no stored word is ever all zeros or all ones.
The all-zero read shows why the decoder's labels matter. At its syndrome has weight four and is flagged as a double error. At its syndrome has weight three, and the OpenTitan decoder, whose single-error flag is err_o[0] = ^syndrome_o, labels every odd-weight syndrome a single error. That syndrome equals data column 6, so OpenTitan's inverted decoder itself returns 0x00000040 and reports one repaired bit. The Ibex core of Register Files and the Ibex Core escapes the hazard only because both of its uses act on any reported error and never on the corrected data. The generator's comment is careful too, saying the inversion works for most codes with balanced fan-in and that formal assertions should prove no all-zero or all-one encoding exists. The inversion itself costs a few inverters.
09.Register Files and the Ibex Core
OpenTitan vendors the Ibex core, a small open RISC-V processor from lowRISC, which at the pinned commit can use these codes in its instruction cache and its register file. Both are options, since ICacheECC and RegFileECC default to 1'b0 in ibex_core.sv.
With ICacheECC set, ibex_icache.sv protects each tag entry, a valid bit and a 21-bit tag in the documented 4 kB configuration and zero-padded to 22 bits in larger ones, with prim_secded_inv_28_22, and each 32-bit beat of data with prim_secded_inv_39_32. The documentation says that the cache "never performs corrections" [10]. Any error in any of its RAMs cancels the hit, the request fetches from main memory as a miss would, a forced write invalidates the line, and a minor alert is raised. This is the clean-line recovery of Clean Lines and Dirty Lines, built in the open.
With SecureIbex and RegFileECC set, the core runs a shadow copy of itself on delayed inputs, and the documentation describes two register file instances, one driven by the main core and holding the data, the other driven by the shadow core and holding the corresponding check bits, which the shadow core checks [11]. In ibex_core.sv the code for the 32-bit data is prim_secded_inv_39_32, with one encoder on the write data and one decoder on each of the two read ports. In the CHERIoT configuration a second set guards each register's 35 capability bits with prim_secded_inv_64_57, zero-padded to 57 bits with only the seven check bits stored. All of these decoders leave their corrected-data outputs unconnected. The stated purpose is detecting fault injection attacks over the register file's large area, and a detected error raises a major alert rather than being corrected, so the false single error of an all-zero read raises the alert like any other.
In generic terms, a register file differs from a cache array in three ways. Its contents usually have no other copy, so every entry is in effect dirty. Its words are written whole, so it needs no read-modify-write. And its read ports feed the execution units directly, where the decoder's delay costs most, which favors checking beside use, or detecting and alerting as Ibex does. A storage code guards values at rest, while the checks of Arithmetic Codes and Checking Logic guard the logic that computes them.
10.Looking Ahead
A cache array can spend the same 12.5 percent on byte parity or on SEC-DED. Clean lines can be fetched again, so detection is enough, while dirty lines hold the only copy and need correction. A byte store into a SEC-DED word costs a read first, scrubbing keeps the loss linear in the interval, and interleaving splits a four-cell burst into four single flips. OpenTitan's open matrices meet Hsiao's conditions without matching those of SECDED and Hsiao Codes.
The gate counts here came from counting ones. Project: A SEC-DED Encoder and Decoder builds a Hsiao encoder and decoder, verifies them, and measures the gate count of a real netlist.
11.Worked Examples
12.Exercises
References
- [1]Hennessy, John L. and Patterson, David A. (2017). “Computer Architecture: A Quantitative Approach.” 6th edition. Morgan Kaufmann. https://shop.elsevier.com/books/computer-architecture/hennessy/978-0-12-811905-1
- [2]Mukherjee, Shubhendu S. and Emer, Joel and Reinhardt, Steven K. (2005). “The Soft Error Problem: An Architectural Perspective.” In Proceedings of the 11th International Symposium on High-Performance Computer Architecture (HPCA-11), pp. 243–247. doi:10.1109/HPCA.2005.37
- [3]Mukherjee, Shubu (2008). “Architecture Design for Soft Errors.” Morgan Kaufmann. doi:10.1016/B978-0-12-369529-1.X5001-0
- [4]Baumann, R. C. (2005). “Radiation-Induced Soft Errors in Advanced Semiconductor Technologies.” IEEE Transactions on Device and Materials Reliability, 5(3), pp. 305–316. doi:10.1109/TDMR.2005.853449
- [5]Saleh, A. M. and Serrano, J. J. and Patel, J. H. (1990). “Reliability of Scrubbing Recovery-Techniques for Memory Systems.” IEEE Transactions on Reliability, 39(1), pp. 114–122. doi:10.1109/24.52622
- [6]OpenTitan Project “SECDED Encoder and Decoder Generator.” lowRISC/opentitan repository, commit 4ced702ca207ad420fbae5226ac8685a17ebef7b. Read 2026-11-15. https://github.com/lowRISC/opentitan/blob/4ced702ca207ad420fbae5226ac8685a17ebef7b/util/design/secded_gen.py
- [7]OpenTitan Project “SECDED Code Configuration.” lowRISC/opentitan repository, commit 4ced702ca207ad420fbae5226ac8685a17ebef7b. Read 2026-11-15. https://github.com/lowRISC/opentitan/blob/4ced702ca207ad420fbae5226ac8685a17ebef7b/util/design/data/secded_cfg.hjson
- [8]Hsiao, M. Y. (1970). “A Class of Optimal Minimum Odd-weight-column SEC-DED Codes.” IBM Journal of Research and Development, 14(4), pp. 395–401. doi:10.1147/rd.144.0395
- [9]Lin, Shu and Costello, Jr., Daniel J. (2004). “Error Control Coding: Fundamentals and Applications.” 2nd edition. Pearson Prentice Hall.
- [10]lowRISC Ibex Project “Instruction Cache.” Ibex documentation as vendored in lowRISC/opentitan, commit 4ced702ca207ad420fbae5226ac8685a17ebef7b. Read 2026-11-15. https://github.com/lowRISC/opentitan/blob/4ced702ca207ad420fbae5226ac8685a17ebef7b/hw/vendor/lowrisc_ibex/doc/03_reference/icache.rst
- [11]lowRISC Ibex Project “Security Features.” Ibex documentation as vendored in lowRISC/opentitan, commit 4ced702ca207ad420fbae5226ac8685a17ebef7b. Read 2026-11-15. https://github.com/lowRISC/opentitan/blob/4ced702ca207ad420fbae5226ac8685a17ebef7b/hw/vendor/lowrisc_ibex/doc/03_reference/security.rst
— Anirban
Hardware–software at the seam where compilers meet microcode.