Improve testbench and add python script to generate test vector

Author: jefflieu

floatsip/sim/doCompileFPVerifier.do

@@ -1,4 +1,4 @@
-set SIMLIBPATH {/fpgasw/altera/12.1sp1/quartus/eda/sim_lib/}
+set SIMLIBPATH {D:/intelFPGA_lite/18.0/quartus/eda/sim_lib/}
 puts $SIMLIBPATH
 vlog $SIMLIBPATH/220model.v
 vlog $SIMLIBPATH/altera_mf.v

floatsip/sim/float_util.py

@@ -0,0 +1,111 @@
+
+import math 
+import random
+
+FloatingPoint_Specification = {
+     32 : ( 8, 23)  ,
+     64 : (11, 52)  ,
+     16 : ( 5, 10)  
+}
+
+def is_inf(dbl, exp_width):
+  bias  = (1<<(exp_width - 1)) - 1
+  max_e = (1<<exp_width) - 1 - 1 - bias
+  if exp_width == 11:
+    return math.isinf(dbl)
+  else: 
+    return (dbl >= math.ldexp(1.0, max_e + 1) or dbl < math.ldexp(-1.0, max_e + 1))
+
+def is_subnormal(dbl, exp_width):
+  bias = (1<<(exp_width - 1)) - 1
+  min_e = 1 - bias 
+  return ((dbl < math.ldexp(1.0, min_e) and dbl > math.ldexp(-1.0, min_e)) and dbl != 0.0)
+
+
+def gen_rand_float(size):
+   e_width, m_width = FloatingPoint_Specification[size]
+   m = random.randint(0, 2**(m_width + 1) - 1)
+   mant = m/2.0**m_width
+   bias = (1<<(e_width - 1)) - 1
+   max_e = ((1 << e_width) - 1) - 1 - bias   
+   min_e = (1 - bias)
+   exp  = random.randint(min_e, max_e)   
+   return math.ldexp(mant, exp)
+
+def round_to_nearest_even(dbl): 
+    upper = math.ceil(dbl)
+    lower = math.floor(dbl)
+    error = dbl - lower 
+    ret = 0
+    if error == 0.5: 
+      if (upper % 2)==0:
+        ret = upper
+      else: 
+        ret =lower 
+    elif error < 0.5: 
+      ret = lower 
+    else: 
+      ret = upper     
+    return int(ret)
+
+def hex_rep(dbl, exp_width = 8, mant_width = 23):
+  """ 
+    This function returns hex representation of dbl value with a custom exp_width and mant_width 
+    First find out the BIAS and the representation of the dbl 
+    dlb = m * 2^e ( m is [-1.0, 1.0])
+    Then we handle infinity, handle subnormal number and special case for zero 
+  """
+  
+  bias = (1<<(exp_width - 1)) - 1
+  m, e = math.frexp(dbl)
+  
+  try:
+    #Infinity number 
+    if is_inf(dbl, exp_width):
+      mant = 0 
+      exp  = (1<<exp_width) - 1
+    
+    #subnormal numbers
+    elif is_subnormal(dbl, exp_width):       
+      """
+        subnormal number a = s * 0.m * 2^min_e (min_e = 1 - bias)
+        the frexp() returns normalized m and e with 0.5 <= m <= 1.0 and e can be smaller than 1 - bias         
+        to represent a = m x 2^e in subnormal format = 0.frac x 2^min_e 
+        we have to unnormalize the mantissa 
+           frac = m / (2^(min_e - e))
+        then multiply by number of bits of mantissa = 2^mant_width
+        --> frac = m * 2^(mant_width - (min_e - e)) 
+      """
+      exp  = 0  
+      k = (1-bias) - e
+      if m < 0: 
+        m = 0 - m
+      if mant_width >= k:
+        mant =  int(m *(1<<(mant_width  - k)))
+      else:
+        mant =  0
+    else:       
+      #Special case of mantissa = 0
+      if m == 0:
+        exp  = 0
+        mant = 0
+      else:
+        if m < 0: 
+          m = 0 - m
+        mant =  round_to_nearest_even((m * 2 - 1.0)*(1<<mant_width))
+        exp  =  (e - 1) + bias     
+  except: 
+    print("Unknown exception", dbl, m, e, exp_width, mant_width, is_inf(dbl, exp_width), is_subnormal(dbl, exp_width), k)
+    pass 
+  
+  #Set up sign bit first   
+  if dbl < 0: 
+    hex_rep = 1 
+  else: 
+    hex_rep = 0
+  
+  #Shift in exponential and mantissa 
+  hex_rep = (hex_rep << exp_width) + exp 
+  hex_rep = (hex_rep << mant_width) + mant     
+  fmtspec = '{:0' + str((exp_width + mant_width + 1 + 3)/4) + 'x}'
+  return fmtspec.format(hex_rep)

floatsip/sim/mFPMultVerifier.v

@@ -2,16 +2,11 @@
 
 module mFPMultVerifier;
 
-parameter pPrecision=2;
-parameter pManW = 52;
-parameter pExpW = 11;
+parameter pPrecision=0;
+parameter pManW = (pPrecision==2)?52:(pPrecision==1?23:10);
+parameter pExpW = (pPrecision==2)?11:(pPrecision==1?8:5);
 parameter pPipeline=5;
