From 2d427bb1f14032023b7829f3788b2d4d3a220782 Mon Sep 17 00:00:00 2001 From: Josh Varga Date: Sat, 17 Feb 2024 21:36:08 -0800 Subject: [PATCH] Adding better fuzzing for both XlsInt and XlsFixed. PiperOrigin-RevId: 608060184 --- .../xlscc/build_rules/cc_generator.bzl | 113 ++++---- xls/contrib/xlscc/unit_tests/BUILD | 4 +- .../xlscc/unit_tests/cc_fuzz_tester.cc | 22 +- .../xlscc/unit_tests/cc_generate_test.cc | 12 +- xls/contrib/xlscc/unit_tests/cc_generator.cc | 262 ++++++++++-------- xls/contrib/xlscc/unit_tests/cc_generator.h | 8 +- 6 files changed, 235 insertions(+), 186 deletions(-) diff --git a/xls/contrib/xlscc/build_rules/cc_generator.bzl b/xls/contrib/xlscc/build_rules/cc_generator.bzl index 020a3dd54c..a25c2d92f5 100644 --- a/xls/contrib/xlscc/build_rules/cc_generator.bzl +++ b/xls/contrib/xlscc/build_rules/cc_generator.bzl @@ -27,78 +27,85 @@ def xls_ac_fuzz_binaries(name, deps, seed_start, seed_count, test_ac_fixed, test All of the outputs of the fuzzing process. Including generated source code and binaries. """ - all_outputs = [] + cc_files = [] + test_list = [] for x in range(seed_count): + test_outputs = [] seed = seed_start + x - srcfile = "{}_{}.cc".format(name, str(seed)) + srcfile = "{}_{}.cc".format(name, seed) + cc_files.append(srcfile) cmd = "./$(location cc_generate_test) -seed=" + str(seed) + " --cc_filepath=$(OUTS) \ --test_ac_int=" + str(test_ac_int) + " --test_ac_fixed=" + str(test_ac_fixed) native.genrule( - name = "fuzzfiles_{}_{}".format(name, str(seed)), + name = "fuzzfiles_{}_{}".format(name, seed), outs = [srcfile], cmd = cmd, tools = ["cc_generate_test"], ) native.cc_binary( - name = "{}_{}".format(name, str(seed)), + name = "{}_{}".format(name, seed), srcs = [srcfile], deps = [ "@com_github_hlslibs_ac_types//:ac_int", "@com_github_hlslibs_ac_types//:ac_fixed", ], ) - all_outputs.append("{}_{}".format(name, str(seed))) - all_outputs.append(srcfile) + test_outputs.append("{}_{}".format(name, seed)) + test_outputs.append(srcfile) - native.filegroup( - name = "{}_group".format(name), - data = all_outputs, - ) + native.filegroup( + name = "{}_group_{}".format(name, seed), + data = test_outputs, + ) - all_outputs.extend([ - "//xls/contrib/xlscc:synth_only_headers", - "//xls/contrib/xlscc:xlscc", - "@com_github_hlslibs_ac_types//:ac_types_as_data", - ]) + test_outputs.extend([ + "//xls/contrib/xlscc:synth_only_headers", + "//xls/contrib/xlscc:xlscc", + "@com_github_hlslibs_ac_types//:ac_types_as_data", + ]) - native.cc_test( + native.cc_test( + name = "{}_{}_test".format(name, seed), + testonly = 1, + srcs = ["cc_fuzz_tester.cc"], + data = test_outputs, + args = [ + "--seed={}".format(seed), + "--input_path=xls/contrib/xlscc/unit_tests/{}_".format(name), + ], + deps = [ + ":cc_generator", + ":unit_test", + "@com_google_absl//absl/container:inlined_vector", + "@com_google_absl//absl/flags:flag", + "@com_google_absl//absl/status:statusor", + "@com_google_absl//absl/strings", + "@com_google_absl//absl/strings:str_format", + "//xls/codegen:combinational_generator", + "//xls/codegen:module_signature", + "//xls/common:init_xls", + "//xls/common:subprocess", + "//xls/common/file:filesystem", + "//xls/common/file:get_runfile_path", + "//xls/common/file:temp_directory", + "//xls/common/logging", + "//xls/common/status:matchers", + "//xls/common/status:status_macros", + "//xls/interpreter:ir_interpreter", + "//xls/ir", + "//xls/ir:events", + "//xls/ir:function_builder", + "//xls/ir:ir_test_base", + "//xls/ir:value", + "//xls/passes:optimization_pass_pipeline", + "//xls/simulation:module_simulator", + "//xls/simulation:verilog_simulators", + ] + deps, + ) + test_list.append(":{}_{}_test".format(name, seed)) + native.test_suite( name = name, - testonly = 1, - srcs = ["cc_fuzz_tester.cc"], - data = all_outputs, - args = [ - "--seed={}".format(seed_start), - "--sample_count={}".format(seed_count), - "--input_path=xls/contrib/xlscc/unit_tests/{}_".format(name), - ], - deps = [ - ":cc_generator", - ":unit_test", - "@com_google_absl//absl/container:inlined_vector", - "@com_google_absl//absl/flags:flag", - "@com_google_absl//absl/status:statusor", - "@com_google_absl//absl/strings", - "@com_google_absl//absl/strings:str_format", - "//xls/codegen:combinational_generator", - "//xls/codegen:module_signature", - "//xls/common:init_xls", - "//xls/common:subprocess", - "//xls/common/file:filesystem", - "//xls/common/file:get_runfile_path", - "//xls/common/file:temp_directory", - "//xls/common/logging", - "//xls/common/status:matchers", - "//xls/common/status:status_macros", - "//xls/interpreter:ir_interpreter", - "//xls/ir", - "//xls/ir:events", - "//xls/ir:function_builder", - "//xls/ir:ir_test_base", - "//xls/ir:value", - "//xls/passes:optimization_pass_pipeline", - "//xls/simulation:module_simulator", - "//xls/simulation:verilog_simulators", - ] + deps, + tests = test_list, ) - return [DefaultInfo(files = depset(all_outputs))] + return [DefaultInfo(files = depset(cc_files))] diff --git a/xls/contrib/xlscc/unit_tests/BUILD b/xls/contrib/xlscc/unit_tests/BUILD index a510ae7fdc..b28d6f664c 100644 --- a/xls/contrib/xlscc/unit_tests/BUILD +++ b/xls/contrib/xlscc/unit_tests/BUILD @@ -389,7 +389,7 @@ cc_binary( xls_ac_fuzz_binaries( name = "fuzz_int", - seed_count = 10, + seed_count = 1, seed_start = 10, test_ac_fixed = False, test_ac_int = True, @@ -406,7 +406,7 @@ xls_ac_fuzz_binaries( xls_ac_fuzz_binaries( name = "fuzz_fixed", - seed_count = 10, + seed_count = 1, seed_start = 10, test_ac_fixed = True, test_ac_int = False, diff --git a/xls/contrib/xlscc/unit_tests/cc_fuzz_tester.cc b/xls/contrib/xlscc/unit_tests/cc_fuzz_tester.cc index e5ced0e8e3..04e08336f7 100644 --- a/xls/contrib/xlscc/unit_tests/cc_fuzz_tester.cc +++ b/xls/contrib/xlscc/unit_tests/cc_fuzz_tester.cc @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include #include #include // NOLINT #include @@ -74,7 +75,8 @@ class GeneratedTester : public XlsccTestBase { xls::InvokeSubprocess({std::string(exec_filename)})); std::string stripped_result = - absl::StrReplaceAll(result_value.stdout, {{"0b", ""}}); + absl::StrReplaceAll(result_value.stdout, {{"0b", ""}, {".", ""}}); + std::reverse(stripped_result.begin(), stripped_result.end()); absl::InlinedVector expected_in; expected_in.reserve(stripped_result.size()); for (char& ch : stripped_result) { @@ -83,7 +85,7 @@ class GeneratedTester : public XlsccTestBase { auto expected = xls::Value(xls::Bits(expected_in)); XLS_ASSIGN_OR_RETURN(auto calc_result, RunIntTest(expected, test_content)); if (calc_result != expected) { - std::cout << expected << " " << calc_result << '\n'; + std::cout << "ac: " << expected << " xls: " << calc_result << '\n'; return absl::InternalError("test failed"); } return absl::OkStatus(); @@ -202,7 +204,6 @@ class GeneratedTester : public XlsccTestBase { TEST_F(GeneratedTester, Simple) { xlscc::GeneratedTester tester; int seed = absl::GetFlag(FLAGS_seed); - int sample_count = absl::GetFlag(FLAGS_sample_count); std::string input_path = absl::GetFlag(FLAGS_input_path); std::string crash_path = absl::GetFlag(FLAGS_crash_path); bool run_failed = absl::GetFlag(FLAGS_run_failed); @@ -227,15 +228,14 @@ TEST_F(GeneratedTester, Simple) { } else { crash_path = temp_dir; } - for (int i = seed; i < sample_count; i++) { - XLS_ASSERT_OK_AND_ASSIGN( - std::filesystem::path exec_filename, - xls::GetXlsRunfilePath(input_path + std::to_string(i))); + XLS_ASSERT_OK_AND_ASSIGN( + std::filesystem::path exec_filename, + xls::GetXlsRunfilePath(input_path + std::to_string(seed))); - std::filesystem::path cc_filepath = exec_filename.string() + ".cc"; - absl::Status status = RunExisting(cc_filepath, exec_filename); - XLS_EXPECT_OK(status) << "failed test case: " << std::to_string(i); - } + std::filesystem::path cc_filepath = exec_filename.string() + ".cc"; + absl::Status status = RunExisting(cc_filepath, exec_filename); + XLS_EXPECT_OK(status) + << "failed test case: " << std::to_string(seed) << " " << cc_filepath; } else { absl::StatusOr> files = xls::GetDirectoryEntries(crash_path); diff --git a/xls/contrib/xlscc/unit_tests/cc_generate_test.cc b/xls/contrib/xlscc/unit_tests/cc_generate_test.cc index 862feecb40..d7ec4911d1 100644 --- a/xls/contrib/xlscc/unit_tests/cc_generate_test.cc +++ b/xls/contrib/xlscc/unit_tests/cc_generate_test.cc @@ -38,11 +38,9 @@ ABSL_FLAG(std::string, cc_filepath, "", "output file name"); namespace { -enum class TestType: uint8_t { kAcInt, kAcFixed }; - -static bool GenerateTest(int seed, const std::string& filename, TestType type) { - std::string content = type == TestType::kAcInt ? xlscc::GenerateIntTest(seed) - : xlscc::GenerateFixedTest(seed); +static bool GenerateTest(int seed, const std::string& filename, + xlscc::VariableType type) { + std::string content = xlscc::GenerateTest(seed, type); std::cout << filename << '\n'; absl::Status contents_set = xls::SetFileContents(filename, content); return contents_set.ok(); @@ -63,10 +61,10 @@ int main(int argc, char** argv) { bool success = true; if (absl::GetFlag(FLAGS_test_ac_fixed)) { - success &= GenerateTest(seed, cc_filepath, TestType::kAcFixed); + success &= GenerateTest(seed, cc_filepath, xlscc::VariableType::kAcFixed); } if (absl::GetFlag(FLAGS_test_ac_int)) { - success &= GenerateTest(seed, cc_filepath, TestType::kAcInt); + success &= GenerateTest(seed, cc_filepath, xlscc::VariableType::kAcInt); } return success ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/xls/contrib/xlscc/unit_tests/cc_generator.cc b/xls/contrib/xlscc/unit_tests/cc_generator.cc index 1d05ed5ea4..3a388cb2ff 100644 --- a/xls/contrib/xlscc/unit_tests/cc_generator.cc +++ b/xls/contrib/xlscc/unit_tests/cc_generator.cc @@ -15,10 +15,9 @@ #include "xls/contrib/xlscc/unit_tests/cc_generator.h" #include +#include -#include #include -#include #include #include #include @@ -28,36 +27,93 @@ #include "absl/random/bit_gen_ref.h" #include "absl/random/distributions.h" -#include "absl/types/span.h" #include "xls/common/random_util.h" namespace xlscc { namespace { +class Function { + public: + std::string return_type; + std::string name; + std::vector parameters; + + static Function Generate(absl::BitGenRef bit_gen) { + std::vector functions{ + {"ac_int", "leading_sign", {}}, {"ac_fixed", "bit_complement", {}}, + {"int", "to_int", {}}, {"unsigned int", "to_uint", {}}, + {"long", "to_long", {}}, {"unsigned long", "to_ulong", {}}, + {"long long", "to_int64", {}}, {"unsigned long long", "to_uint64", {}}, + }; + return xls::RandomChoice(functions, bit_gen); + } +}; + +class BuiltInIntegerTypes { + public: + std::string name; + bool is_signed; + char bit_width; +}; + class Variable { public: std::string name; std::string type; std::string value; std::vector templated_parameters; - static Variable GenerateInt(char variable_number, absl::BitGenRef bit_gen) { + + static Variable GenerateInt(const std::string& variable_name, + absl::BitGenRef bit_gen) { + std::vector int_types{ + {"bool", false, 1}, {"char", false, 8}, + {"signed char", true, 8}, {"unsigned char", false, 8}, + {"signed short", true, 16}, {"unsigned short", false, 16}, + {"signed int", true, 32}, {"unsigned int", false, 32}, + {"signed long", true, 64}, {"unsigned long", false, 64}, + {"Slong", true, 64}, {"Ulong", false, 64}, + }; + auto int_metadata = xls::RandomChoice(int_types, bit_gen); + std::string value_str; + if (int_metadata.bit_width < 64) { + int64_t min_value = (1 << int_metadata.bit_width) - 1; + int64_t max_value = 1 << (int_metadata.bit_width - 1); + value_str = std::to_string(absl::Uniform(bit_gen, min_value, max_value)); + } else { + if (int_metadata.is_signed) { + int64_t min_value = std::numeric_limits::min(); + int64_t max_value = std::numeric_limits::max(); + value_str = + std::to_string(absl::Uniform(bit_gen, min_value, max_value)); + } else { + uint64_t min_value = std::numeric_limits::min(); + uint64_t max_value = std::numeric_limits::max(); + value_str = + std::to_string(absl::Uniform(bit_gen, min_value, max_value)); + } + } + return {variable_name, int_metadata.name, value_str, {}}; + } + + static Variable GenerateXlsInt(const std::string& variable_name, + absl::BitGenRef bit_gen) { bool is_signed = absl::Bernoulli(bit_gen, 0.5); int64_t bit_width = absl::Uniform(absl::IntervalClosed, bit_gen, 1, 100); int64_t max_value = std::numeric_limits::max(); - int64_t min_value = std::numeric_limits::min(); + int64_t min_value = is_signed ? std::numeric_limits::min() : 0; if (bit_width + static_cast(is_signed) < 64) { int64_t range = (int64_t{1} << bit_width) + 10; max_value = is_signed ? range / 2 : range; min_value = is_signed ? -range / 2 : 0; } - Variable var = { - std::string(1, 'a' + variable_number), - "ac_int", - std::to_string(absl::Uniform(bit_gen, min_value, max_value)), - {std::to_string(bit_width), is_signed ? "true" : "false"}}; - return var; + return {variable_name, + "ac_int", + std::to_string(absl::Uniform(bit_gen, min_value, max_value)), + {std::to_string(bit_width), is_signed ? "true" : "false"}}; } - static Variable GenerateFixed(char variable_number, absl::BitGenRef bit_gen) { + + static Variable GenerateXlsFixed(const std::string& variable_name, + absl::BitGenRef bit_gen) { std::vector ac_q_mode{ "AC_TRN", "AC_RND", "AC_TRN_ZERO", "AC_RND_ZERO", "AC_RND_INF", "AC_RND_MIN_INF", "AC_RND_CONV", "AC_RND_CONV_ODD"}; @@ -73,13 +129,12 @@ class Variable { absl::Uniform(absl::IntervalClosed, bit_gen, 1, bit_width); int64_t max_value = std::numeric_limits::max(); - int64_t min_value = std::numeric_limits::min(); - if (bit_width + static_cast(is_signed) < 64) { - int64_t range = (int64_t{1} << bit_width) + 10; + int64_t min_value = is_signed ? std::numeric_limits::min() : 0; + if (integer_width + static_cast(is_signed) < 64) { + int64_t range = (int64_t{1} << integer_width); max_value = is_signed ? range / 2 : range; min_value = is_signed ? -range / 2 : 0; } - std::string value; if (is_float) { value = std::to_string( @@ -90,12 +145,25 @@ class Variable { std::to_string(absl::Uniform(bit_gen, min_value, max_value)); } - Variable var = { - std::string(1, 'a' + variable_number), "ac_fixed", value, + return { + variable_name, + "ac_fixed", + value, {std::to_string(bit_width), std::to_string(integer_width), is_signed ? "true" : "false", quantization, overflow}, }; - return var; + } + + static Variable GenerateVariable(const std::string& variable_name, + absl::BitGenRef bit_gen, VariableType type) { + switch (type) { + case VariableType::kAcInt: + return GenerateXlsInt(variable_name, bit_gen); + case VariableType::kAcFixed: + return GenerateXlsFixed(variable_name, bit_gen); + default: + return GenerateInt(variable_name, bit_gen); + } } std::string Type() { @@ -118,115 +186,87 @@ class Variable { }; } // namespace -std::string GenerateIntTest(uint32_t seed) { - char max_variables_count = 10; - - std::mt19937_64 bit_gen(seed); - std::vector operations = {"+", "-", "*", "/", "|", "&", "^"}; - std::vector variables; - - char variables_count = - absl::Uniform(bit_gen, char{2}, max_variables_count + char{2}); - - Variable var = Variable::GenerateInt(0, bit_gen); - variables.reserve(variables_count); - for (char i = 0; i < variables_count; i++) { - variables.push_back(Variable::GenerateInt(i + 1, bit_gen)); - } - std::stringstream content; - content << "#ifndef __SYNTHESIS__\n"; - content << "#include \n"; - content << "#endif\n"; - - content << "#include \"ac_int.h\"\n"; - content << "#pragma hls_top\n"; - content << var.Type() << " FuzzTestInt" << seed << "() {\n"; +void GenerateFixedBinaryOp(std::stringstream& content, Variable& v1, + Variable& v2, std::mt19937_64& bit_gen) { + std::vector binary_ops = {"+", "-", "*", "/", "|", "&", "^"}; + std::vector binary_ops_with_ac_int = {"+", "-", "*", "/", "|", + "&", "^", "<<", ">>"}; + std::string operation1 = xls::RandomChoice( + v2.type == "ac_int" ? binary_ops_with_ac_int : binary_ops, bit_gen); + content << "result = " << v1.name << " " << operation1 << " " << v2.name + << ";\n"; +} - for (auto variable : variables) { - content << variable.Declaration() << " = " << variable.value << ";\n"; - } +void GenerateFixedBinaryAssignOp(std::stringstream& content, Variable& v1, + Variable& v2, std::mt19937_64& bit_gen) { + std::vector assign_ops = { + "+=", "-=", "*=", "/=", "|=", "&=", "^="}; + std::vector assign_ops_with_ac_int = { + "+=", "-=", "*=", "/=", "|=", "&=", "^=", "<<=", ">>="}; + std::string operation1 = xls::RandomChoice( + v2.type == "ac_int" ? assign_ops_with_ac_int : assign_ops, bit_gen); + content << v1.name << " " << operation1 << " " << v2.name << ";\n"; + content << "result = " << v1.name << ";\n"; +} - for (int i = 0; i < variables.size(); i++) { - std::string operation1 = xls::RandomChoice(operations, bit_gen); - Variable var1 = xls::RandomChoice(variables, bit_gen); - Variable var2 = xls::RandomChoice(variables, bit_gen); - content << "auto var" << i << " = " << var1.name << " " << operation1 << " " - << var2.name << ";\n"; - std::string operation2 = xls::RandomChoice(operations, bit_gen); - Variable var3 = variables[i]; - Variable var4 = xls::RandomChoice(variables, bit_gen); - content << var3.name << " = var" << i << " " << operation2 << " " - << var4.name << ";\n"; +void GenerateUnaryOp(std::stringstream& content, Variable& output, Variable& v1, + std::mt19937_64& bit_gen) { + std::vector postfix_unary_operations = {"++", "--"}; + std::vector prefix_unary_operations = {"!", "+", "-", + "~", "++", "--"}; + bool use_prefix = absl::Uniform(bit_gen, 0, 2) == 0; + if (use_prefix) { + std::string op = xls::RandomChoice(prefix_unary_operations, bit_gen); + content << output.name << " = " << op << v1.name << ";\n"; + } else { + std::string op = xls::RandomChoice(postfix_unary_operations, bit_gen); + content << v1.name << op << ";\n"; + content << output.name << " = " << v1.name << ";\n"; } - content << var.Declaration() << " = "; - Variable var3 = variables.back(); - std::string operation = xls::RandomChoice(operations, bit_gen); - content << var3.name << " " << operation << " "; - Variable final_var = xls::RandomChoice( - absl::MakeConstSpan(variables).first(variables.size() - 1), bit_gen); - content << final_var.name; - - content << ";\n"; - content << "#ifndef __SYNTHESIS__\n"; - content << "std::cout << " << var.name - << ".to_string(AC_BIN, false, true);\n"; - content << "#endif\n"; - content << "return " << var.name << ";\n"; - content << "}\n"; - - content << "int main() { FuzzTestInt" << seed << "(); return 0; }\n"; - return content.str(); +} +void GenerateComparisonOp(std::stringstream& content, Variable& v1, + Variable& v2, std::mt19937_64& bit_gen) { + std::vector operations = {">", "<", ">=", "<=", "==", "!="}; + std::string op = xls::RandomChoice(operations, bit_gen); + content << "result = (" << v1.name << " " << op << " " << v2.name + << ") ? 1 : 0;\n"; } -std::string GenerateFixedTest(uint32_t seed) { - char max_variables_count = 10; - +std::string GenerateTest(uint32_t seed, VariableType type) { std::mt19937_64 bit_gen(seed); - std::vector operations = {"+", "-", "*", "/", "|", "&", "^"}; - std::vector variables; - - char variables_count = - absl::Uniform(bit_gen, char{2}, max_variables_count + char{2}); - Variable var = Variable::GenerateFixed(0, bit_gen); - variables.reserve(variables_count); - for (char i = 0; i < variables_count; i++) { - variables.push_back(Variable::GenerateFixed(i + 1, bit_gen)); - } + Variable var = Variable::GenerateVariable("result", bit_gen, type); std::stringstream content; content << "#ifndef __SYNTHESIS__\n"; content << "#include \n"; content << "#endif\n"; + content << "#include \"ac_int.h\"\n"; content << "#include \"ac_fixed.h\"\n"; content << "#pragma hls_top\n"; content << var.Type() << " FuzzTestFixed" << seed << "() {\n"; - - for (auto variable : variables) { - content << variable.Declaration() << " = " << variable.value << ";\n"; + content << var.Declaration() << " = " << var.value << ";\n"; + char op_type = absl::Uniform(bit_gen, 0, 5); + Variable input = Variable::GenerateVariable("input", bit_gen, type); + content << input.Declaration() << " = " << input.value << ";\n"; + if (op_type == 0) { + Variable v2 = Variable::GenerateVariable("v2", bit_gen, type); + content << v2.Declaration() << " = " << v2.value << ";\n"; + GenerateFixedBinaryOp(content, input, v2, bit_gen); + } else if (op_type == 1) { + Variable v2 = Variable::GenerateVariable("v2", bit_gen, type); + content << v2.Declaration() << " = " << v2.value << ";\n"; + GenerateFixedBinaryAssignOp(content, v2, input, bit_gen); + } else if (op_type == 2) { + GenerateUnaryOp(content, var, input, bit_gen); + } else if (op_type == 3) { + GenerateComparisonOp(content, var, input, bit_gen); + } else { + Function selected = Function::Generate(bit_gen); + content << var.name << " = " << var.Type() << "(" << input.name << "." + << selected.name << "()" << ");\n"; } - for (int i = 0; i < variables.size(); i++) { - std::string operation1 = xls::RandomChoice(operations, bit_gen); - Variable var1 = xls::RandomChoice(variables, bit_gen); - Variable var2 = xls::RandomChoice(variables, bit_gen); - content << "auto var" << i << " = " << var1.name << " " << operation1 << " " - << var2.name << ";\n"; - std::string operation2 = xls::RandomChoice(operations, bit_gen); - Variable var3 = variables[i]; - Variable var4 = xls::RandomChoice(variables, bit_gen); - content << var3.name << " = var" << i << " " << operation2 << " " - << var4.name << ";\n"; - } - content << var.Declaration() << " = "; - Variable var3 = variables.back(); - std::string operation = xls::RandomChoice(operations, bit_gen); - content << var3.name << " " << operation << " "; - Variable final_var = xls::RandomChoice( - absl::MakeConstSpan(variables).first(variables.size() - 1), bit_gen); - content << final_var.name; - - content << ";\n"; content << "#ifndef __SYNTHESIS__\n"; content << "std::cout << " << var.name << ".to_string(AC_BIN, false, true);\n"; diff --git a/xls/contrib/xlscc/unit_tests/cc_generator.h b/xls/contrib/xlscc/unit_tests/cc_generator.h index 4b4f324f39..ca6da4f50e 100644 --- a/xls/contrib/xlscc/unit_tests/cc_generator.h +++ b/xls/contrib/xlscc/unit_tests/cc_generator.h @@ -19,9 +19,13 @@ #include namespace xlscc { + enum class VariableType : std::uint8_t { + kAcInt, + kAcFixed, + kInt + }; - std::string GenerateIntTest(uint32_t seed); - std::string GenerateFixedTest(uint32_t seed); + std::string GenerateTest(uint32_t seed, VariableType type); } // namespace xlscc