From 4c17b3862423d3f806bae831423a9efbaf279bc6 Mon Sep 17 00:00:00 2001 From: Sisi Wang Date: Sat, 18 Apr 2026 21:33:32 -0700 Subject: [PATCH 01/12] Reimplement B14.py to fix issue #69(100% coverage w/ less vectors) and added B14 documentation --- docs/B14.adoc | 151 ++++++++++++++++++++++++++++++++ src/cover_float/testgen/B14.py | 152 +++++++++++++++------------------ 2 files changed, 222 insertions(+), 81 deletions(-) create mode 100644 docs/B14.adoc diff --git a/docs/B14.adoc b/docs/B14.adoc new file mode 100644 index 0000000..5ead72b --- /dev/null +++ b/docs/B14.adoc @@ -0,0 +1,151 @@ += Floating Point Model Documentation +:toc: +:toclevels: 3 +:sectnums: +:stem: latexmath + + +== B14 Multiply-Add: Shift + +Aharoni et al. + +=== Description + +This model tests every possible value for a shift between the addends of the +multiply-add (FMA) operation. For the difference between the unbiased +exponent of the addend and the unbiased exponent of the result of the +multiplication, test the following values: + +1. A value smaller than `-(2p + 1)` +2. All the values in the range `[-(2p + 1), (p + 1)]` +3. A value larger than `(p + 1)` + +*Precisions Supported:* `BF_16`, `FP_16`, `FP_32`, `FP_64`, `FP_128` + +*Operations Supported:* FMADD, FMSUB, FNMADD, FNMSUB + +*Rounding Mode:* Round-to-Nearest-Even (RNE) + +== Implementation + +=== General Implementation + +An FMA (fused multiply-add) unit computes `X = A * B + C`, where `X` is the +result, `A` and `B` are the multiplicands, and `C` is the addend. + +The shift is defined as the difference between the unbiased exponent of the +multiplication product and the unbiased exponent of the addend `C`: + +[source] +---- +S = unbiased_exp(product) - unbiased_exp(C) + = (unbiased_exp(A) + unbiased_exp(B)) - unbiased_exp(C) +---- + +In order for a processor to properly execute a fused multiply-add operation, +it must first compute the product and then align the significand of the +addend with the significand of the multiplication result (or the other way +around) so that both quantities share the same exponent before addition or +subtraction is performed. + +=== Definitions + +`p`:: `mantissa_bits + 1`, the precision +`min_u`:: Minimum unbiased exponent for the format +`max_u`:: Maximum unbiased exponent for the format +`bias`:: `(2 ^ (E - 1)) - 1`, exponent bias for the format +`A`, `B`, `C`:: The three FMA operands +`P = A * B`:: The intermediate product +`S`:: The target shift, measured as `unbiased_exp(P) - unbiased_exp(C)` + +=== General Procedure + +The generator produces a single group of test vectors per format, +corresponding directly to Aharoni's three shift regions: + +[cols="2,1,2,2",options="header"] +|=== +| Group | Aharoni Case | Shift Constraint | Vectors per format + +| Group 1 (small_diff) | 1 | `S <= -(2p + 2)` | 4 +| Group 2 (mid_diff sweep) | 2 | `S ∈ [-(2p + 1), (p + 1)]` | `(3p + 3) * 4` +| Group 3 (large_diff) | 3 | `S >= (p + 2)` | 4 +|=== + +Where `S = unbiased_exp(product) - unbiased_exp(C)` and +`p = mantissa_bits + 1`. + +For every group, the generator loops through the four FMA operations +{FMADD, FMSUB, FNMADD, FNMSUB}, and the rounding mode is fixed at RNE. The +sign, mantissa, and exponent-split choices are randomized within the +constraints of the target shift. + +== Test Implementation + +=== Group 1 — The Deep-Negative Shift (small_diff) + +*Goal:* Drive the alignment shift into the region `S <= -(2p + 2)`. This +region corresponds to the case where the addend `C` is so much larger than +the product `P` that `P` effectively becomes a sticky bit relative to `C`. + +*Intermediate Constraint:* `S <= -(2p + 2)`, achieved by pairing a +small-exponent product with a large-exponent addend. + +*Construction Method:* + +1. Given the fixed target shift `S = -(2p + 2)`, pick an unbiased addend + exponent `C_u` from the reachable range + `[max(min_u, 2*min_u - S), min(max_u, 2*max_u - S)] ∩ [min_u, max_u]`. +2. Compute the required unbiased product exponent `P_u = S + C_u`. +3. Split `P_u = A_u + B_u` with both in `[min_u, max_u]` by randomly picking + `A_u ∈ [max(min_u, P_u - max_u), min(max_u, P_u - min_u)]` and setting + `B_u = P_u - A_u`. +4. Emit the test vector with random signs and random mantissas for `A`, + `B`, `C`. + +*Total Test Cases for Group 1:* `1 shift x 4 operations = 4 vectors per format.` + +=== Group 2 — The Mid Range Sweep (mid_diff) + +*Goal:* Exercise every integer alignment shift in the range where the +addend and product have comparable magnitudes. Every integer shift +`S ∈ [-(2p + 1), (p + 1)]` is visited. + +*Intermediate Constraint:* `S` takes every value in `[-(2p + 1), (p + 1)]`. + +*Construction Method:* For each target shift `S` in the sweep and for each +of the four FMA operations, the generator applies the same construction as +Group 1. + +*Total Test Cases for Group 2:* `(3p + 3) shifts x 4 operations = (12p + 12) vectors per format.` + +=== Group 3 — The Deep-Positive Shift (large_diff) + +*Goal:* Drive the alignment shift into the region `S >= (p + 2)`. This +region corresponds to the case where the product `P` is so much larger than +the addend `C` that `C` effectively becomes a sticky bit relative to `P`. + +*Intermediate Constraint:* `S >= (p + 2)`, achieved by pairing a +large-exponent product with a small-exponent addend. + +*Construction Method:* Same as Group 1. + +*Total Test Cases for Group 3:* `1 shift x 4 operations = 4 vectors per format.` + +=== Vector Count Summary + +NOTE: There is no redundancy between groups, and no vector contributes to +more than one shift. + +[cols="1,1,1,1,1,1",options="header"] +|=== +| Precision | p | Group 1 | Group 2 | Group 3 | Total per format + +| BF16 | 8 | 4 | 108 | 4 | 116 +| F16 | 11 | 4 | 144 | 4 | 152 +| F32 | 24 | 4 | 300 | 4 | 308 +| F64 | 53 | 4 | 648 | 4 | 656 +| F128 | 113 | 4 | 1,368 | 4 | 1,376 +|=== + +*Total across 5 formats:* 2,608 vectors. \ No newline at end of file diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index 1dbbb2f..b89a4e3 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -1,20 +1,14 @@ # By: Sisi Wang # B14.py -# Fuse Multiply Add(FMA) +# Fused Multiply-Add (FMA) # B14 -> Multiply-Add: Shift - - -# This model tests every possible value for a shift between the addends of the multiply-add operation. -# For the difference between the unbiased exponent of the addend and the unbiased exponent of the result of the -# multiplication, test the following values: -# 1.A value smaller than -(2* p + 1) -# 2.All the values in the range:[-(2*p +1), (p +1) ] -# 3.A value larger than (p + 1) - +# +# Tests every possible value of the alignment shift between the multiplication +# result and the addend in a fused multiply-add (FMA) operation. The shift is +# defined as S = unbiased_exp(A*B) - unbiased_exp(C). import random from pathlib import Path -from random import seed from typing import TextIO import cover_float.common.constants as const @@ -34,76 +28,72 @@ def decimalComponentsToHex(fmt: str, sign: int, biased_exp: int, mantissa: int) def generate_b14_tests(test_f: TextIO, cover_f: TextIO, fmt: str) -> None: - _p = const.MANTISSA_BITS[fmt] + 1 # defines the precision we are working with - bias = (1 << (const.EXPONENT_BITS[fmt] - 1)) - 1 # calculates the correct bias depending on fmt - min_exp = const.BIASED_EXP[fmt][0] - max_exp = const.BIASED_EXP[fmt][1] - - # Define Format-Specific Shift Limits - # This defines the sweep range [ -limit, +limit ] - # We want to cover the full range of (ExpA + ExpB) - ExpC - SHIFT_LIMITS = { - const.FMT_HALF: 31, # Max exp diff is ~30. We use 31 - const.FMT_BF16: 256, # Max exp diff is ~255. We use 256 - const.FMT_SINGLE: 256, # Max exp diff is ~255. We use 256 - const.FMT_DOUBLE: 2050, # Max exp diff is ~2047. We use 2050 - const.FMT_QUAD: 32001, # Max exp diff is ~32001 - } - - # Get the limit (default to 500 if format missing) - limit = SHIFT_LIMITS.get(fmt, 500) - - start_shift = -limit - end_shift = limit - - for target_shift in range(start_shift, end_shift + 1): - for op in OPS: - hashval = reproducible_hash(op + fmt + "b14") # Unique hash for (op, fmt) seed - seed(hashval) # Seed the random generator for reproducibility - # Randomize & generate 15 variations per shift - for _ in range(15): - ##Part 1: Randomize a and b exponents (and make sure their product is valid) - # a: - # safe margin defined to keep 'a' somewhat central to avoid immediate overflows - safe_margin = int(max_exp / 4) - exp_a = random.randint(min_exp + safe_margin, max_exp - safe_margin) - # b: - low_bound = max(min_exp, bias - 50) - high_bound = min(max_exp, bias + 50) - # Pick 'b' near the bias (so product exponent is close to exp_a) or random. This is simplified; - # we might want more range here. - exp_b = random.randint(low_bound, high_bound) - - ##Part 2: Calculate the addends - # Calculate product exponent:Exp_Prod = Exp_A + Exp_B - Bias - exp_prod = exp_a + exp_b - bias - - # Calculate required Exp_C to hit the Target Shift: target_shift = Exp_C - Exp_Prod - exp_c = target_shift + exp_prod - - # Quick validity check -> If the calculated exp_c is invalid (too big/small), skip this variation - if exp_c < min_exp or exp_c > max_exp: - continue - - ##Part 3: Generate mantissa componenets + Assemble >:3 - # Create random signs (0 or 1) - sign_a = random.randint(0, 1) - sign_b = random.randint(0, 1) - sign_c = random.randint(0, 1) - - # Randomize mantissas -> Uses random bits to trigger different carry/rounding paths. - mant_a = random.getrandbits(const.MANTISSA_BITS[fmt]) - mant_b = random.getrandbits(const.MANTISSA_BITS[fmt]) - mant_c = random.getrandbits(const.MANTISSA_BITS[fmt]) - - # Converts the components created above to hex - hex_a = decimalComponentsToHex(fmt, sign_a, exp_a, mant_a) - hex_b = decimalComponentsToHex(fmt, sign_b, exp_b, mant_b) - hex_c = decimalComponentsToHex(fmt, sign_c, exp_c, mant_c) - - run_and_store_test_vector( - f"{op}_{const.ROUND_NEAR_EVEN}_{hex_a}_{hex_b}_{hex_c}_{fmt}_{32 * '0'}_{fmt}_00", test_f, cover_f - ) + p = const.MANTISSA_BITS[fmt] + 1 + min_u, max_u = const.UNBIASED_EXP[fmt] + bias = const.BIAS[fmt] + + # Build shift list: [small_anchor] + [mid_range] + [large_anchor] + small_anchor = -(2 * p + 2) + mid_range = list(range(-(2 * p + 1), (p + 1) + 1)) + large_anchor = p + 2 + shift_list = [small_anchor, *mid_range, large_anchor] + + for op in OPS: + # Seed once per (fmt, op) pair, outside the shift loop + rng = random.Random(reproducible_hash(f"B14 {fmt} {op}")) + + for target_shift in shift_list: + # Section 5: Exponent Construction Algorithm + + # 1. Pick unbiased C exponent + c_lo = max(min_u, 2 * min_u - target_shift) + c_hi = min(max_u, 2 * max_u - target_shift) + + if c_lo > c_hi: + continue + + c_u = rng.randint(c_lo, c_hi) + + # 2. Compute unbiased product exponent + p_u = target_shift + c_u + + # 3. Split p_u into a_u + b_u + a_lo = max(min_u, p_u - max_u) + a_hi = min(max_u, p_u - min_u) + + if a_lo > a_hi: + continue + + a_u = rng.randint(a_lo, a_hi) + b_u = p_u - a_u + + # 4. Convert to biased exponents + exp_a = a_u + bias + exp_b = b_u + bias + exp_c = c_u + bias + + # Section 7: Test Vector Assembly + + # Draw random signs and mantissas + sign_a = rng.randint(0, 1) + sign_b = rng.randint(0, 1) + sign_c = rng.randint(0, 1) + + mant_a = rng.getrandbits(const.MANTISSA_BITS[fmt]) + mant_b = rng.getrandbits(const.MANTISSA_BITS[fmt]) + mant_c = rng.getrandbits(const.MANTISSA_BITS[fmt]) + + # Encode operands to hex + hex_a = decimalComponentsToHex(fmt, sign_a, exp_a, mant_a) + hex_b = decimalComponentsToHex(fmt, sign_b, exp_b, mant_b) + hex_c = decimalComponentsToHex(fmt, sign_c, exp_c, mant_c) + + # Emit test vector + run_and_store_test_vector( + f"{op}_{const.ROUND_NEAR_EVEN}_{hex_a}_{hex_b}_{hex_c}_{fmt}_{32 * '0'}_{fmt}_00", + test_f, + cover_f, + ) def main() -> None: From 613a25291af0f296397ecc56d31ddeee2252473f Mon Sep 17 00:00:00 2001 From: Sisi Wang Date: Sat, 18 Apr 2026 22:11:38 -0700 Subject: [PATCH 02/12] fix formatting issues Made-with: Cursor --- config.svh | 24 ++++++++++++------------ docs/B14.adoc | 2 +- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/config.svh b/config.svh index f30a234..36756a7 100644 --- a/config.svh +++ b/config.svh @@ -1,28 +1,28 @@ // define macros for which models to check coverage for // e.g. `define COVER_B1 for model B1 -`define COVER_B1 -`define COVER_B2 -`define COVER_B3 -`define COVER_B4 -`define COVER_B5 +// `define COVER_B1 +// `define COVER_B2 +// `define COVER_B3 +// `define COVER_B4 +// `define COVER_B5 // `define COVER_B6 // `define COVER_B7 // `define COVER_B8 -`define COVER_B9 -`define COVER_B10 +// `define COVER_B9 +// `define COVER_B10 // `define COVER_B11 -`define COVER_B12 +// `define COVER_B12 // `define COVER_B13 `define COVER_B14 // `define COVER_B15 -`define COVER_B16 +// `define COVER_B16 // `define COVER_B17 // `define COVER_B18 -`define COVER_B19 +// `define COVER_B19 // `define COVER_B20 -`define COVER_B21 -`define COVER_B22 +// `define COVER_B21 +// `define COVER_B22 // `define COVER_B23 // `define COVER_B24 // `define COVER_B25 diff --git a/docs/B14.adoc b/docs/B14.adoc index 5ead72b..84ea798 100644 --- a/docs/B14.adoc +++ b/docs/B14.adoc @@ -148,4 +148,4 @@ more than one shift. | F128 | 113 | 4 | 1,368 | 4 | 1,376 |=== -*Total across 5 formats:* 2,608 vectors. \ No newline at end of file +*Total across 5 formats:* 2,608 vectors From d663ecd90b747b5bfa1302ef2c32775dd8d65f7a Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Thu, 23 Apr 2026 18:08:15 -0700 Subject: [PATCH 03/12] added path (removed from resolving the wrong conflict :p) --- src/cover_float/testgen/B14.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index 7e4193e..3700ec6 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -10,7 +10,8 @@ import logging import random from random import seed -from typing import TextIO, cast +from pathlib import Path +from typing import TextIO import cover_float.common.constants as const import cover_float.common.log as log @@ -18,6 +19,7 @@ from cover_float.reference import run_and_store_test_vector from cover_float.testgen.model import register_model + logger: log.ModelLogger = cast(log.ModelLogger, logging.getLogger("B14")) OPS = [const.OP_FMADD, const.OP_FMSUB, const.OP_FNMADD, const.OP_FNMSUB] From 636182d45172468a2087393bffbf7c5dcc9ba634 Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Thu, 23 Apr 2026 18:10:05 -0700 Subject: [PATCH 04/12] Update B14.py --- src/cover_float/testgen/B14.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index 3700ec6..d3001f5 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -11,7 +11,7 @@ import random from random import seed from pathlib import Path -from typing import TextIO +from typing import TextIO, cast import cover_float.common.constants as const import cover_float.common.log as log From e9c045950d2058aa30337f688a54d927f16429f7 Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Thu, 23 Apr 2026 18:13:31 -0700 Subject: [PATCH 05/12] Remove unused import from B14.py --- src/cover_float/testgen/B14.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index d3001f5..eb38581 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -9,7 +9,7 @@ import logging import random -from random import seed + from pathlib import Path from typing import TextIO, cast @@ -17,8 +17,6 @@ import cover_float.common.log as log from cover_float.common.util import reproducible_hash from cover_float.reference import run_and_store_test_vector -from cover_float.testgen.model import register_model - logger: log.ModelLogger = cast(log.ModelLogger, logging.getLogger("B14")) From aa9a6c0430860963773b14b83d68cc0eb664f467 Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Thu, 23 Apr 2026 18:15:55 -0700 Subject: [PATCH 06/12] Remove unnecessary blank line in B14.py --- src/cover_float/testgen/B14.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index eb38581..2b6cd08 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -9,7 +9,6 @@ import logging import random - from pathlib import Path from typing import TextIO, cast From a4baba877f0d039cb8fe4db0a43a494f5095376c Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Fri, 24 Apr 2026 09:46:40 -0700 Subject: [PATCH 07/12] Update B14.py added @register_model("B14") --- src/cover_float/testgen/B14.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index 2b6cd08..2feb017 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -99,7 +99,7 @@ def generate_b14_tests(test_f: TextIO, cover_f: TextIO, fmt: str) -> None: cover_f, ) - +@register_model("B14") def main() -> None: with ( Path("./tests/testvectors/B14_tv.txt").open("w") as test_f, From f3f5987acfca4548c5cf5334a04f6adcff547fc4 Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Fri, 24 Apr 2026 09:49:47 -0700 Subject: [PATCH 08/12] Import register_model in B14.py --- src/cover_float/testgen/B14.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index 2feb017..fb47151 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -16,6 +16,7 @@ import cover_float.common.log as log from cover_float.common.util import reproducible_hash from cover_float.reference import run_and_store_test_vector +from cover_float.testgen.model import register_model logger: log.ModelLogger = cast(log.ModelLogger, logging.getLogger("B14")) From dbbf6405e2b5e4db9f1a2731c2ffe1f05fb037c4 Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Sat, 25 Apr 2026 14:05:44 -0700 Subject: [PATCH 09/12] Update B14.py pre-commit issues fixed (hopefully) --- src/cover_float/testgen/B14.py | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index fb47151..0ac81da 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -9,7 +9,6 @@ import logging import random -from pathlib import Path from typing import TextIO, cast import cover_float.common.constants as const @@ -23,7 +22,8 @@ OPS = [const.OP_FMADD, const.OP_FMSUB, const.OP_FNMADD, const.OP_FNMSUB] -def decimalComponentsToHex(fmt: str, sign: int, biased_exp: int, mantissa: int) -> str: +def decimalComponentsToHex(fmt: str, sign: int, biased_exp: int, + mantissa: int) -> str: b_sign = f"{sign:01b}" b_exponent = f"{biased_exp:0{const.EXPONENT_BITS[fmt]}b}" b_mantissa = f"{mantissa:0{const.MANTISSA_BITS[fmt]}b}" @@ -100,15 +100,8 @@ def generate_b14_tests(test_f: TextIO, cover_f: TextIO, fmt: str) -> None: cover_f, ) -@register_model("B14") -def main() -> None: - with ( - Path("./tests/testvectors/B14_tv.txt").open("w") as test_f, - Path("./tests/covervectors/B14_cv.txt").open("w") as cover_f, - ): - for fmt in const.FLOAT_FMTS: - generate_b14_tests(test_f, cover_f, fmt) - -if __name__ == "__main__": - main() +@register_model("B14") +def main(test_f: TextIO, cover_f: TextIO) -> None: + for fmt in const.FLOAT_FMTS: + generate_b14_tests(test_f, cover_f, fmt) From e963450c8964028db0b7c214f2cec65be580a3ab Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Sat, 25 Apr 2026 14:07:55 -0700 Subject: [PATCH 10/12] Fix formatting --- src/cover_float/testgen/B14.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/cover_float/testgen/B14.py b/src/cover_float/testgen/B14.py index 0ac81da..7faf4ae 100644 --- a/src/cover_float/testgen/B14.py +++ b/src/cover_float/testgen/B14.py @@ -22,8 +22,7 @@ OPS = [const.OP_FMADD, const.OP_FMSUB, const.OP_FNMADD, const.OP_FNMSUB] -def decimalComponentsToHex(fmt: str, sign: int, biased_exp: int, - mantissa: int) -> str: +def decimalComponentsToHex(fmt: str, sign: int, biased_exp: int, mantissa: int) -> str: b_sign = f"{sign:01b}" b_exponent = f"{biased_exp:0{const.EXPONENT_BITS[fmt]}b}" b_mantissa = f"{mantissa:0{const.MANTISSA_BITS[fmt]}b}" From 1fab631ce93669e0406eab13c81a2e9785606082 Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Sun, 26 Apr 2026 15:24:16 -0700 Subject: [PATCH 11/12] Uncomment coverage definitions in config.svh --- config.svh | 54 +++++++++++++++++++++++++++--------------------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/config.svh b/config.svh index e0e0dd4..9a7a5eb 100644 --- a/config.svh +++ b/config.svh @@ -1,35 +1,35 @@ // define macros for which models to check coverage for // e.g. `define COVER_B1 for model B1 -// `define COVER_B1 -// `define COVER_B2 -// `define COVER_B3 -// `define COVER_B4 -// `define COVER_B5 -// `define COVER_B6 -// `define COVER_B7 -// `define COVER_B8 -// `define COVER_B9 -// `define COVER_B10 -// `define COVER_B11 -// `define COVER_B12 -// `define COVER_B13 +`define COVER_B1 +`define COVER_B2 +`define COVER_B3 +`define COVER_B4 +`define COVER_B5 +`define COVER_B6 +`define COVER_B7 +`define COVER_B8 +`define COVER_B9 +`define COVER_B10 +`define COVER_B11 +`define COVER_B12 +`define COVER_B13 `define COVER_B14 -// `define COVER_B15 -// `define COVER_B16 -// `define COVER_B17 -// `define COVER_B18 -// `define COVER_B19 -// `define COVER_B20 -// `define COVER_B21 -// `define COVER_B22 -// `define COVER_B23 +`define COVER_B15 +`define COVER_B16 +`define COVER_B17 +`define COVER_B18 +`define COVER_B19 +`define COVER_B20 +`define COVER_B21 +`define COVER_B22 +`define COVER_B23 `define COVER_B24 -// `define COVER_B25 -// `define COVER_B26 -// `define COVER_B27 -// `define COVER_B28 -// `define COVER_B29 +`define COVER_B25 +`define COVER_B26 +`define COVER_B27 +`define COVER_B28 +`define COVER_B29 // define macros for which precisions to check coverage for // e.g. `define COVER_F32 for single precision From 61c9a801fa27133c83c80c47bdf13242cd7926ce Mon Sep 17 00:00:00 2001 From: sww0000 <143860457+sww0000@users.noreply.github.com> Date: Tue, 28 Apr 2026 11:25:19 -0700 Subject: [PATCH 12/12] newline at end of file in config.svh --- config.svh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/config.svh b/config.svh index 5e72a7e..346556f 100644 --- a/config.svh +++ b/config.svh @@ -57,4 +57,4 @@ // define macro for long int support (i.e. 64 bit DUT) -`define COVER_LONG \ No newline at end of file +`define COVER_LONG