def generate_scheme(self):
# declaring function input variable
vx = self.implementation.add_input_variable("x", self.precision)
vy = self.implementation.add_input_variable("y", self.precision)
Cst0 = Constant(5, precision=self.precision)
Cst1 = Constant(7, precision=self.precision)
comp = Comparison(vx,
vy,
specifier=Comparison.Greater,
precision=ML_Bool,
tag="comp")
comp_eq = Comparison(vx,
vy,
specifier=Comparison.Equal,
precision=ML_Bool,
tag="comp_eq")
scheme = Statement(
ConditionBlock(
comp, Return(vy, precision=self.precision),
ConditionBlock(
comp_eq,
Return(vx + vy * Cst0 - Cst1, precision=self.precision))),
ConditionBlock(comp_eq, Return(Cst1 * vy,
precision=self.precision)),
Return(vx * vy, precision=self.precision))
return scheme
def get_output_check_statement(output_signal, output_tag, output_value):
""" Generate output value check statement """
test_pass_cond = Comparison(
output_signal,
output_value,
specifier=Comparison.Equal,
precision=ML_Bool
)
check_statement = ConditionBlock(
LogicalNot(
test_pass_cond,
precision = ML_Bool
),
Report(
Concatenation(
" result for {}: ".format(output_tag),
Conversion(
output_signal if output_signal.get_precision() is ML_StdLogic else
TypeCast(
output_signal,
precision=ML_StdLogicVectorFormat(
output_signal.get_precision().get_bit_size()
)
),
precision = ML_String
),
precision = ML_String
)
)
)
return test_pass_cond, check_statement
def test_ref_assign(self):
""" test behavior of StaticVectorizer on predicated ReferenceAssign """
va = Variable("a")
vb = Variable("b")
vc = Variable("c")
scheme = Statement(
ReferenceAssign(va, Constant(3)),
ConditionBlock(
(va > vb).modify_attributes(likely=True),
Statement(ReferenceAssign(vb, va),
ReferenceAssign(va, Constant(11)), Return(va)),
), ReferenceAssign(va, Constant(7)), Return(vb))
vectorized_path = StaticVectorizer().extract_vectorizable_path(
scheme, fallback_policy)
linearized_most_likely_path = instanciate_variable(
vectorized_path.linearized_optree,
vectorized_path.variable_mapping)
test_result = (isinstance(linearized_most_likely_path, Constant)
and linearized_most_likely_path.get_value() == 11)
if not test_result:
print("test UT_StaticVectorizer failure")
print("scheme: {}".format(scheme.get_str()))
print("linearized_most_likely_path: {}".format(
linearized_most_likely_path))
self.assertTrue(test_result)
def generate_tensor_check_loop(self, tensor_descriptors, input_tables,
output_tables):
# unpack tensor descriptors tuple
(input_tensor_descriptor_list,
output_tensor_descriptor_list) = tensor_descriptors
# internal array iterator index
vj = Variable("j", precision=ML_UInt32, var_type=Variable.Local)
printf_error_detail_function = self.get_printf_error_detail_fct(
output_tensor_descriptor_list[0])
NUM_INPUT_ARRAY = len(input_tables)
# generate the expected table for the whole multi-array
expected_tables = self.generate_expected_table(tensor_descriptors,
input_tables)
# global statement to list all checks
check_statement = Statement()
# implement check for each output tensor
for out_id, out_td in enumerate(output_tensor_descriptor_list):
# expected values for the (vj)-th entry of the sub-array
expected_values = [
TableLoad(expected_tables[out_id], vj, i)
for i in range(self.accuracy.get_num_output_value())
]
# local result for the (vj)-th entry of the sub-array
local_result = TableLoad(output_tables[out_id], vj)
array_len = out_td.get_bounding_size()
if self.break_error:
return_statement_break = Statement(
printf_error_detail_function(*((vj, ) + (local_result, ))),
self.accuracy.get_output_print_call(
self.function_name, output_values))
else:
return_statement_break = Statement(
printf_error_detail_function(*((vj, ) + (local_result, ))),
self.accuracy.get_output_print_call(
self.function_name, expected_values),
Return(Constant(1, precision=ML_Int32)))
check_array_loop = Loop(
ReferenceAssign(vj, 0), vj < array_len,
Statement(
ConditionBlock(
self.accuracy.get_output_check_test(
local_result, expected_values),
return_statement_break),
ReferenceAssign(vj, vj + 1),
))
check_statement.add(check_array_loop)
return check_statement
def generate_scheme(self):
# declaring input variable
vx = self.implementation.add_input_variable("x", self.precision)
vx2 = vx * vx
scheme = ConditionBlock(
vx > 0, Return(vx - 0.33 * vx2 * vx + (2 / 15.0) * vx * vx2 * vx2),
Return(FP_QNaN(self.precision)))
return scheme
def generate_scalar_scheme(self, vx, vy):
div = Division(vx, vy, precision=self.precision)
div_if = Trunc(div, precision=self.precision)
rem = Variable("rem",
var_type=Variable.Local,
precision=self.precision)
qi = Variable("qi", var_type=Variable.Local, precision=self.precision)
qi_bound = Constant(S2**self.precision.get_mantissa_size())
init_rem = FusedMultiplyAdd(-div_if, vy, vx)
# factorizing 1 / vy to save time
# NOTES: it makes rem / vy approximate
# shared_rcp = Division(1, vy, precision=self.precision)
iterative_fmod = Loop(
Statement(
ReferenceAssign(rem, init_rem),
ReferenceAssign(qi, div_if),
),
Abs(qi) > qi_bound,
Statement(
ReferenceAssign(
qi,
#Trunc(shared_rcp * rem, precision=self.precision)
Trunc(rem / vy, precision=self.precision)),
ReferenceAssign(rem, FMA(-qi, vy, rem))))
scheme = Statement(
rem,
# shared_rcp,
iterative_fmod,
ConditionBlock(
# if rem's sign and vx sign mismatch
(rem * vx < 0.0).modify_attributes(tag="update_cond",
debug=debug_multi),
Return(rem + vy),
Return(rem),
))
return scheme
def generate_scheme(self):
""" main scheme generation """
input_precision = self.precision
output_precision = self.precision
# declaring main input variable
x_interval = Interval(-10.3, 10.7)
var_x = self.implementation.add_input_variable("x",
input_precision,
interval=x_interval)
y_interval = Interval(-17.9, 17.2)
var_y = self.implementation.add_input_variable("y",
input_precision,
interval=y_interval)
z_interval = Interval(-70.3, -57.7)
var_z = self.implementation.add_input_variable("z",
input_precision,
interval=z_interval)
min_yz = Min(var_z, var_y)
cst0 = Constant(42.5, tag="cst0", precision=self.precision)
cst1 = Constant(2.5, tag="cst1", precision=self.precision)
cst2 = Constant(12.5, tag="cst2", precision=self.precision)
new_cst = cst0 + cst1 * cst2
result = min_yz + new_cst
scheme = ConditionBlock(
LogicalAnd(
LogicalOr(cst0 > cst1, LogicalNot(cst1 > cst0)),
var_x > var_y,
), Return(result), Return(cst2))
return scheme
def generate_pipeline_stage(entity):
""" Process a entity to generate pipeline stages required """
retiming_map = {}
retime_map = RetimeMap()
output_assign_list = entity.implementation.get_output_assign()
for output in output_assign_list:
Log.report(
Log.Verbose,
"generating pipeline from output %s " % (output.get_str(depth=1)))
retime_op(output, retime_map)
process_statement = Statement()
# adding stage forward process
clk = entity.get_clk_input()
clock_statement = Statement()
for stage_id in sorted(retime_map.stage_forward.keys()):
stage_statement = Statement(*tuple(
assign for assign in retime_map.stage_forward[stage_id]))
clock_statement.add(stage_statement)
# To meet simulation / synthesis tools, we build
# a single if clock predicate block which contains all
# the stage register allocation
clock_block = ConditionBlock(
LogicalAnd(Event(clk, precision=ML_Bool),
Comparison(clk,
Constant(1, precision=ML_StdLogic),
specifier=Comparison.Equal,
precision=ML_Bool),
precision=ML_Bool), clock_statement)
process_statement.add(clock_block)
pipeline_process = Process(process_statement, sensibility_list=[clk])
for op in retime_map.pre_statement:
pipeline_process.add_to_pre_statement(op)
entity.implementation.add_process(pipeline_process)
stage_num = len(retime_map.stage_forward.keys())
#print "there are %d pipeline stages" % (stage_num)
return stage_num
def generate_scheme(self):
# declaring target and instantiating optimization engine
vx = self.implementation.add_input_variable("x", self.precision)
Log.set_dump_stdout(True)
Log.report(Log.Info,
"\033[33;1m generating implementation scheme \033[0m")
if self.debug_flag:
Log.report(Log.Info, "\033[31;1m debug has been enabled \033[0;m")
# local overloading of RaiseReturn operation
def ExpRaiseReturn(*args, **kwords):
kwords["arg_value"] = vx
kwords["function_name"] = self.function_name
if self.libm_compliant:
return RaiseReturn(*args, precision=self.precision, **kwords)
else:
return Return(kwords["return_value"], precision=self.precision)
test_nan_or_inf = Test(vx,
specifier=Test.IsInfOrNaN,
likely=False,
debug=debug_multi,
tag="nan_or_inf")
test_nan = Test(vx,
specifier=Test.IsNaN,
debug=debug_multi,
tag="is_nan_test")
test_positive = Comparison(vx,
0,
specifier=Comparison.GreaterOrEqual,
debug=debug_multi,
tag="inf_sign")
test_signaling_nan = Test(vx,
specifier=Test.IsSignalingNaN,
debug=debug_multi,
tag="is_signaling_nan")
return_snan = Statement(
ExpRaiseReturn(ML_FPE_Invalid,
return_value=FP_QNaN(self.precision)))
# return in case of infinity input
infty_return = Statement(
ConditionBlock(
test_positive,
Return(FP_PlusInfty(self.precision), precision=self.precision),
Return(FP_PlusZero(self.precision), precision=self.precision)))
# return in case of specific value input (NaN or inf)
specific_return = ConditionBlock(
test_nan,
ConditionBlock(
test_signaling_nan, return_snan,
Return(FP_QNaN(self.precision), precision=self.precision)),
infty_return)
# return in case of standard (non-special) input
# exclusion of early overflow and underflow cases
precision_emax = self.precision.get_emax()
precision_max_value = S2 * S2**precision_emax
exp_overflow_bound = sollya.ceil(log(precision_max_value))
early_overflow_test = Comparison(vx,
exp_overflow_bound,
likely=False,
specifier=Comparison.Greater)
early_overflow_return = Statement(
ClearException() if self.libm_compliant else Statement(),
ExpRaiseReturn(ML_FPE_Inexact,
ML_FPE_Overflow,
return_value=FP_PlusInfty(self.precision)))
precision_emin = self.precision.get_emin_subnormal()
precision_min_value = S2**precision_emin
exp_underflow_bound = floor(log(precision_min_value))
early_underflow_test = Comparison(vx,
exp_underflow_bound,
likely=False,
specifier=Comparison.Less)
early_underflow_return = Statement(
ClearException() if self.libm_compliant else Statement(),
ExpRaiseReturn(ML_FPE_Inexact,
ML_FPE_Underflow,
return_value=FP_PlusZero(self.precision)))
# constant computation
invlog2 = self.precision.round_sollya_object(1 / log(2), sollya.RN)
interval_vx = Interval(exp_underflow_bound, exp_overflow_bound)
interval_fk = interval_vx * invlog2
interval_k = Interval(floor(inf(interval_fk)),
sollya.ceil(sup(interval_fk)))
log2_hi_precision = self.precision.get_field_size() - (
sollya.ceil(log2(sup(abs(interval_k)))) + 2)
Log.report(Log.Info, "log2_hi_precision: %d" % log2_hi_precision)
invlog2_cst = Constant(invlog2, precision=self.precision)
log2_hi = round(log(2), log2_hi_precision, sollya.RN)
log2_lo = self.precision.round_sollya_object(
log(2) - log2_hi, sollya.RN)
# argument reduction
unround_k = vx * invlog2
unround_k.set_attributes(tag="unround_k", debug=debug_multi)
k = NearestInteger(unround_k,
precision=self.precision,
debug=debug_multi)
ik = NearestInteger(unround_k,
precision=self.precision.get_integer_format(),
debug=debug_multi,
tag="ik")
ik.set_tag("ik")
k.set_tag("k")
exact_pre_mul = (k * log2_hi)
exact_pre_mul.set_attributes(exact=True)
exact_hi_part = vx - exact_pre_mul
exact_hi_part.set_attributes(exact=True,
tag="exact_hi",
debug=debug_multi,
prevent_optimization=True)
exact_lo_part = -k * log2_lo
exact_lo_part.set_attributes(tag="exact_lo",
debug=debug_multi,
prevent_optimization=True)
r = exact_hi_part + exact_lo_part
r.set_tag("r")
r.set_attributes(debug=debug_multi)
approx_interval = Interval(-log(2) / 2, log(2) / 2)
approx_interval_half = approx_interval / 2
approx_interval_split = [
Interval(-log(2) / 2, inf(approx_interval_half)),
approx_interval_half,
Interval(sup(approx_interval_half),
log(2) / 2)
]
# TODO: should be computed automatically
exact_hi_interval = approx_interval
exact_lo_interval = -interval_k * log2_lo
opt_r = self.optimise_scheme(r, copy={})
tag_map = {}
self.opt_engine.register_nodes_by_tag(opt_r, tag_map)
cg_eval_error_copy_map = {
vx:
Variable("x", precision=self.precision, interval=interval_vx),
tag_map["k"]:
Variable("k", interval=interval_k, precision=self.precision)
}
#try:
if is_gappa_installed():
eval_error = self.gappa_engine.get_eval_error_v2(
self.opt_engine,
opt_r,
cg_eval_error_copy_map,
gappa_filename="red_arg.g")
else:
eval_error = 0.0
Log.report(Log.Warning,
"gappa is not installed in this environnement")
Log.report(Log.Info, "eval error: %s" % eval_error)
local_ulp = sup(ulp(sollya.exp(approx_interval), self.precision))
# FIXME refactor error_goal from accuracy
Log.report(Log.Info, "accuracy: %s" % self.accuracy)
if isinstance(self.accuracy, ML_Faithful):
error_goal = local_ulp
elif isinstance(self.accuracy, ML_CorrectlyRounded):
error_goal = S2**-1 * local_ulp
elif isinstance(self.accuracy, ML_DegradedAccuracyAbsolute):
error_goal = self.accuracy.goal
elif isinstance(self.accuracy, ML_DegradedAccuracyRelative):
error_goal = self.accuracy.goal
else:
Log.report(Log.Error, "unknown accuracy: %s" % self.accuracy)
# error_goal = local_ulp #S2**-(self.precision.get_field_size()+1)
error_goal_approx = S2**-1 * error_goal
Log.report(Log.Info,
"\033[33;1m building mathematical polynomial \033[0m\n")
poly_degree = max(
sup(
guessdegree(
expm1(sollya.x) / sollya.x, approx_interval,
error_goal_approx)) - 1, 2)
init_poly_degree = poly_degree
error_function = lambda p, f, ai, mod, t: dirtyinfnorm(f - p, ai)
polynomial_scheme_builder = PolynomialSchemeEvaluator.generate_estrin_scheme
#polynomial_scheme_builder = PolynomialSchemeEvaluator.generate_horner_scheme
while 1:
Log.report(Log.Info, "attempting poly degree: %d" % poly_degree)
precision_list = [1] + [self.precision] * (poly_degree)
poly_object, poly_approx_error = Polynomial.build_from_approximation_with_error(
expm1(sollya.x),
poly_degree,
precision_list,
approx_interval,
sollya.absolute,
error_function=error_function)
Log.report(Log.Info, "polynomial: %s " % poly_object)
sub_poly = poly_object.sub_poly(start_index=2)
Log.report(Log.Info, "polynomial: %s " % sub_poly)
Log.report(Log.Info, "poly approx error: %s" % poly_approx_error)
Log.report(
Log.Info,
"\033[33;1m generating polynomial evaluation scheme \033[0m")
pre_poly = polynomial_scheme_builder(
poly_object, r, unified_precision=self.precision)
pre_poly.set_attributes(tag="pre_poly", debug=debug_multi)
pre_sub_poly = polynomial_scheme_builder(
sub_poly, r, unified_precision=self.precision)
pre_sub_poly.set_attributes(tag="pre_sub_poly", debug=debug_multi)
poly = 1 + (exact_hi_part + (exact_lo_part + pre_sub_poly))
poly.set_tag("poly")
# optimizing poly before evaluation error computation
#opt_poly = self.opt_engine.optimization_process(poly, self.precision, fuse_fma = fuse_fma)
#opt_sub_poly = self.opt_engine.optimization_process(pre_sub_poly, self.precision, fuse_fma = fuse_fma)
opt_poly = self.optimise_scheme(poly)
opt_sub_poly = self.optimise_scheme(pre_sub_poly)
# evaluating error of the polynomial approximation
r_gappa_var = Variable("r",
precision=self.precision,
interval=approx_interval)
exact_hi_gappa_var = Variable("exact_hi",
precision=self.precision,
interval=exact_hi_interval)
exact_lo_gappa_var = Variable("exact_lo",
precision=self.precision,
interval=exact_lo_interval)
vx_gappa_var = Variable("x",
precision=self.precision,
interval=interval_vx)
k_gappa_var = Variable("k",
interval=interval_k,
precision=self.precision)
#print "exact_hi interval: ", exact_hi_interval
sub_poly_error_copy_map = {
#r.get_handle().get_node(): r_gappa_var,
#vx.get_handle().get_node(): vx_gappa_var,
exact_hi_part.get_handle().get_node():
exact_hi_gappa_var,
exact_lo_part.get_handle().get_node():
exact_lo_gappa_var,
#k.get_handle().get_node(): k_gappa_var,
}
poly_error_copy_map = {
exact_hi_part.get_handle().get_node(): exact_hi_gappa_var,
exact_lo_part.get_handle().get_node(): exact_lo_gappa_var,
}
if is_gappa_installed():
sub_poly_eval_error = -1.0
sub_poly_eval_error = self.gappa_engine.get_eval_error_v2(
self.opt_engine,
opt_sub_poly,
sub_poly_error_copy_map,
gappa_filename="%s_gappa_sub_poly.g" % self.function_name)
dichotomy_map = [
{
exact_hi_part.get_handle().get_node():
approx_interval_split[0],
},
{
exact_hi_part.get_handle().get_node():
approx_interval_split[1],
},
{
exact_hi_part.get_handle().get_node():
approx_interval_split[2],
},
]
poly_eval_error_dico = self.gappa_engine.get_eval_error_v3(
self.opt_engine,
opt_poly,
poly_error_copy_map,
gappa_filename="gappa_poly.g",
dichotomy=dichotomy_map)
poly_eval_error = max(
[sup(abs(err)) for err in poly_eval_error_dico])
else:
poly_eval_error = 0.0
sub_poly_eval_error = 0.0
Log.report(Log.Warning,
"gappa is not installed in this environnement")
Log.report(Log.Info, "stopping autonomous degree research")
# incrementing polynomial degree to counteract initial decrementation effect
poly_degree += 1
break
Log.report(Log.Info, "poly evaluation error: %s" % poly_eval_error)
Log.report(Log.Info,
"sub poly evaluation error: %s" % sub_poly_eval_error)
global_poly_error = None
global_rel_poly_error = None
for case_index in range(3):
poly_error = poly_approx_error + poly_eval_error_dico[
case_index]
rel_poly_error = sup(
abs(poly_error /
sollya.exp(approx_interval_split[case_index])))
if global_rel_poly_error == None or rel_poly_error > global_rel_poly_error:
global_rel_poly_error = rel_poly_error
global_poly_error = poly_error
flag = error_goal > global_rel_poly_error
if flag:
break
else:
poly_degree += 1
late_overflow_test = Comparison(ik,
self.precision.get_emax(),
specifier=Comparison.Greater,
likely=False,
debug=debug_multi,
tag="late_overflow_test")
overflow_exp_offset = (self.precision.get_emax() -
self.precision.get_field_size() / 2)
diff_k = Subtraction(
ik,
Constant(overflow_exp_offset,
precision=self.precision.get_integer_format()),
precision=self.precision.get_integer_format(),
debug=debug_multi,
tag="diff_k",
)
late_overflow_result = (ExponentInsertion(
diff_k, precision=self.precision) * poly) * ExponentInsertion(
overflow_exp_offset, precision=self.precision)
late_overflow_result.set_attributes(silent=False,
tag="late_overflow_result",
debug=debug_multi,
precision=self.precision)
late_overflow_return = ConditionBlock(
Test(late_overflow_result, specifier=Test.IsInfty, likely=False),
ExpRaiseReturn(ML_FPE_Overflow,
return_value=FP_PlusInfty(self.precision)),
Return(late_overflow_result, precision=self.precision))
late_underflow_test = Comparison(k,
self.precision.get_emin_normal(),
specifier=Comparison.LessOrEqual,
likely=False)
underflow_exp_offset = 2 * self.precision.get_field_size()
corrected_exp = Addition(
ik,
Constant(underflow_exp_offset,
precision=self.precision.get_integer_format()),
precision=self.precision.get_integer_format(),
tag="corrected_exp")
late_underflow_result = (
ExponentInsertion(corrected_exp, precision=self.precision) *
poly) * ExponentInsertion(-underflow_exp_offset,
precision=self.precision)
late_underflow_result.set_attributes(debug=debug_multi,
tag="late_underflow_result",
silent=False)
test_subnormal = Test(late_underflow_result,
specifier=Test.IsSubnormal)
late_underflow_return = Statement(
ConditionBlock(
test_subnormal,
ExpRaiseReturn(ML_FPE_Underflow,
return_value=late_underflow_result)),
Return(late_underflow_result, precision=self.precision))
twok = ExponentInsertion(ik,
tag="exp_ik",
debug=debug_multi,
precision=self.precision)
#std_result = twok * ((1 + exact_hi_part * pre_poly) + exact_lo_part * pre_poly)
std_result = twok * poly
std_result.set_attributes(tag="std_result", debug=debug_multi)
result_scheme = ConditionBlock(
late_overflow_test, late_overflow_return,
ConditionBlock(late_underflow_test, late_underflow_return,
Return(std_result, precision=self.precision)))
std_return = ConditionBlock(
early_overflow_test, early_overflow_return,
ConditionBlock(early_underflow_test, early_underflow_return,
result_scheme))
# main scheme
Log.report(Log.Info, "\033[33;1m MDL scheme \033[0m")
scheme = ConditionBlock(
test_nan_or_inf,
Statement(ClearException() if self.libm_compliant else Statement(),
specific_return), std_return)
return scheme
def generate_datafile_testbench(self, tc_list, io_map, input_signals, output_signals, time_step, test_fname="test.input"):
""" Generate testbench with input and output data externalized in
a data file """
# textio function to read hexadecimal text
def FCT_HexaRead_gen(input_format):
legalized_input_format = input_format
FCT_HexaRead = FunctionObject("hread", [HDL_LINE, legalized_input_format], ML_Void, FunctionOperator("hread", void_function=True, arity=2))
return FCT_HexaRead
# textio function to read binary text
FCT_Read = FunctionObject("read", [HDL_LINE, ML_StdLogic], ML_Void, FunctionOperator("read", void_function=True, arity=2))
input_line = Variable("input_line", precision=HDL_LINE, var_type=Variable.Local)
# building ordered list of input and output signal names
input_signal_list = [sname for sname in input_signals.keys()]
input_statement = Statement()
for input_name in input_signal_list:
input_format = input_signals[input_name].precision
input_var = Variable(
"v_" + input_name,
precision=input_format,
var_type=Variable.Local)
if input_format is ML_StdLogic:
input_statement.add(FCT_Read(input_line, input_var))
else:
input_statement.add(FCT_HexaRead_gen(input_format)(input_line, input_var))
input_statement.add(ReferenceAssign(input_signals[input_name], input_var))
output_signal_list = [sname for sname in output_signals.keys()]
output_statement = Statement()
for output_name in output_signal_list:
output_format = output_signals[output_name].precision
output_var = Variable(
"v_" + output_name,
precision=output_format,
var_type=Variable.Local)
if output_format is ML_StdLogic:
output_statement.add(FCT_Read(input_line, output_var))
else:
output_statement.add(FCT_HexaRead_gen(output_format)(input_line, output_var))
output_signal = output_signals[output_name]
#value_msg = get_output_value_msg(output_signal, output_value)
test_pass_cond, check_statement = get_output_check_statement(output_signal, output_name, output_var)
input_msg = multi_Concatenation(*tuple(sum([[" %s=" % input_tag, signal_str_conversion(input_signals[input_tag], input_signals[input_tag].precision)] for input_tag in input_signal_list], [])))
output_statement.add(check_statement)
assert_statement = Assert(
test_pass_cond,
multi_Concatenation(
"unexpected value for inputs ",
input_msg,
" expecting :",
signal_str_conversion(output_var, output_format),
" got :",
signal_str_conversion(output_signal, output_format),
precision = ML_String
),
severity=Assert.Failure
)
output_statement.add(assert_statement)
self_component = self.implementation.get_component_object()
self_instance = self_component(io_map = io_map, tag = "tested_entity")
test_statement = Statement()
DATA_FILE_NAME = test_fname
with open(DATA_FILE_NAME, "w") as data_file:
# dumping column tags
data_file.write("# " + " ".join(input_signal_list + output_signal_list) + "\n")
def get_raw_cst_string(cst_format, cst_value):
size = int((cst_format.get_bit_size() + 3) / 4)
return ("{:x}").format(cst_format.get_base_format().get_integer_coding(cst_value)).zfill(size)
for input_values, output_values in tc_list:
# TODO; generate test data file
cst_list = []
for input_name in input_signal_list:
input_value = input_values[input_name]
input_format = input_signals[input_name].get_precision()
cst_list.append(get_raw_cst_string(input_format, input_value))
for output_name in output_signal_list:
output_value = output_values[output_name]
output_format = output_signals[output_name].get_precision()
cst_list.append(get_raw_cst_string(output_format, output_value))
# dumping line into file
data_file.write(" ".join(cst_list) + "\n")
input_stream = Variable("data_file", precision=HDL_FILE, var_type=Variable.Local)
file_status = Variable("file_status", precision=HDL_OPEN_FILE_STATUS, var_type=Variable.Local)
FCT_EndFile = FunctionObject("endfile", [HDL_FILE], ML_Bool, FunctionOperator("endfile", arity=1))
FCT_OpenFile = FunctionObject(
"FILE_OPEN", [HDL_OPEN_FILE_STATUS, HDL_FILE, ML_String], ML_Void,
FunctionOperator(
"FILE_OPEN",
arg_map={0: FO_Arg(0), 1: FO_Arg(1), 2: FO_Arg(2), 3: "READ_MODE"},
void_function=True))
FCT_ReadLine = FunctionObject(
"readline", [HDL_FILE, HDL_LINE], ML_Void,
FunctionOperator("readline", void_function=True, arity=2))
reset_statement = self.get_reset_statement(io_map, time_step)
OPEN_OK = Constant("OPEN_OK", precision=HDL_OPEN_FILE_STATUS)
testbench = CodeEntity("testbench")
test_process = Process(
reset_statement,
FCT_OpenFile(file_status, input_stream, DATA_FILE_NAME),
ConditionBlock(
Comparison(file_status, OPEN_OK, specifier=Comparison.NotEqual),
Assert(
Constant(0, precision=ML_Bool),
" \"failed to open file {}\"".format(DATA_FILE_NAME),
severity=Assert.Failure
)
),
# consume legend line
FCT_ReadLine(input_stream, input_line),
WhileLoop(
LogicalNot(FCT_EndFile(input_stream)),
Statement(
FCT_ReadLine(input_stream, input_line),
input_statement,
Wait(time_step * (self.stage_num + 2)),
output_statement,
),
),
# end of test
Assert(
Constant(0, precision = ML_Bool),
" \"end of test, no error encountered \"",
severity = Assert.Warning
),
# infinite end loop
WhileLoop(
Constant(1, precision=ML_Bool),
Statement(
Wait(time_step * (self.stage_num + 2)),
)
)
)
testbench_scheme = Statement(
self_instance,
test_process
)
if self.pipelined:
half_time_step = time_step / 2
assert (half_time_step * 2) == time_step
# adding clock process for pipelined bench
clk_process = Process(
Statement(
ReferenceAssign(
io_map["clk"],
Constant(1, precision = ML_StdLogic)
),
Wait(half_time_step),
ReferenceAssign(
io_map["clk"],
Constant(0, precision = ML_StdLogic)
),
Wait(half_time_step),
)
)
testbench_scheme.push(clk_process)
testbench.add_process(testbench_scheme)
return [testbench]
def generate_pipeline_stage(entity,
reset=False,
recirculate=False,
one_process_per_stage=True):
""" Process a entity to generate pipeline stages required """
retiming_map = {}
retime_map = RetimeMap()
output_assign_list = entity.implementation.get_output_assign()
for output in output_assign_list:
Log.report(Log.Verbose, "generating pipeline from output {} ", output)
retime_op(output, retime_map)
for recirculate_stage in entity.recirculate_signal_map:
recirculate_ctrl = entity.recirculate_signal_map[recirculate_stage]
Log.report(Log.Verbose,
"generating pipeline from recirculation control signal {}",
recirculate_ctrl)
retime_op(recirculate_ctrl, retime_map)
process_statement = Statement()
# adding stage forward process
clk = entity.get_clk_input()
clock_statement = Statement()
# handle towards the first clock Process (in generation order)
# which must be the one whose pre_statement is filled with
# signal required to be generated outside the processes
first_process = False
for stage_id in sorted(retime_map.stage_forward.keys()):
stage_statement = Statement(*tuple(
assign for assign in retime_map.stage_forward[stage_id]))
if reset:
reset_statement = Statement()
for assign in retime_map.stage_forward[stage_id]:
target = assign.get_input(0)
reset_value = Constant(0, precision=target.get_precision())
reset_statement.push(ReferenceAssign(target, reset_value))
if recirculate:
# inserting recirculation condition
recirculate_signal = entity.get_recirculate_signal(stage_id)
stage_statement = ConditionBlock(
Comparison(
recirculate_signal,
Constant(0,
precision=recirculate_signal.get_precision()),
specifier=Comparison.Equal,
precision=ML_Bool), stage_statement)
stage_statement = ConditionBlock(
Comparison(entity.reset_signal,
Constant(1, precision=ML_StdLogic),
specifier=Comparison.Equal,
precision=ML_Bool), reset_statement,
stage_statement)
# To meet simulation / synthesis tools, we build
# a single if clock predicate block per stage
clock_block = ConditionBlock(
LogicalAnd(Event(clk, precision=ML_Bool),
Comparison(clk,
Constant(1, precision=ML_StdLogic),
specifier=Comparison.Equal,
precision=ML_Bool),
precision=ML_Bool), stage_statement)
if one_process_per_stage:
clock_process = Process(clock_block, sensibility_list=[clk])
entity.implementation.add_process(clock_process)
first_process = first_process or clock_process
else:
clock_statement.add(clock_block)
if one_process_per_stage:
pass
else:
process_statement.add(clock_statement)
pipeline_process = Process(process_statement, sensibility_list=[clk])
entity.implementation.add_process(pipeline_process)
first_process = pipeline_process
# statement that gather signals which must be pre-computed
for op in retime_map.pre_statement:
first_process.add_to_pre_statement(op)
stage_num = len(retime_map.stage_forward.keys())
#print "there are %d pipeline stages" % (stage_num)
return stage_num
def generate_scalar_scheme(self, vx, vy):
# fixing inputs' node tag
vx.set_attributes(tag="x")
vy.set_attributes(tag="y")
int_precision = self.precision.get_integer_format()
# assuming x = m.2^e (m in [1, 2[)
# n, positive or null integers
#
# pow(x, n) = x^(y)
# = exp(y * log(x))
# = 2^(y * log2(x))
# = 2^(y * (log2(m) + e))
#
e = ExponentExtraction(vx, tag="e", precision=int_precision)
m = MantissaExtraction(vx, tag="m", precision=self.precision)
# approximation log2(m)
# retrieving processor inverse approximation table
dummy_var = Variable("dummy", precision = self.precision)
dummy_div_seed = ReciprocalSeed(dummy_var, precision = self.precision)
inv_approx_table = self.processor.get_recursive_implementation(
dummy_div_seed, language=None,
table_getter= lambda self: self.approx_table_map)
log_f = sollya.log(sollya.x) # /sollya.log(self.basis)
ml_log_args = ML_GenericLog.get_default_args(precision=self.precision, basis=2)
ml_log = ML_GenericLog(ml_log_args)
log_table, log_table_tho, table_index_range = ml_log.generate_log_table(log_f, inv_approx_table)
log_approx = ml_log.generate_reduced_log_split(Abs(m, precision=self.precision), log_f, inv_approx_table, log_table)
log_approx = Select(Equal(vx, 0), FP_MinusInfty(self.precision), log_approx)
log_approx.set_attributes(tag="log_approx", debug=debug_multi)
r = Multiplication(log_approx, vy, tag="r", debug=debug_multi)
# 2^(y * (log2(m) + e)) = 2^(y * log2(m)) * 2^(y * e)
#
# log_approx = log2(Abs(m))
# r = y * log_approx ~ y * log2(m)
#
# NOTES: manage cases where e is negative and
# (y * log2(m)) AND (y * e) could cancel out
# if e positive, whichever the sign of y (y * log2(m)) and (y * e) CANNOT
# be of opposite signs
# log2(m) in [0, 1[ so cancellation can occur only if e == -1
# we split 2^x in 2^x = 2^t0 * 2^t1
# if e < 0: t0 = y * (log2(m) + e), t1=0
# else: t0 = y * log2(m), t1 = y * e
t_cond = e < 0
# e_y ~ e * y
e_f = Conversion(e, precision=self.precision)
#t0 = Select(t_cond, (e_f + log_approx) * vy, Multiplication(e_f, vy), tag="t0")
#NearestInteger(t0, precision=self.precision, tag="t0_int")
EY = NearestInteger(e_f * vy, tag="EY", precision=self.precision)
LY = NearestInteger(log_approx * vy, tag="LY", precision=self.precision)
t0_int = Select(t_cond, EY + LY, EY, tag="t0_int")
t0_frac = Select(t_cond, FMA(e_f, vy, -EY) + FMA(log_approx, vy, -LY) ,EY - t0_int, tag="t0_frac")
#t0_frac.set_attributes(tag="t0_frac")
ml_exp2_args = ML_Exp2.get_default_args(precision=self.precision)
ml_exp2 = ML_Exp2(ml_exp2_args)
exp2_t0_frac = ml_exp2.generate_scalar_scheme(t0_frac, inline_select=True)
exp2_t0_frac.set_attributes(tag="exp2_t0_frac", debug=debug_multi)
exp2_t0_int = ExponentInsertion(Conversion(t0_int, precision=int_precision), precision=self.precision, tag="exp2_t0_int")
t1 = Select(t_cond, Constant(0, precision=self.precision), r)
exp2_t1 = ml_exp2.generate_scalar_scheme(t1, inline_select=True)
exp2_t1.set_attributes(tag="exp2_t1", debug=debug_multi)
result_sign = Constant(1.0, precision=self.precision) # Select(n_is_odd, CopySign(vx, Constant(1.0, precision=self.precision)), 1)
y_int = NearestInteger(vy, precision=self.precision)
y_is_integer = Equal(y_int, vy)
y_is_even = LogicalOr(
# if y is a number (exc. inf) greater than 2**mantissa_size * 2,
# then it is an integer multiple of 2 => even
Abs(vy) >= 2**(self.precision.get_mantissa_size()+1),
LogicalAnd(
y_is_integer and Abs(vy) < 2**(self.precision.get_mantissa_size()+1),
# we want to limit the modulo computation to an integer input
Equal(Modulo(Conversion(y_int, precision=int_precision), 2), 0)
)
)
y_is_odd = LogicalAnd(
LogicalAnd(
Abs(vy) < 2**(self.precision.get_mantissa_size()+1),
y_is_integer
),
Equal(Modulo(Conversion(y_int, precision=int_precision), 2), 1)
)
# special cases management
special_case_results = Statement(
# x is sNaN OR y is sNaN
ConditionBlock(
LogicalOr(Test(vx, specifier=Test.IsSignalingNaN), Test(vy, specifier=Test.IsSignalingNaN)),
Return(FP_QNaN(self.precision))
),
# pow(x, ±0) is 1 if x is not a signaling NaN
ConditionBlock(
Test(vy, specifier=Test.IsZero),
Return(Constant(1.0, precision=self.precision))
),
# pow(±0, y) is ±∞ and signals the divideByZero exception for y an odd integer <0
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsZero), LogicalAnd(y_is_odd, vy < 0)),
Return(Select(Test(vx, specifier=Test.IsPositiveZero), FP_PlusInfty(self.precision), FP_MinusInfty(self.precision))),
),
# pow(±0, −∞) is +∞ with no exception
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsZero), Test(vy, specifier=Test.IsNegativeInfty)),
Return(FP_MinusInfty(self.precision)),
),
# pow(±0, +∞) is +0 with no exception
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsZero), Test(vy, specifier=Test.IsPositiveInfty)),
Return(FP_PlusInfty(self.precision)),
),
# pow(±0, y) is ±0 for finite y>0 an odd integer
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsZero), LogicalAnd(y_is_odd, vy > 0)),
Return(vx),
),
# pow(−1, ±∞) is 1 with no exception
ConditionBlock(
LogicalAnd(Equal(vx, -1), Test(vy, specifier=Test.IsInfty)),
Return(Constant(1.0, precision=self.precision)),
),
# pow(+1, y) is 1 for any y (even a quiet NaN)
ConditionBlock(
vx == 1,
Return(Constant(1.0, precision=self.precision)),
),
# pow(x, +∞) is +0 for −1<x<1
ConditionBlock(
LogicalAnd(Abs(vx) < 1, Test(vy, specifier=Test.IsPositiveInfty)),
Return(FP_PlusZero(self.precision))
),
# pow(x, +∞) is +∞ for x<−1 or for 1<x (including ±∞)
ConditionBlock(
LogicalAnd(Abs(vx) > 1, Test(vy, specifier=Test.IsPositiveInfty)),
Return(FP_PlusInfty(self.precision))
),
# pow(x, −∞) is +∞ for −1<x<1
ConditionBlock(
LogicalAnd(Abs(vx) < 1, Test(vy, specifier=Test.IsNegativeInfty)),
Return(FP_PlusInfty(self.precision))
),
# pow(x, −∞) is +0 for x<−1 or for 1<x (including ±∞)
ConditionBlock(
LogicalAnd(Abs(vx) > 1, Test(vy, specifier=Test.IsNegativeInfty)),
Return(FP_PlusZero(self.precision))
),
# pow(+∞, y) is +0 for a number y < 0
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsPositiveInfty), vy < 0),
Return(FP_PlusZero(self.precision))
),
# pow(+∞, y) is +∞ for a number y > 0
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsPositiveInfty), vy > 0),
Return(FP_PlusInfty(self.precision))
),
# pow(−∞, y) is −0 for finite y < 0 an odd integer
# TODO: check y is finite
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsNegativeInfty), LogicalAnd(y_is_odd, vy < 0)),
Return(FP_MinusZero(self.precision)),
),
# pow(−∞, y) is −∞ for finite y > 0 an odd integer
# TODO: check y is finite
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsNegativeInfty), LogicalAnd(y_is_odd, vy > 0)),
Return(FP_MinusInfty(self.precision)),
),
# pow(−∞, y) is +0 for finite y < 0 and not an odd integer
# TODO: check y is finite
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsNegativeInfty), LogicalAnd(LogicalNot(y_is_odd), vy < 0)),
Return(FP_PlusZero(self.precision)),
),
# pow(−∞, y) is +∞ for finite y > 0 and not an odd integer
# TODO: check y is finite
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsNegativeInfty), LogicalAnd(LogicalNot(y_is_odd), vy > 0)),
Return(FP_PlusInfty(self.precision)),
),
# pow(±0, y) is +∞ and signals the divideByZero exception for finite y<0 and not an odd integer
# TODO: signal divideByZero exception
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsZero), LogicalAnd(LogicalNot(y_is_odd), vy < 0)),
Return(FP_PlusInfty(self.precision)),
),
# pow(±0, y) is +0 for finite y>0 and not an odd integer
ConditionBlock(
LogicalAnd(Test(vx, specifier=Test.IsZero), LogicalAnd(LogicalNot(y_is_odd), vy > 0)),
Return(FP_PlusZero(self.precision)),
),
)
# manage n=1 separately to avoid catastrophic propagation of errors
# between log2 and exp2 to eventually compute the identity function
# test-case #3
result = Statement(
special_case_results,
# fallback default cases
Return(result_sign * exp2_t1 * exp2_t0_int * exp2_t0_frac))
return result
def generate_scheme(self):
# We wish to compute vx / vy
vx = self.implementation.add_input_variable(
"x", self.precision, interval=self.input_intervals[0])
vy = self.implementation.add_input_variable(
"y", self.precision, interval=self.input_intervals[1])
# maximum exponent magnitude (to avoid overflow/ underflow during
# intermediary computations
int_prec = self.precision.get_integer_format()
max_exp_mag = Constant(self.precision.get_emax() - 1,
precision=int_prec)
exact_ex = ExponentExtraction(vx,
tag="exact_ex",
precision=int_prec,
debug=debug_multi)
exact_ey = ExponentExtraction(vy,
tag="exact_ey",
precision=int_prec,
debug=debug_multi)
ex = Max(Min(exact_ex, max_exp_mag, precision=int_prec),
-max_exp_mag,
tag="ex",
precision=int_prec)
ey = Max(Min(exact_ey, max_exp_mag, precision=int_prec),
-max_exp_mag,
tag="ey",
precision=int_prec)
Attributes.set_default_rounding_mode(ML_RoundToNearest)
Attributes.set_default_silent(True)
# computing the inverse square root
init_approx = None
scaling_factor_x = ExponentInsertion(-ex,
tag="sfx_ei",
precision=self.precision,
debug=debug_multi)
scaling_factor_y = ExponentInsertion(-ey,
tag="sfy_ei",
precision=self.precision,
debug=debug_multi)
def test_interval_out_of_bound_risk(x_range, y_range):
""" Try to determine from x and y's interval if there is a risk
of underflow or overflow """
div_range = abs(x_range / y_range)
underflow_risk = sollya.inf(div_range) < S2**(
self.precision.get_emin_normal() + 2)
overflow_risk = sollya.sup(div_range) > S2**(
self.precision.get_emax() - 2)
return underflow_risk or overflow_risk
out_of_bound_risk = (self.input_intervals[0] is None
or self.input_intervals[1] is None
) or test_interval_out_of_bound_risk(
self.input_intervals[0],
self.input_intervals[1])
Log.report(Log.Debug,
"out_of_bound_risk: {}".format(out_of_bound_risk))
# scaled version of vx and vy, to avoid overflow and underflow
if out_of_bound_risk:
scaled_vx = vx * scaling_factor_x
scaled_vy = vy * scaling_factor_y
scaled_interval = MetaIntervalList(
[MetaInterval(Interval(-2, -1)),
MetaInterval(Interval(1, 2))])
scaled_vx.set_attributes(tag="scaled_vx",
debug=debug_multi,
interval=scaled_interval)
scaled_vy.set_attributes(tag="scaled_vy",
debug=debug_multi,
interval=scaled_interval)
seed_interval = 1 / scaled_interval
print("seed_interval=1/{}={}".format(scaled_interval,
seed_interval))
else:
scaled_vx = vx
scaled_vy = vy
seed_interval = 1 / scaled_vy.get_interval()
# We need a first approximation to 1 / scaled_vy
dummy_seed = ReciprocalSeed(EmptyOperand(precision=self.precision),
precision=self.precision)
if self.processor.is_supported_operation(dummy_seed, self.language):
init_approx = ReciprocalSeed(scaled_vy,
precision=self.precision,
tag="init_approx",
debug=debug_multi)
else:
# generate tabulated version of seed
raise NotImplementedError
current_approx_std = init_approx
# correctly-rounded inverse computation
num_iteration = self.num_iter
Attributes.unset_default_rounding_mode()
Attributes.unset_default_silent()
# check if inputs are zeros
x_zero = Test(vx,
specifier=Test.IsZero,
likely=False,
precision=ML_Bool)
y_zero = Test(vy,
specifier=Test.IsZero,
likely=False,
precision=ML_Bool)
comp_sign = Test(vx,
vy,
specifier=Test.CompSign,
tag="comp_sign",
debug=debug_multi)
# check if divisor is NaN
y_nan = Test(vy, specifier=Test.IsNaN, likely=False, precision=ML_Bool)
# check if inputs are signaling NaNs
x_snan = Test(vx,
specifier=Test.IsSignalingNaN,
likely=False,
precision=ML_Bool)
y_snan = Test(vy,
specifier=Test.IsSignalingNaN,
likely=False,
precision=ML_Bool)
# check if inputs are infinities
x_inf = Test(vx,
specifier=Test.IsInfty,
likely=False,
tag="x_inf",
precision=ML_Bool)
y_inf = Test(vy,
specifier=Test.IsInfty,
likely=False,
tag="y_inf",
debug=debug_multi,
precision=ML_Bool)
scheme = None
gappa_vx, gappa_vy = None, None
# initial reciprocal approximation of 1.0 / scaled_vy
inv_iteration_list, recp_approx = compute_reduced_reciprocal(
init_approx, scaled_vy, self.num_iter)
recp_approx.set_attributes(tag="recp_approx", debug=debug_multi)
# approximation of scaled_vx / scaled_vy
yerr_last, reduced_div_approx, div_iteration_list = compute_reduced_division(
scaled_vx, scaled_vy, recp_approx)
eval_error_range, div_eval_error_range = self.solve_eval_error(
init_approx, recp_approx, reduced_div_approx, scaled_vx, scaled_vy,
inv_iteration_list, div_iteration_list, S2**-7, seed_interval)
eval_error = sup(abs(eval_error_range))
recp_interval = 1 / scaled_vy.get_interval() + eval_error_range
recp_approx.set_interval(recp_interval)
div_interval = scaled_vx.get_interval() / scaled_vy.get_interval(
) + div_eval_error_range
reduced_div_approx.set_interval(div_interval)
reduced_div_approx.set_tag("reduced_div_approx")
if out_of_bound_risk:
unscaled_result = scaling_div_result(reduced_div_approx, ex,
scaling_factor_y,
self.precision)
subnormal_result = subnormalize_result(recp_approx,
reduced_div_approx, ex, ey,
yerr_last, self.precision)
else:
unscaled_result = reduced_div_approx
subnormal_result = reduced_div_approx
x_inf_or_nan = Test(vx, specifier=Test.IsInfOrNaN, likely=False)
y_inf_or_nan = Test(vy,
specifier=Test.IsInfOrNaN,
likely=False,
tag="y_inf_or_nan",
debug=debug_multi)
# generate IEEE exception raising only of libm-compliant
# mode is enabled
enable_raise = self.libm_compliant
# managing special cases
# x inf and y inf
pre_scheme = ConditionBlock(
x_inf_or_nan,
ConditionBlock(
x_inf,
ConditionBlock(
y_inf_or_nan,
Statement(
# signaling NaNs raise invalid operation flags
ConditionBlock(y_snan, Raise(ML_FPE_Invalid))
if enable_raise else Statement(),
Return(FP_QNaN(self.precision)),
),
ConditionBlock(comp_sign,
Return(FP_MinusInfty(self.precision)),
Return(FP_PlusInfty(self.precision)))),
Statement(
ConditionBlock(x_snan, Raise(ML_FPE_Invalid))
if enable_raise else Statement(),
Return(FP_QNaN(self.precision)))),
ConditionBlock(
x_zero,
ConditionBlock(
LogicalOr(y_zero, y_nan, precision=ML_Bool),
Statement(
ConditionBlock(y_snan, Raise(ML_FPE_Invalid))
if enable_raise else Statement(),
Return(FP_QNaN(self.precision))), Return(vx)),
ConditionBlock(
y_inf_or_nan,
ConditionBlock(
y_inf,
Return(
Select(comp_sign, FP_MinusZero(self.precision),
FP_PlusZero(self.precision))),
Statement(
ConditionBlock(y_snan, Raise(ML_FPE_Invalid))
if enable_raise else Statement(),
Return(FP_QNaN(self.precision)))),
ConditionBlock(
y_zero,
Statement(
Raise(ML_FPE_DivideByZero)
if enable_raise else Statement(),
ConditionBlock(
comp_sign,
Return(FP_MinusInfty(self.precision)),
Return(FP_PlusInfty(self.precision)))),
# managing numerical value result cases
Statement(
recp_approx,
reduced_div_approx,
ConditionBlock(
Test(unscaled_result,
specifier=Test.IsSubnormal,
likely=False),
# result is subnormal
Statement(
# inexact flag should have been raised when computing yerr_last
# ConditionBlock(
# Comparison(
# yerr_last, 0,
# specifier=Comparison.NotEqual, likely=True),
# Statement(Raise(ML_FPE_Inexact, ML_FPE_Underflow))
#),
Return(subnormal_result), ),
# result is normal
Statement(
# inexact flag should have been raised when computing yerr_last
#ConditionBlock(
# Comparison(
# yerr_last, 0,
# specifier=Comparison.NotEqual, likely=True),
# Raise(ML_FPE_Inexact)
#),
Return(unscaled_result))),
)))))
# managing rounding mode save and restore
# to ensure intermediary computations are performed in round-to-nearest
# clearing exception before final computation
#rnd_mode = GetRndMode()
#scheme = Statement(
# rnd_mode,
# SetRndMode(ML_RoundToNearest),
# yerr_last,
# SetRndMode(rnd_mode),
# unscaled_result,
# ClearException(),
# pre_scheme
#)
scheme = pre_scheme
return scheme
def generate_scalar_scheme(self, vx, n):
# fixing inputs' node tag
vx.set_attributes(tag="x")
n.set_attributes(tag="n")
int_precision = self.precision.get_integer_format()
# assuming x = m.2^e (m in [1, 2[)
# n, positive or null integers
#
# rootn(x, n) = x^(1/n)
# = exp(1/n * log(x))
# = 2^(1/n * log2(x))
# = 2^(1/n * (log2(m) + e))
#
# approximation log2(m)
# retrieving processor inverse approximation table
dummy_var = Variable("dummy", precision=self.precision)
dummy_div_seed = ReciprocalSeed(dummy_var, precision=self.precision)
inv_approx_table = self.processor.get_recursive_implementation(
dummy_div_seed,
language=None,
table_getter=lambda self: self.approx_table_map)
log_f = sollya.log(sollya.x) # /sollya.log(self.basis)
use_reciprocal = False
# non-scaled vx used to compute vx^1
unmodified_vx = vx
is_subnormal = Test(vx, specifier=Test.IsSubnormal, tag="is_subnormal")
exp_correction_factor = self.precision.get_mantissa_size()
mantissa_factor = Constant(2**exp_correction_factor,
tag="mantissa_factor")
vx = Select(is_subnormal, vx * mantissa_factor, vx, tag="corrected_vx")
m = MantissaExtraction(vx, tag="m", precision=self.precision)
e = ExponentExtraction(vx, tag="e", precision=int_precision)
e = Select(is_subnormal,
e - exp_correction_factor,
e,
tag="corrected_e")
ml_log_args = ML_GenericLog.get_default_args(precision=self.precision,
basis=2)
ml_log = ML_GenericLog(ml_log_args)
log_table, log_table_tho, table_index_range = ml_log.generate_log_table(
log_f, inv_approx_table)
log_approx = ml_log.generate_reduced_log_split(
Abs(m, precision=self.precision), log_f, inv_approx_table,
log_table)
# floating-point version of n
n_f = Conversion(n, precision=self.precision, tag="n_f")
inv_n = Division(Constant(1, precision=self.precision), n_f)
log_approx = Select(Equal(vx, 0), FP_MinusInfty(self.precision),
log_approx)
log_approx.set_attributes(tag="log_approx", debug=debug_multi)
if use_reciprocal:
r = Multiplication(log_approx, inv_n, tag="r", debug=debug_multi)
else:
r = Division(log_approx, n_f, tag="r", debug=debug_multi)
# e_n ~ e / n
e_f = Conversion(e, precision=self.precision, tag="e_f")
if use_reciprocal:
e_n = Multiplication(e_f, inv_n, tag="e_n")
else:
e_n = Division(e_f, n_f, tag="e_n")
error_e_n = FMA(e_n, -n_f, e_f, tag="error_e_n")
e_n_int = NearestInteger(e_n, precision=self.precision, tag="e_n_int")
pre_e_n_frac = e_n - e_n_int
pre_e_n_frac.set_attributes(tag="pre_e_n_frac")
e_n_frac = pre_e_n_frac + error_e_n * inv_n
e_n_frac.set_attributes(tag="e_n_frac")
ml_exp2_args = ML_Exp2.get_default_args(precision=self.precision)
ml_exp2 = ML_Exp2(ml_exp2_args)
exp2_r = ml_exp2.generate_scalar_scheme(r, inline_select=True)
exp2_r.set_attributes(tag="exp2_r", debug=debug_multi)
exp2_e_n_frac = ml_exp2.generate_scalar_scheme(e_n_frac,
inline_select=True)
exp2_e_n_frac.set_attributes(tag="exp2_e_n_frac", debug=debug_multi)
exp2_e_n_int = ExponentInsertion(Conversion(e_n_int,
precision=int_precision),
precision=self.precision,
tag="exp2_e_n_int")
n_is_even = Equal(Modulo(n, 2), 0, tag="n_is_even", debug=debug_multi)
n_is_odd = LogicalNot(n_is_even, tag="n_is_odd")
result_sign = Select(
n_is_odd, CopySign(vx, Constant(1.0, precision=self.precision)), 1)
# managing n == -1
if self.expand_div:
ml_division_args = ML_Division.get_default_args(
precision=self.precision, input_formats=[self.precision] * 2)
ml_division = ML_Division(ml_division_args)
self.division_implementation = ml_division.implementation
self.division_implementation.set_scheme(
ml_division.generate_scheme())
ml_division_fct = self.division_implementation.get_function_object(
)
else:
ml_division_fct = Division
# manage n=1 separately to avoid catastrophic propagation of errors
# between log2 and exp2 to eventually compute the identity function
# test-case #3
result = ConditionBlock(
LogicalOr(LogicalOr(Test(vx, specifier=Test.IsNaN), Equal(n, 0)),
LogicalAnd(n_is_even, vx < 0)),
Return(FP_QNaN(self.precision)),
Statement(
ConditionBlock(
Equal(n, -1, tag="n_is_mone"),
#Return(Division(Constant(1, precision=self.precision), unmodified_vx, tag="div_res", precision=self.precision)),
Return(
ml_division_fct(Constant(1, precision=self.precision),
unmodified_vx,
tag="div_res",
precision=self.precision)),
),
ConditionBlock(
# rootn( ±inf, n) is +∞ for even n< 0.
Test(vx, specifier=Test.IsInfty),
Statement(
ConditionBlock(
n < 0,
#LogicalAnd(n_is_odd, n < 0),
Return(
Select(Test(vx,
specifier=Test.IsPositiveInfty),
Constant(FP_PlusZero(self.precision),
precision=self.precision),
Constant(FP_MinusZero(self.precision),
precision=self.precision),
precision=self.precision)),
Return(vx),
), ),
),
ConditionBlock(
# rootn(±0, n) is ±∞ for odd n < 0.
LogicalAnd(LogicalAnd(n_is_odd, n < 0),
Equal(vx, 0),
tag="n_is_odd_and_neg"),
Return(
Select(Test(vx, specifier=Test.IsPositiveZero),
Constant(FP_PlusInfty(self.precision),
precision=self.precision),
Constant(FP_MinusInfty(self.precision),
precision=self.precision),
precision=self.precision)),
),
ConditionBlock(
# rootn( ±0, n) is +∞ for even n< 0.
LogicalAnd(LogicalAnd(n_is_even, n < 0), Equal(vx, 0)),
Return(FP_PlusInfty(self.precision))),
ConditionBlock(
# rootn(±0, n) is +0 for even n > 0.
LogicalAnd(n_is_even, Equal(vx, 0)),
Return(vx)),
ConditionBlock(
Equal(n, 1), Return(unmodified_vx),
Return(result_sign * exp2_r * exp2_e_n_int *
exp2_e_n_frac))))
return result
def generate_array_check_loop(self, input_tables, output_array,
table_size_offset_array, array_offset,
array_len, test_id):
# internal array iterator index
vj = Variable("j", precision=ML_UInt32, var_type=Variable.Local)
printf_input_function = self.get_printf_input_function()
printf_error_template = "printf(\"max %s error is %s \\n\", %s)" % (
self.function_name,
self.precision.get_display_format().format_string,
self.precision.get_display_format().pre_process_fct("{0}"))
printf_error_op = TemplateOperatorFormat(printf_error_template,
arity=1,
void_function=True,
require_header=["stdio.h"])
printf_error_function = FunctionObject("printf", [self.precision],
ML_Void, printf_error_op)
printf_max_op = FunctionOperator(
"printf",
arg_map={
0:
"\"max %s error is reached at input number %s \\n \"" %
(self.function_name, "%d"),
1:
FO_Arg(0)
},
void_function=True,
require_header=["stdio.h"])
printf_max_function = FunctionObject("printf", [self.precision],
ML_Void, printf_max_op)
NUM_INPUT_ARRAY = len(input_tables)
# generate the expected table for the whole multi-array
expected_table = self.generate_expected_table(input_tables,
table_size_offset_array)
# inputs for the (vj)-th entry of the sub-arrat
local_inputs = tuple(
TableLoad(input_tables[in_id], array_offset + vj)
for in_id in range(NUM_INPUT_ARRAY))
# expected values for the (vj)-th entry of the sub-arrat
expected_values = [
TableLoad(expected_table, array_offset + vj, i)
for i in range(self.accuracy.get_num_output_value())
]
# local result for the (vj)-th entry of the sub-arrat
local_result = TableLoad(output_array, array_offset + vj)
if self.break_error:
return_statement_break = Statement(
printf_input_function(*((vj, ) + local_inputs +
(local_result, ))),
self.accuracy.get_output_print_call(self.function_name,
output_values))
else:
return_statement_break = Statement(
printf_input_function(*((vj, ) + local_inputs +
(local_result, ))),
self.accuracy.get_output_print_call(self.function_name,
expected_values),
Return(Constant(1, precision=ML_Int32)))
# loop implementation to check sub-array array_offset
# results validity
check_array_loop = Loop(
ReferenceAssign(vj, 0), vj < array_len,
Statement(
ConditionBlock(
self.accuracy.get_output_check_test(
local_result, expected_values),
return_statement_break),
ReferenceAssign(vj, vj + 1),
))
return check_array_loop
def generate_scheme(self):
int_precision = self.precision.get_integer_format()
# We wish to compute vx / vy
vx = self.implementation.add_input_variable("x", self.precision, interval=self.input_intervals[0])
vy = self.implementation.add_input_variable("y", self.precision, interval=self.input_intervals[1])
if self.mode is FULL_MODE:
quo = self.implementation.add_input_variable("quo", ML_Pointer_Format(int_precision))
i = Variable("i", precision=int_precision, var_type=Variable.Local)
q = Variable("q", precision=int_precision, var_type=Variable.Local)
CI = lambda v: Constant(v, precision=int_precision)
CF = lambda v: Constant(v, precision=self.precision)
vx_subnormal = Test(vx, specifier=Test.IsSubnormal, tag="vx_subnormal")
vy_subnormal = Test(vy, specifier=Test.IsSubnormal, tag="vy_subnormal")
DELTA_EXP = self.precision.get_mantissa_size()
scale_factor = Constant(2.0**DELTA_EXP, precision=self.precision)
inv_scale_factor = Constant(2.0**-DELTA_EXP, precision=self.precision)
normalized_vx = Select(vx_subnormal, vx * scale_factor, vx, tag="scaled_vx")
normalized_vy = Select(vy_subnormal, vy * scale_factor, vy, tag="scaled_vy")
real_ex = ExponentExtraction(vx, tag="real_ex", precision=int_precision)
real_ey = ExponentExtraction(vy, tag="real_ey", precision=int_precision)
# if real_e<x/y> is +1023 then it may Overflow in -real_ex for ExponentInsertion
# which only supports downto -1022 before falling into subnormal numbers (which are
# not supported by ExponentInsertion)
real_ex_h0 = real_ex / 2
real_ex_h1 = real_ex - real_ex_h0
real_ey_h0 = real_ey / 2
real_ey_h1 = real_ey - real_ey_h0
EI = lambda v: ExponentInsertion(v, precision=self.precision)
mx = Abs((vx * EI(-real_ex_h0)) * EI(-real_ex_h1), tag="mx")
my = Abs((vy * EI(-real_ey_h0)) * EI(-real_ey_h1), tag="pre_my")
# scale_ey is used to regain the unscaling of mx in the first loop
# if real_ey >= real_ex, the first loop is never executed
# so a different scaling is required
mx_unscaling = Select(real_ey < real_ex, real_ey, real_ex)
ey_half0 = (mx_unscaling) / 2
ey_half1 = (mx_unscaling) - ey_half0
scale_ey_half0 = ExponentInsertion(ey_half0, precision=self.precision, tag="scale_ey_half0")
scale_ey_half1 = ExponentInsertion(ey_half1, precision=self.precision, tag="scale_ey_half1")
# if only vy is subnormal we want to normalize it
#normal_cond = LogicalAnd(vy_subnormal, LogicalNot(vx_subnormal))
normal_cond = vy_subnormal #LogicalAnd(vy_subnormal, LogicalNot(vx_subnormal))
my = Select(normal_cond, Abs(MantissaExtraction(vy * scale_factor)), my, tag="my")
# vx / vy = vx * 2^-ex * 2^(ex-ey) / (vy * 2^-ey)
# vx % vy
post_mx = Variable("post_mx", precision=self.precision, var_type=Variable.Local)
# scaling for half comparison
VY_SCALING = Select(vy_subnormal, 1.0, 0.5, precision=self.precision)
VX_SCALING = Select(vy_subnormal, 2.0, 1.0, precision=self.precision)
def LogicalXor(a, b):
return LogicalOr(LogicalAnd(a, LogicalNot(b)), LogicalAnd(LogicalNot(a), b))
rem_sign = Select(vx < 0, CF(-1), CF(1), precision=self.precision, tag="rem_sign")
quo_sign = Select(LogicalXor(vx <0, vy < 0), CI(-1), CI(1), precision=int_precision, tag="quo_sign")
loop_watchdog = Variable("loop_watchdog", precision=ML_Int32, var_type=Variable.Local)
loop = Statement(
real_ex, real_ey, mx, my, loop_watchdog,
ReferenceAssign(loop_watchdog, 5000),
ReferenceAssign(q, CI(0)),
Loop(
ReferenceAssign(i, CI(0)), i < (real_ex - real_ey),
Statement(
ReferenceAssign(i, i+CI(1)),
ReferenceAssign(q, ((q << 1) + Select(mx >= my, CI(1), CI(0))).modify_attributes(tag="step1_q")),
ReferenceAssign(mx, (CF(2) * (mx - Select(mx >= my, my, CF(0)))).modify_attributes(tag="step1_mx")),
# loop watchdog
ReferenceAssign(loop_watchdog, loop_watchdog - 1),
ConditionBlock(loop_watchdog < 0, Return(-1)),
),
),
# unscaling remainder
ReferenceAssign(mx, ((mx * scale_ey_half0) * scale_ey_half1).modify_attributes(tag="scaled_rem")),
ReferenceAssign(my, ((my * scale_ey_half0) * scale_ey_half1).modify_attributes(tag="scaled_rem_my")),
Loop(
Statement(), (my > Abs(vy)),
Statement(
ReferenceAssign(q, ((q << 1) + Select(mx >= Abs(my), CI(1), CI(0))).modify_attributes(tag="step2_q")),
ReferenceAssign(mx, (mx - Select(mx >= Abs(my), Abs(my), CF(0))).modify_attributes(tag="step2_mx")),
ReferenceAssign(my, (my * 0.5).modify_attributes(tag="step2_my")),
# loop watchdog
ReferenceAssign(loop_watchdog, loop_watchdog - 1),
ConditionBlock(loop_watchdog < 0, Return(-1)),
),
),
ReferenceAssign(q, q << 1),
Loop(
ReferenceAssign(i, CI(0)), mx > Abs(vy),
Statement(
ReferenceAssign(q, (q + Select(mx > Abs(vy), CI(1), CI(0))).modify_attributes(tag="step3_q")),
ReferenceAssign(mx, (mx - Select(mx > Abs(vy), Abs(vy), CF(0))).modify_attributes(tag="step3_mx")),
# loop watchdog
ReferenceAssign(loop_watchdog, loop_watchdog - 1),
ConditionBlock(loop_watchdog < 0, Return(-1)),
),
),
ReferenceAssign(q, q + Select(mx >= Abs(vy), CI(1), CI(0))),
ReferenceAssign(mx, (mx - Select(mx >= Abs(vy), Abs(vy), CF(0))).modify_attributes(tag="pre_half_mx")),
ConditionBlock(
# actual comparison is mx > | abs(vy * 0.5) | to avoid rounding effect when
# vy is subnormal we mulitply both side by 2.0**60
((mx * VX_SCALING) > Abs(vy * VY_SCALING)).modify_attributes(tag="half_test"),
Statement(
ReferenceAssign(q, q + CI(1)),
ReferenceAssign(mx, (mx - Abs(vy)))
)
),
ConditionBlock(
# if the remainder is exactly half the dividend
# we need to make sure the quotient is even
LogicalAnd(
Equal(mx * VX_SCALING, Abs(vy * VY_SCALING)),
Equal(Modulo(q, CI(2)), CI(1)),
),
Statement(
ReferenceAssign(q, q + CI(1)),
ReferenceAssign(mx, (mx - Abs(vy)))
)
),
ReferenceAssign(mx, rem_sign * mx),
ReferenceAssign(q,
Modulo(TypeCast(q, precision=self.precision.get_unsigned_integer_format()), Constant(2**self.quotient_size, precision=self.precision.get_unsigned_integer_format()), tag="mod_q")
),
ReferenceAssign(q, quo_sign * q),
)
# NOTES: Warning QuotientReturn must always preceeds RemainderReturn
if self.mode is QUOTIENT_MODE:
#
QuotientReturn = Return
RemainderReturn = lambda _: Statement()
elif self.mode is REMAINDER_MODE:
QuotientReturn = lambda _: Statement()
RemainderReturn = Return
elif self.mode is FULL_MODE:
QuotientReturn = lambda v: ReferenceAssign(Dereference(quo, precision=int_precision), v)
RemainderReturn = Return
else:
raise NotImplemented
# quotient invalid value
QUO_INVALID_VALUE = 0
mod_scheme = Statement(
# x or y is NaN, a NaN is returned
ConditionBlock(
LogicalOr(Test(vx, specifier=Test.IsNaN), Test(vy, specifier=Test.IsNaN)),
Statement(
QuotientReturn(QUO_INVALID_VALUE),
RemainderReturn(FP_QNaN(self.precision))
),
),
#
ConditionBlock(
Test(vy, specifier=Test.IsZero),
Statement(
QuotientReturn(QUO_INVALID_VALUE),
RemainderReturn(FP_QNaN(self.precision))
),
),
ConditionBlock(
Test(vx, specifier=Test.IsZero),
Statement(
QuotientReturn(0),
RemainderReturn(vx)
),
),
ConditionBlock(
Test(vx, specifier=Test.IsInfty),
Statement(
QuotientReturn(QUO_INVALID_VALUE),
RemainderReturn(FP_QNaN(self.precision))
)
),
ConditionBlock(
Test(vy, specifier=Test.IsInfty),
Statement(
QuotientReturn(0),
RemainderReturn(vx),
)
),
ConditionBlock(
Abs(vx) < Abs(vy * 0.5),
Statement(
QuotientReturn(0),
RemainderReturn(vx),
)
),
ConditionBlock(
Equal(vx, vy),
Statement(
QuotientReturn(1),
# 0 with the same sign as x
RemainderReturn(vx - vx),
),
),
ConditionBlock(
Equal(vx, -vy),
Statement(
# quotient is -1
QuotientReturn(-1),
# 0 with the same sign as x
RemainderReturn(vx - vx),
),
),
loop,
QuotientReturn(q),
RemainderReturn(mx),
)
quo_scheme = Statement(
# x or y is NaN, a NaN is returned
ConditionBlock(
LogicalOr(Test(vx, specifier=Test.IsNaN), Test(vy, specifier=Test.IsNaN)),
Return(QUO_INVALID_VALUE),
),
#
ConditionBlock(
Test(vy, specifier=Test.IsZero),
Return(QUO_INVALID_VALUE),
),
ConditionBlock(
Test(vx, specifier=Test.IsZero),
Return(0),
),
ConditionBlock(
Test(vx, specifier=Test.IsInfty),
Return(QUO_INVALID_VALUE),
),
ConditionBlock(
Test(vy, specifier=Test.IsInfty),
Return(QUO_INVALID_VALUE),
),
ConditionBlock(
Abs(vx) < Abs(vy * 0.5),
Return(0),
),
ConditionBlock(
Equal(vx, vy),
Return(1),
),
ConditionBlock(
Equal(vx, -vy),
Return(-1),
),
loop,
Return(q),
)
return mod_scheme
def generate_pipeline_stage(entity, reset=False, recirculate=False, one_process_per_stage=True, synchronous_reset=True, negate_reset=False):
""" Process a entity to generate pipeline stages required to implement
pipeline structure described by node's stage attributes.
:param entity: input entity to pipeline
:type entity: ML_EntityBasis
:param reset: indicate if a reset must be generated for pipeline registers
:type reset: bool
:param recirculate: trigger the integration of a recirculation signal to the stage
flopping condition
:type recirculate: bool
:param one_process_per_stage:forces the generation of a separate process for each
pipeline stage (else a unique process is generated for all the stages
:type one_process_per_stage: bool
:param synchronous_reset: triggers the generation of a clocked reset
:type synchronous_reset: bool
:param negate_reset: if set indicates the reset is triggered when reset signal is 0
(else 1)
:type negate_reset: bool
"""
retiming_map = {}
retime_map = RetimeMap()
output_assign_list = entity.implementation.get_output_assign()
for output in output_assign_list:
Log.report(Log.Verbose, "generating pipeline from output {} ", output)
retime_op(output, retime_map)
for recirculate_stage in entity.recirculate_signal_map:
recirculate_ctrl = entity.recirculate_signal_map[recirculate_stage]
Log.report(Log.Verbose, "generating pipeline from recirculation control signal {}", recirculate_ctrl)
retime_op(recirculate_ctrl, retime_map)
process_statement = Statement()
# adding stage forward process
clk = entity.get_clk_input()
clock_statement = Statement()
global_reset_statement = Statement()
Log.report(Log.Info, "design has {} flip-flop(s).", retime_map.register_count)
# handle towards the first clock Process (in generation order)
# which must be the one whose pre_statement is filled with
# signal required to be generated outside the processes
first_process = False
for stage_id in sorted(retime_map.stage_forward.keys()):
stage_statement = Statement(
*tuple(assign for assign in retime_map.stage_forward[stage_id]))
if reset:
reset_statement = Statement()
for assign in retime_map.stage_forward[stage_id]:
target = assign.get_input(0)
reset_value = Constant(0, precision=target.get_precision())
reset_statement.push(ReferenceAssign(target, reset_value))
if recirculate:
# inserting recirculation condition
recirculate_signal = entity.get_recirculate_signal(stage_id)
stage_statement = ConditionBlock(
Comparison(
recirculate_signal,
Constant(0, precision=recirculate_signal.get_precision()),
specifier=Comparison.Equal,
precision=ML_Bool
),
stage_statement
)
if synchronous_reset:
# build a compound statement with reset and flops statement
stage_statement = ConditionBlock(
Comparison(
entity.reset_signal,
Constant(0 if negate_reset else 1, precision=ML_StdLogic),
specifier=Comparison.Equal, precision=ML_Bool
),
reset_statement,
stage_statement
)
else:
# for asynchronous reset, reset is in a non-clocked statement
# and will be added at the end of stage to the same process than
# register clocking
global_reset_statement.add(reset_statement)
# To meet simulation / synthesis tools, we build
# a single if clock predicate block per stage
clock_block = ConditionBlock(
LogicalAnd(
Event(clk, precision=ML_Bool),
Comparison(
clk,
Constant(1, precision=ML_StdLogic),
specifier=Comparison.Equal,
precision=ML_Bool
),
precision=ML_Bool
),
stage_statement
)
if one_process_per_stage:
if reset and not synchronous_reset:
clock_block = ConditionBlock(
Comparison(
entity.reset_signal,
Constant(0 if negate_reset else 1, precision=ML_StdLogic),
specifier=Comparison.Equal, precision=ML_Bool
),
reset_statement,
clock_block
)
clock_process = Process(clock_block, sensibility_list=[clk, entity.reset_signal])
else:
# no reset, or synchronous reset (already appended to clock_block)
clock_process = Process(clock_block, sensibility_list=[clk])
entity.implementation.add_process(clock_process)
first_process = first_process or clock_process
else:
clock_statement.add(clock_block)
if one_process_per_stage:
# reset and clock processed where generated at each stage loop
pass
else:
process_statement.add(clock_statement)
if synchronous_reset:
pipeline_process = Process(process_statement, sensibility_list=[clk])
else:
process_statement.add(global_reset_statement)
pipeline_process = Process(process_statement, sensibility_list=[clk, entity.reset_signal])
entity.implementation.add_process(pipeline_process)
first_process = pipeline_process
# statement that gather signals which must be pre-computed
for op in retime_map.pre_statement:
first_process.add_to_pre_statement(op)
stage_num = len(retime_map.stage_forward.keys())
Log.report(Log.Info, "there are {} pipeline stage(s)", stage_num)
return stage_num
def generate_auto_test(self,
test_num=10,
test_range=Interval(-1.0, 1.0),
debug=False,
time_step=10):
""" time_step: duration of a stage (in ns) """
# instanciating tested component
# map of input_tag -> input_signal and output_tag -> output_signal
io_map = {}
# map of input_tag -> input_signal, excludind commodity signals
# (e.g. clock and reset)
input_signals = {}
# map of output_tag -> output_signal
output_signals = {}
# excluding clock and reset signals from argument list
# reduced_arg_list = [input_port for input_port in self.implementation.get_arg_list() if not input_port.get_tag() in ["clk", "reset"]]
reduced_arg_list = self.implementation.get_arg_list()
for input_port in reduced_arg_list:
input_tag = input_port.get_tag()
input_signal = Signal(input_tag + "_i",
precision=input_port.get_precision(),
var_type=Signal.Local)
io_map[input_tag] = input_signal
if not input_tag in ["clk", "reset"]:
input_signals[input_tag] = input_signal
for output_port in self.implementation.get_output_port():
output_tag = output_port.get_tag()
output_signal = Signal(output_tag + "_o",
precision=output_port.get_precision(),
var_type=Signal.Local)
io_map[output_tag] = output_signal
output_signals[output_tag] = output_signal
# building list of test cases
tc_list = []
self_component = self.implementation.get_component_object()
self_instance = self_component(io_map=io_map, tag="tested_entity")
test_statement = Statement()
# initializing random test case generator
self.init_test_generator()
# Appending standard test cases if required
if self.auto_test_std:
tc_list += self.standard_test_cases
for i in range(test_num):
input_values = self.generate_test_case(input_signals, io_map, i,
test_range)
tc_list.append((input_values, None))
def compute_results(tc):
""" update test case with output values if required """
input_values, output_values = tc
if output_values is None:
return input_values, self.numeric_emulate(input_values)
else:
return tc
# filling output values
tc_list = [compute_results(tc) for tc in tc_list]
for input_values, output_values in tc_list:
input_msg = ""
# Adding input setting
for input_tag in input_values:
input_signal = io_map[input_tag]
# FIXME: correct value generation depending on signal precision
input_value = input_values[input_tag]
test_statement.add(
ReferenceAssign(
input_signal,
Constant(input_value,
precision=input_signal.get_precision())))
value_msg = input_signal.get_precision().get_cst(
input_value, language=VHDL_Code).replace('"', "'")
value_msg += " / " + hex(input_signal.get_precision(
).get_base_format().get_integer_coding(input_value))
input_msg += " {}={} ".format(input_tag, value_msg)
test_statement.add(Wait(time_step * self.stage_num))
# Adding output value comparison
for output_tag in output_signals:
output_signal = output_signals[output_tag]
output_value = Constant(
output_values[output_tag],
precision=output_signal.get_precision())
output_precision = output_signal.get_precision()
expected_dec = output_precision.get_cst(
output_values[output_tag],
language=VHDL_Code).replace('"', "'")
expected_hex = " / " + hex(
output_precision.get_base_format().get_integer_coding(
output_values[output_tag]))
value_msg = "{} / {}".format(expected_dec, expected_hex)
test_pass_cond = Comparison(output_signal,
output_value,
specifier=Comparison.Equal,
precision=ML_Bool)
test_statement.add(
ConditionBlock(
LogicalNot(test_pass_cond, precision=ML_Bool),
Report(
Concatenation(
" result for {}: ".format(output_tag),
Conversion(TypeCast(
output_signal,
precision=ML_StdLogicVectorFormat(
output_signal.get_precision(
).get_bit_size())),
precision=ML_String),
precision=ML_String))))
test_statement.add(
Assert(
test_pass_cond,
"\"unexpected value for inputs {input_msg}, output {output_tag}, expecting {value_msg}, got: \""
.format(input_msg=input_msg,
output_tag=output_tag,
value_msg=value_msg),
severity=Assert.Failure))
testbench = CodeEntity("testbench")
test_process = Process(
test_statement,
# end of test
Assert(Constant(0, precision=ML_Bool),
" \"end of test, no error encountered \"",
severity=Assert.Failure))
testbench_scheme = Statement(self_instance, test_process)
if self.pipelined:
half_time_step = time_step / 2
assert (half_time_step * 2) == time_step
# adding clock process for pipelined bench
clk_process = Process(
Statement(
ReferenceAssign(io_map["clk"],
Constant(1, precision=ML_StdLogic)),
Wait(half_time_step),
ReferenceAssign(io_map["clk"],
Constant(0, precision=ML_StdLogic)),
Wait(half_time_step),
))
testbench_scheme.push(clk_process)
testbench.add_process(testbench_scheme)
return [testbench]
def generate_scheme(self):
# declaring target and instantiating optimization engine
vx = self.implementation.add_input_variable("x", self.precision)
vx.set_attributes(precision=self.precision,
tag="vx",
debug=debug_multi)
Log.set_dump_stdout(True)
Log.report(Log.Info,
"\033[33;1m Generating implementation scheme \033[0m")
if self.debug_flag:
Log.report(Log.Info, "\033[31;1m debug has been enabled \033[0;m")
C0 = Constant(0, precision=self.precision)
C0_plus = Constant(FP_PlusZero(self.precision))
C0_minus = Constant(FP_MinusZero(self.precision))
def local_test(specifier, tag):
""" Local wrapper to generate Test operations """
return Test(vx,
specifier=specifier,
likely=False,
debug=debug_multi,
tag="is_%s" % tag,
precision=ML_Bool)
test_NaN = local_test(Test.IsNaN, "is_NaN")
test_inf = local_test(Test.IsInfty, "is_Inf")
test_NaN_or_Inf = local_test(Test.IsInfOrNaN, "is_Inf_Or_Nan")
test_negative = Comparison(vx,
C0,
specifier=Comparison.Less,
debug=debug_multi,
tag="is_Negative",
precision=ML_Bool,
likely=False)
test_NaN_or_Neg = LogicalOr(test_NaN, test_negative, precision=ML_Bool)
test_std = LogicalNot(LogicalOr(test_NaN_or_Inf,
test_negative,
precision=ML_Bool,
likely=False),
precision=ML_Bool,
likely=True)
test_zero = Comparison(vx,
C0,
specifier=Comparison.Equal,
likely=False,
debug=debug_multi,
tag="Is_Zero",
precision=ML_Bool)
return_NaN_or_neg = Statement(Return(FP_QNaN(self.precision)))
return_inf = Statement(Return(FP_PlusInfty(self.precision)))
return_PosZero = Return(C0_plus)
return_NegZero = Return(C0_minus)
NR_init = ReciprocalSquareRootSeed(vx,
precision=self.precision,
tag="sqrt_seed",
debug=debug_multi)
result = compute_sqrt(vx,
NR_init,
int(self.num_iter),
precision=self.precision)
return_non_std = ConditionBlock(
test_NaN_or_Neg, return_NaN_or_neg,
ConditionBlock(
test_inf, return_inf,
ConditionBlock(test_zero, return_PosZero, return_NegZero)))
return_std = Return(result)
scheme = ConditionBlock(test_std, return_std, return_non_std)
return scheme
