def test_empty_global(temp):
@sv()
def foo():
pass
foo.func_def.imports = {}
compile_lib([foo], cwd=temp)
def test_no_call_sv_compile(temp):
from pysv.codegen import generate_cxx_binding, generate_sv_binding
@sv
def foo():
pass
compile_lib([foo], cwd=temp)
generate_cxx_binding([foo], filename=os.path.join(temp, "test.hh"))
generate_sv_binding([foo], filename=os.path.join(temp, "test.svh"))
def test_sv_object_funcs(get_vector_filename, simulator, temp):
avail, tester_cls = simulator_map[simulator]
if not avail():
pytest.skip(simulator + " is not available")
class ClassA:
@sv()
def __init__(self):
self.num = 21
class ClassB:
# object is allowed if you want duct typing
@sv(a=DataType.Object)
def __init__(self, a):
self.a = a
@sv(return_type=ClassA)
def create_a(self, num):
a = ClassA()
a.num = num
return a
@sv(a=ClassA)
def add(self, a):
return self.a.num + a.num
lib_path = compile_lib([ClassA, ClassB], cwd=temp)
sv_pkg = os.path.join(os.path.abspath(temp), "pysv_pkg.sv")
generate_sv_binding([ClassA, ClassB], filename=sv_pkg)
tb_file = get_vector_filename("test_sv_object_funcs.sv")
tester = tester_cls(lib_path, sv_pkg, tb_file, cwd=temp)
tester.run()
def test_model_constructor(temp):
c_code = """
void *ptr = {0}(42, 1);
std::cout << ptr;
""".format(TestModel.__init__.func_name)
lib_path = compile_lib([TestModel], cwd=temp)
compile_and_run(lib_path, c_code, temp, [TestModel])
def test_compile(temp):
@sv()
def add(a, b):
return a + b
lib_file = compile_lib([add], cwd=temp)
assert os.path.exists(lib_file)
def test_cxx_object_funcs_1(temp):
class ClassA:
@sv()
def __init__(self):
self.num = 21
class ClassB:
@sv(a=DataType.Object)
def __init__(self, a):
self.a = a
@sv(return_type=ClassA)
def create_a(self, num):
a = ClassA()
a.num = num
return a
@sv(a=ClassA)
def add(self, a):
return self.a.num + a.num
lib_file = compile_lib([ClassA, ClassB], cwd=temp)
cxx_code = """
using namespace pysv;
ClassA a1;
ClassB b(&a1);
ClassA a2 = b.create_a(-42);
std::cout << b.add(&a1) << std::endl;
std::cout << b.add(&a2);
pysv_finalize();
"""
values = compile_and_run(lib_file, cxx_code, temp, [ClassA, ClassB], use_implementation=True).split("\n")
assert int(values[0]) == 42
assert int(values[1]) == (21 - 42)
def test_model_function_call(temp):
c_code = """
void *ptr = {0}(42, 1);
auto r = {1}(ptr, 1);
std::cout << r;
""".format(TestModel.__init__.func_name, TestModel.foo.func_name)
calls = [TestModel]
lib_path = compile_lib(calls, cwd=temp)
output = compile_and_run(lib_path, c_code, temp, calls)
assert int(output) == 42
def test_function_import(temp):
from random import randint
@sv()
def rand_():
print(randint(0, 42))
lib_file = compile_lib([rand_], cwd=temp)
call_str = rand_.make_call().str() + ";\n"
value = compile_and_run(lib_file, call_str, temp, [rand_])
value = int(value)
# randint is [a, b]
assert value in range(0, 42 + 1)
def test_sv_simulator(get_vector_filename, simulator, temp):
avail, tester_cls = simulator_map[simulator]
if not avail():
pytest.skip("{0} not available".format(simulator))
lib_path = compile_lib([BoxFilter], cwd=temp)
sv_pkg = os.path.join(os.path.abspath(temp), "pysv_pkg.sv")
generate_sv_binding([BoxFilter], filename=sv_pkg)
sv_file = get_vector_filename("box_filter.sv")
tb_file = get_vector_filename("test_sv_boxfilter.sv")
tester = tester_cls(lib_path, sv_pkg, sv_file, tb_file, cwd=temp)
tester.run()
def test_function_output_ref1(temp):
@sv(return_type=Reference(a=DataType.Int))
def func_output():
return 42
lib_file = compile_lib([func_output], cwd=temp)
cxx_code = """
using namespace pysv;
int a;
func_output(&a);
printf("%d", a);
pysv_finalize();
"""
value = compile_and_run(lib_file, cxx_code, temp, [func_output], use_implementation=True)
value = int(value)
assert value == 42
def test_verilator(get_vector_filename, temp):
lib_path = compile_lib([BoxFilter], cwd=temp)
header_file = os.path.join(os.path.abspath(temp), "box_filter.hh")
generate_cxx_binding([BoxFilter], filename=header_file)
# we have three files
# the sv file, the driver file, and the header
sv_file = get_vector_filename("box_filter.sv")
driver = get_vector_filename("test_verilator_boxfilter.cc")
# just run teh verilator
tester = pysv.util.VerilatorTester(lib_path,
sv_file,
header_file,
driver,
cwd=temp)
tester.run()
def test_function_output_ref2(temp):
@sv(return_type=Reference(a=DataType.Int, b=DataType.Int))
def func_output():
return 42, 43
lib_file = compile_lib([func_output], cwd=temp)
cxx_code = """
using namespace pysv;
int a, b;
func_output(&a, &b);
printf("%d\\n%d", a, b);
pysv_finalize();
"""
value = compile_and_run(lib_file, cxx_code, temp, [func_output], use_implementation=True)
values = [int(v) for v in value.split()]
assert values[0] == 42 and values[1] == 43;
def test_numpy(temp):
import numpy as np
@sv()
def min_(a, b):
return np.min([a, b])
lib_file = compile_lib([min_], cwd=temp)
call_str = min_.make_call(-1, -2).str()
code = """
auto r = {0};
std::cout << r << std::endl;
""".format(call_str)
outputs = compile_and_run(lib_file, code, temp, [min_])
assert int(outputs) == -2
def test_sv_return_reference(get_vector_filename, temp):
# test out return reference
simulator = "xcelium"
avail, tester_cls = simulator_map[simulator]
if not avail():
pytest.skip(simulator + " is not available")
@sv(return_type=Reference(a=DataType.Int, b=DataType.Int))
def set_value():
return 42, 43
lib_path = compile_lib([set_value], cwd=temp)
sv_pkg = os.path.join(os.path.abspath(temp), "pysv_pkg.sv")
generate_sv_binding([set_value], filename=sv_pkg)
tb_file = get_vector_filename("test_sv_return_reference.sv")
tester = tester_cls(lib_path, sv_pkg, tb_file, cwd=temp)
tester.run()
def test_type_import(temp):
from random import Random
@sv()
def foo():
rand = Random()
rand.seed(0)
val = rand.randint(0, 42)
print(val)
lib_file = compile_lib([foo], cwd=temp)
call_str = foo.make_call().str() + ";\n"
value = compile_and_run(lib_file, call_str, temp, [foo])
value = int(value)
rand = Random()
rand.seed(0)
expected = rand.randint(0, 42)
assert value == expected
def test_cxx_object_funcs_2(temp):
class ClassA2:
@sv()
def __init__(self):
self.num = 42
@sv(a=ClassA2)
def foo(a):
print(a.num)
lib_file = compile_lib([ClassA2, foo], cwd=temp)
cxx_code = """
using namespace pysv;
ClassA2 a;
foo(&a);
pysv_finalize();
"""
value = compile_and_run(lib_file, cxx_code, temp, [ClassA2, foo], use_implementation=True)
value = int(value)
assert value == 42
def test_subclass_abc(temp):
from abc import ABC, abstractmethod
class ClassBase(ABC):
@abstractmethod
def foo(self):
pass
class ClassChild(ClassBase):
@sv()
def __init__(self):
pass
@sv()
def foo(self):
pass
c_code = ""
lib_path = compile_lib([ClassChild], cwd=temp)
compile_and_run(lib_path, c_code, temp, [ClassChild])
def test_str(temp):
@sv(s=DataType.String, return_type=DataType.String)
def mul_str(num, s):
return num * s
lib_file = compile_lib([mul_str], cwd=temp)
code = """
const char *str = "test ";
int32_t repeat = 4;
auto r1 = mul_str(repeat, str);
std::cout << r1 << std::endl;
// another call
auto r2 = mul_str(repeat + 1, str);
std::cout << r2;
"""
outputs = compile_and_run(lib_file, code, temp, [mul_str])
outputs = outputs.splitlines()
assert outputs[0] == "test " * 4
assert outputs[1] == "test " * (4 + 1)
def test_verilator_return_reference(get_vector_filename, temp):
@sv(return_type=Reference(a=DataType.UInt, b=DataType.UInt))
def set_value():
return 42, 43
lib_path = compile_lib([set_value], cwd=temp)
header_file = os.path.join(os.path.abspath(temp),
"test_verilator_return_ref.hh")
generate_cxx_binding([set_value], filename=header_file)
# we have three files
# the sv file, the driver file, and the header
sv_file = get_vector_filename("test_verilator_return_ref.sv")
driver = get_vector_filename("test_verilator_return_ref.cc")
# just run teh verilator
tester = pysv.util.VerilatorTester(lib_path,
sv_file,
header_file,
driver,
cwd=temp)
tester.run()
def test_sv_object_funcs_2(get_vector_filename, temp):
# test out a normal function takes in Python object
simulator = "xcelium"
avail, tester_cls = simulator_map[simulator]
if not avail():
pytest.skip(simulator + " is not available")
class ClassA2:
@sv()
def __init__(self):
self.num = 1
@sv(a=ClassA2)
def add(a):
return a.num + 41
lib_path = compile_lib([ClassA2, add], cwd=temp)
sv_pkg = os.path.join(os.path.abspath(temp), "pysv_pkg.sv")
generate_sv_binding([ClassA2, add], filename=sv_pkg)
tb_file = get_vector_filename("test_sv_object_funcs_2.sv")
tester = tester_cls(lib_path, sv_pkg, tb_file, cwd=temp)
tester.run()
def test_tensorflow(get_vector_filename, temp):
# should work with any simulator, but it seems like the Xcelium we have doesn't ship
# with the latest libstdc++. Use vcs instead
avail, tester_cls = simulator_map["vcs"]
if not avail():
pytest.skip("VCS not available")
import tensorflow as tf
@sv()
def simple_mat_mal(a, b):
c = tf.constant([[a, a], [a, a]])
d = tf.constant([[b, b], [b, b]])
e = tf.matmul(c, d)
n = e.numpy()
s = np.sum(n)
return s
lib_path = compile_lib([simple_mat_mal], cwd=temp)
sv_pkg = os.path.join(os.path.abspath(temp), "pysv_pkg.sv")
generate_sv_binding([simple_mat_mal], filename=sv_pkg)
tb_file = get_vector_filename("test_tensorflow.sv")
tester = tester_cls(lib_path, sv_pkg, tb_file, cwd=temp)
tester.run()