-
-parameter pDouble1 		= 64'h3FF_0_0000_0000_0000;
-parameter pDouble1p5 	= 64'h3FF_8_0000_0000_0000;
-parameter pSingle1 		= 32'h3F80_0000;
-parameter pSingle1p5	= 32'h3FC0_0000;
-parameter pSingle2		= 32'h4000_0000;
+parameter pTestVector = (pPrecision==2)?"Mult64Data.txt":(pPrecision==1?"Mult32Data.txt":"Mult16Data.txt");
 
 reg 	[pExpW+pManW:0] rv_A;
 reg 	[pExpW+pManW:0] rv_B;
@@ -22,6 +17,7 @@ wire 	[pExpW+pManW:0] wv_FltB;
 wire 	[pExpW+pManW:0] wv_FltC;
 
 reg [pExpW+pManW:0] rv_FltC_D[0:pPipeline-1];
+reg [pExpW+pManW:0] ref_data;
 
 reg r_Clk;
 reg r_ARst;
@@ -72,17 +68,18 @@ wire w_Inf,w_NaN;
 	always@(posedge r_Clk)
 		begin
 			r_Dv <= r_GenEn;
-			//rv_FltC_D[0] <= wv_FltC;
+			rv_FltC_D[0] <= wv_FltC;
 			for(I=1;I<10;I=I+1)
 				rv_FltC_D[I]<=rv_FltC_D[I-1];
-			ModelMultiplier(wv_FltA,wv_FltB,rv_FltC_D[0]);		
+			//ModelMultiplier(wv_FltA,wv_FltB,rv_FltC_D[0]);		
+			ModelMultiplier(wv_FltA,wv_FltB,ref_data);		
 		end
 
 	mFloatLoader #(.pPrecision(pPrecision),
 			.pWidthExp(pExpW),
 			.pWidthMan(pManW),
 			.pDataCol(3),
-			.pDataFile("Mult64Data.txt")) u0FPGen
+			.pDataFile(pTestVector)) u0FPGen
 	(
 	.i_Clk(r_Clk),
 	.i_ClkEn(r_GenEn),
@@ -132,7 +129,7 @@ wire w_Inf,w_NaN;
 					else 
 						begin
 							$display("INFINITY CHECK FAILED");	
-							//$stop;		
+							$stop;		
 						end
 				end
 				else if (w_NaN)

floatsip/sim/mult_data_gen.py

@@ -0,0 +1,75 @@
+#Python Data generator 
+import math 
+import random
+from  float_util import gen_rand_float, is_subnormal, is_inf, FloatingPoint_Specification, hex_rep
+
+
+
+coverage_counters = {'nnn' : 0}
+
+def counters(a, b, p, size):
+  def get_state(a, size):
+    ew, mw = FloatingPoint_Specification[size]
+    if a == 0.0: 
+      state_a  = 'z' 
+    elif is_inf(a, ew): 
+      state_a  = 'i'
+    elif is_subnormal(a, ew):
+      state_a  = 's'
+    else : 
+      state_a  = 'n'
+    return state_a 
+  state = get_state(a, size) + get_state(b, size) + get_state(p, size)
+  try: 
+    coverage_counters[state] = coverage_counters[state] + 1
+  except: 
+    coverage_counters[state] = 0
+  
+def generate_mult_test_data(size):
+   """
+     Lookup the exponent width and mantissa width 
+     calculate the BIAS 
+     Find the Maximum and Minimum exponent value 
+     Generate a Random exp within the range 
+     Generate a Random mantissa value within range of (-1.0 and 1.0) 
+     a = mant * 2^exp 
+     b = mant * 2^exp 
+     p = a * b 
+     return a, b, p 
+   """
+   e_width, m_width = FloatingPoint_Specification[size]
+   
+   a = gen_rand_float(size)
+   b = gen_rand_float(size)
+   
+   p = a * b   
+   
+   #Check subnormal value and round product to 0 
+   #The core is supposed to detect subnormal input
+   if is_subnormal(a, e_width) or is_subnormal(b, e_width) or is_subnormal(p, e_width):
+     p = 0.0
+     
+   return a, b, p
+  
+
+def main():
+    #Seeding 
+    random.seed(1.0)
+    total_N = 100000
+    for size, (e_width, m_width) in FloatingPoint_Specification.items(): 
+      print("Test vector for size ", size)
+      with open('Mult' + str(size) + 'Data.txt', 'w') as f:
+        with open('Mult' + str(size) + 'Real.txt', 'w')  as r:
+          for id in range(0, total_N):                
+            a, b, p = generate_mult_test_data(size)            
+            counters(a, b, p, size) 
+            r.write('{:02x} {:<+16e} {} {:<+16e} {} {:<+16e} {}\n'.format(id, a, math.frexp(a), b, math.frexp(b), p, math.frexp(p)))
+            f.write('{:02x} {:s} {:s} {:s}\n'.format(id, hex_rep(a, e_width, m_width), hex_rep(b, e_width, m_width), hex_rep(p, e_width, m_width)))
+            if ( id % (total_N/100)) == 0: 
+               print(id/(total_N/100))
+          r.close()
+        f.close()
+      print("Coverage", coverage_counters)
+    
+
+main()