def generate_sample(rng: Random,
ast_options: ast_generator.AstGeneratorOptions,
calls_per_sample: int,
default_options: sample.SampleOptions) -> sample.Sample:
"""Generates and returns a random Sample with the given options."""
ast_gen = ast_generator.AstGenerator(
rng, ast_options, codegen_ops_only=default_options.codegen)
f, m = ast_gen.generate_function_in_module(fname='main', mname='test')
dslx_text = m.format()
# Re-parse so we can get real positions in error messages.
m, node_to_type = parse_and_typecheck.parse_text_fakefs(
dslx_text,
m.name,
print_on_error=True,
f_import=None,
filename='/fake/test.x')
f = m.get_function('main')
arg_types = tuple(node_to_type[p.type_] for p in f.params)
args_batch = tuple(
generate_arguments(arg_types, rng) for _ in range(calls_per_sample))
# The generated sample is DSLX so input_is_dslx must be true.
options = default_options._replace(input_is_dslx=True)
if options.codegen and not options.codegen_args:
# Generate codegen args if codegen is given but no codegen args specified.
options = options._replace(codegen_args=generate_codegen_args(
options.use_system_verilog, rng))
return sample.Sample(dslx_text, options, args_batch)
def _test_repeatable(self, seed: int) -> None:
def generate_one(g):
_, m = g.generate_function_in_module('main', 'test')
text = str(m)
return text
count_to_generate = 128
g = ast_generator.AstGenerator(random.Random(seed),
ast_generator.AstGeneratorOptions())
fs = [generate_one(g) for _ in range(count_to_generate)]
g.reset(seed=seed)
gs = [generate_one(g) for _ in range(count_to_generate)]
self.assertEqual(fs, gs)
# Create a fresh generator as well.
g = ast_generator.AstGenerator(random.Random(seed),
ast_generator.AstGeneratorOptions())
hs = [generate_one(g) for _ in range(count_to_generate)]
self.assertEqual(gs, hs)
def test_generates_valid_functions(self):
g = ast_generator.AstGenerator(
random.Random(0), ast_generator.AstGeneratorOptions())
for i in range(32):
print('Generating sample', i)
_, m = g.generate_function_in_module('main', 'test')
text = str(m)
filename = '/fake/test_sample.x'
with fakefs_test_util.scoped_fakefs(filename, text):
try:
module = parser_helpers.parse_text(
text, name='test_sample', print_on_error=True, filename=filename)
typecheck.check_module(module, f_import=None)
except PositionalError as e:
parser_helpers.pprint_positional_error(e)
raise
def test_types(self):
g = ast_generator.AstGenerator(random.Random(0),
ast_generator.AstGeneratorOptions())
_, m = g.generate_function_in_module('main', 'test')
u1 = g._make_type_annotation(signed=False, width=1)
self.assertEqual(g._get_type_bit_count(u1), 1)
self.assertTrue(g._is_bit_vector(u1))
self.assertTrue(g._is_unsigned_bit_vector(u1))
self.assertFalse(g._is_array(u1))
self.assertFalse(g._is_tuple(u1))
s1 = g._make_type_annotation(signed=True, width=1)
self.assertTrue(g._is_bit_vector(s1))
self.assertFalse(g._is_unsigned_bit_vector(s1))
self.assertEqual(g._get_type_bit_count(s1), 1)
self.assertFalse(g._is_array(s1))
self.assertFalse(g._is_tuple(s1))
u42 = g._make_type_annotation(signed=False, width=42)
self.assertEqual(g._get_type_bit_count(u42), 42)
self.assertTrue(g._is_bit_vector(u42))
self.assertTrue(g._is_unsigned_bit_vector(u42))
self.assertFalse(g._is_array(u42))
self.assertFalse(g._is_tuple(u42))
empty_tuple = g._make_tuple_type(())
self.assertEqual(g._get_type_bit_count(empty_tuple), 0)
self.assertFalse(g._is_bit_vector(empty_tuple))
self.assertFalse(g._is_unsigned_bit_vector(empty_tuple))
self.assertFalse(g._is_array(empty_tuple))
self.assertTrue(g._is_tuple(empty_tuple))
tple = g._make_tuple_type((empty_tuple, s1, u1, u42, u42))
self.assertEqual(g._get_type_bit_count(tple), 86)
self.assertFalse(g._is_bit_vector(tple))
self.assertFalse(g._is_unsigned_bit_vector(tple))
self.assertFalse(g._is_array(tple))
self.assertTrue(g._is_tuple(tple))
nested_tuple = g._make_tuple_type((tple, u42, tple))
self.assertEqual(g._get_type_bit_count(nested_tuple), 214)
self.assertFalse(g._is_bit_vector(nested_tuple))
self.assertFalse(g._is_unsigned_bit_vector(nested_tuple))
self.assertFalse(g._is_array(nested_tuple))
self.assertTrue(g._is_tuple(nested_tuple))
array_of_u42 = g._make_array_type(u42, 100)
self.assertEqual(g._get_type_bit_count(array_of_u42), 4200)
self.assertFalse(g._is_bit_vector(array_of_u42))
self.assertFalse(g._is_unsigned_bit_vector(array_of_u42))
self.assertEqual(g._get_array_size(array_of_u42), 100)
self.assertTrue(g._is_array(array_of_u42))
self.assertFalse(g._is_tuple(array_of_u42))
array_of_tuple = g._make_array_type(nested_tuple, 10)
self.assertEqual(g._get_type_bit_count(array_of_tuple), 2140)
self.assertFalse(g._is_bit_vector(array_of_tuple))
self.assertFalse(g._is_unsigned_bit_vector(array_of_tuple))
self.assertEqual(g._get_array_size(array_of_tuple), 10)
self.assertTrue(g._is_array(array_of_tuple))
self.assertFalse(g._is_tuple(array_of_tuple))
u11_token = scanner.Token(g.fake_span,
scanner.KeywordFromString('u11'))
u11 = ast_helpers.make_builtin_type_annotation(m,
g.fake_span,
u11_token,
dims=())
self.assertEqual(g._get_type_bit_count(u11), 11)
self.assertTrue(g._is_bit_vector(u11))
self.assertTrue(g._is_unsigned_bit_vector(u11))
self.assertFalse(g._is_array(u11))
self.assertFalse(g._is_tuple(u11))
un_token = scanner.Token(g.fake_span, scanner.KeywordFromString('uN'))
un1234 = ast_helpers.make_builtin_type_annotation(m,
g.fake_span,
un_token,
dims=(g._make_number(
1234, None), ))
self.assertEqual(g._get_type_bit_count(un1234), 1234)
self.assertTrue(g._is_bit_vector(un1234))
self.assertTrue(g._is_unsigned_bit_vector(un1234))
self.assertFalse(g._is_array(un1234))
self.assertFalse(g._is_tuple(un1234))
sn_token = scanner.Token(g.fake_span, scanner.KeywordFromString('sN'))
sn1234 = ast_helpers.make_builtin_type_annotation(m,
g.fake_span,
sn_token,
dims=(g._make_number(
1234, None), ))
self.assertEqual(g._get_type_bit_count(sn1234), 1234)
self.assertTrue(g._is_bit_vector(sn1234))
self.assertFalse(g._is_unsigned_bit_vector(sn1234))
self.assertFalse(g._is_array(sn1234))
self.assertFalse(g._is_tuple(sn1234))
bits_token = scanner.Token(g.fake_span,
scanner.KeywordFromString('bits'))
bits1234 = ast_helpers.make_builtin_type_annotation(
m, g.fake_span, bits_token, dims=(g._make_number(1234, None), ))
self.assertEqual(g._get_type_bit_count(bits1234), 1234)
self.assertTrue(g._is_bit_vector(bits1234))
self.assertTrue(g._is_unsigned_bit_vector(bits1234))
self.assertFalse(g._is_array(bits1234))
self.assertFalse(g._is_tuple(bits1234))
un1234_10 = ast_helpers.make_builtin_type_annotation(
m,
g.fake_span,
un_token,
dims=(g._make_number(1234, None), g._make_number(10, None)))
self.assertEqual(g._get_type_bit_count(un1234_10), 12340)
self.assertFalse(g._is_bit_vector(un1234_10))
self.assertFalse(g._is_unsigned_bit_vector(un1234_10))
self.assertTrue(g._is_array(un1234_10))
self.assertFalse(g._is_tuple(un1234_10))
