def test_elif(): def kernel(A): with hcl.if_(A[0] > 5): A[0] = 5 with hcl.elif_(A[0] > 3): A[0] = 3 A = hcl.placeholder((1, )) s = hcl.create_schedule(A, kernel) f = hcl.build(s) np_A = np.random.randint(10, size=(1, )) golden_A = [5 if np_A[0] > 5 else (3 if np_A[0] > 3 else np_A[0])] hcl_A = hcl.asarray(np_A) f(hcl_A) ret_A = hcl_A.asnumpy()
def test_reuse_before_streaming(): hcl.init() A = hcl.placeholder((10, 10), name="A") def kernel(A): B = hcl.compute((10, 8), lambda y, x: A[y, x] + A[y, x + 1] + A[y, x + 2], name="B") C = hcl.compute((10, 8), lambda y, x: B[y, x], name="C") return C s = hcl.create_schedule([A], kernel) kernel_B = kernel.B RB = s.reuse_at(A, s[kernel_B], kernel_B.axis[1]) target = hcl.platform.zc706 target.config(compile="vivado_hls", mode="csim") s.to(kernel.B, target.xcel) s.to(kernel.C, target.host) f = hcl.build(s, target)
def top(target=None): points = hcl.placeholder((N, dim)) means = hcl.placeholder((K, dim)) def kmeans(points, means): def loop_kernel(labels): # assign cluster with hcl.for_(0, N, name="N") as n: min_dist = hcl.local(100000) with hcl.for_(0, K) as k: dist = hcl.local(0) with hcl.for_(0, dim) as d: dist_ = points[n, d] - means[k, d] dist[0] += dist_ * dist_ with hcl.if_(dist[0] < min_dist[0]): min_dist[0] = dist[0] labels[n] = k # update mean num_k = hcl.compute((K, ), lambda x: 0) sum_k = hcl.compute((K, dim), lambda x, y: 0) def calc_sum(n): num_k[labels[n]] += 1 with hcl.for_(0, dim) as d: sum_k[labels[n], d] += points[n, d] hcl.mutate((N, ), lambda n: calc_sum(n), "calc_sum") hcl.update(means, lambda k, d: sum_k[k, d] // num_k[k], "update_mean") labels = hcl.compute((N, ), lambda x: 0) hcl.mutate((niter, ), lambda _: loop_kernel(labels), "main_loop") return labels # create schedule and apply compute customization s = hcl.create_schedule([points, means], kmeans) main_loop = kmeans.main_loop update_mean = main_loop.update_mean s[main_loop].pipeline(main_loop.N) s[main_loop.calc_sum].unroll(main_loop.calc_sum.axis[0]) fused = s[update_mean].fuse(update_mean.axis[0], update_mean.axis[1]) s[update_mean].unroll(fused) return hcl.build(s, target=target)
def test_mixed_stream(): A = hcl.placeholder((10, 32), "A") B = hcl.placeholder((10, 32), "B") def kernel(A, B): C = hcl.compute(A.shape, lambda i, j: A[i][j] + B[i][j], "C") D = hcl.compute(C.shape, lambda i, j: C[i][j], "D") return D target = hcl.Platform.aws_f1 s = hcl.create_schedule([A, B], kernel) s.to([A, B], target.xcel) s.to(kernel.D, target.host) s.to(kernel.C, s[kernel.D]) code = str(hcl.lower(s)) assert "test(A, B, D)" in code assert "allocate C.pipe.1[int32 * 10 * 32]" in code
def test_schedule_return(): A = hcl.placeholder((10, )) def algorithm(A): return hcl.compute(A.shape, lambda x: A[x] + 1) s = hcl.create_schedule([A], algorithm) f = hcl.build(s) _A = hcl.asarray(np.random.randint(100, size=(10, )), dtype=hcl.Int(32)) _B = hcl.asarray(np.zeros(10), dtype=hcl.Int(32)) f(_A, _B) _A = _A.asnumpy() _B = _B.asnumpy() for i in range(10): assert (_B[i] == _A[i] + 1)
def test_simple(): hcl.init() A = hcl.placeholder((10, 10), name="A") def kernel(A): B = hcl.compute((10, 8), lambda y, x: A[y, x] + A[y, x + 1] + A[y, x + 2], name="B") return B s = hcl.create_schedule([A], kernel) target = hcl.platform.zc706 target.config(compile="vivado_hls", mode="debug") s.to(A, target.xcel, local_buffer=False) s.to(kernel.B, target.host, local_buffer=False) code = str((hcl.build(s, target))) assert ("test(A, B)" in code) or ("test(B, A)" in code)
def test_merge_kernel_stages(): hcl.init() A = hcl.placeholder((10, 32), "A") B = hcl.placeholder((10, 32), "B") def kernel(A, B): C = hcl.compute(A.shape, lambda i, j: 0, "C") hcl.update(C, lambda i, j: A[i, j] + 1, "s1") hcl.update(C, lambda i, j: B[i, j] * 2, "s2") return hcl.compute(C.shape, lambda *args: C[args] + 3, "ret") target = hcl.Platform.aws_f1 s = hcl.create_schedule([A, B], kernel) s.to([A, B], target.xcel) s.to(kernel.ret, target.host) tops = s.subgraph()[0] dev_body = str(tops.op.body) assert "device_scope = \"fpga\"" in dev_body
def test_comm_intf(): hcl.init() A = hcl.placeholder((10, 32), "A") B = hcl.placeholder((10, 32), "B") def kernel(A, B): C = hcl.compute(A.shape, lambda i, j: A[i, j] + B[i, j], "C") D = hcl.compute(C.shape, lambda i, j: C[i, j] + 1, "D") return D target = hcl.platform.aws_f1 target.config(compile="vitis", mode="debug") s = hcl.create_schedule([A, B], kernel) s.to(A, target.xcel, stream_type=hcl.Stream.FIFO) s.to(B, target.xcel, stream_type=hcl.Stream.Copy) s.to(kernel.D, target.host, stream_type=hcl.Stream.FIFO) code = hcl.build(s, target) assert "hls::stream<pkt_b32> &A" in code assert "hls::stream<pkt_b32> &D" in code
def test_move_inputs(): hcl.init() A = hcl.placeholder((10, 32), "A") B = hcl.placeholder((10, 32), "B") C = hcl.placeholder((10, 32), "C") D = hcl.compute(A.shape, lambda i, j: A[i][j] + B[i][j], "D") E = hcl.compute(C.shape, lambda i, j: C[i][j] * D[i][j], "E") F = hcl.compute(C.shape, lambda i, j: E[i][j] + 1, "F") target = hcl.platform.aws_f1 s = hcl.create_schedule([A, B, C, D, E, F]) s.to([A, B, C], target.xcel) s.to(E, target.host) code = str(hcl.lower(s)) pattern = "test({}.channel, {}.channel, {}.channel, E.channel)" combination = [ pattern.format(*_) for _ in list(permutations(["A", "B", "C"])) ] assert any([_ in code for _ in combination])
def test_toy_nn(): dtype = hcl.Float(32) hcl.init(dtype) input_1 = hcl.placeholder((16, ), dtype=dtype, name="input_1") output_1 = hcl.placeholder((5, ), dtype=dtype, name="output_1") def math_func(input_1, output_1): toynn_vhls_ip(input_1, output_1) target = hcl.Platform.aws_f1 s = hcl.create_schedule([input_1, output_1], math_func) s.to(input_1, target.xcel) s.to(output_1, target.host) target.config(compiler="vitis", mode="debug") code = hcl.build(s, target) assert "nnet::softmax" in code, code os.system("rm -rf firmware toynn.tar.gz")
def test_extern_op_multicast(): A = hcl.placeholder((10, 32), "A") B = hcl.placeholder((10, 32), "B") def kernel(A, B): C = hcl.compute(A.shape, lambda i, j: A[i][j] + B[i][j], "C") D = hcl.compute(C.shape, lambda i, j: C[i][j] + 1, "D") E = hcl.compute(C.shape, lambda i, j: C[i][j] * 2, "E") return D, E target = hcl.platform.aws_f1 s = hcl.create_schedule([A, B], kernel) s.to(kernel.C, s[kernel.D]) s.to(kernel.C, s[kernel.E]) code = str(hcl.lower(s)) assert "C.pipe1.write" in code assert "C.pipe1.read" in code assert "C.pipe2.write" in code assert "C.pipe2.read" in code
def test_float(): hcl.init(hcl.Float()) a = hcl.placeholder((10, )) b = hcl.compute(a.shape, lambda x: hcl.power(2.0, a[x])) s = hcl.create_schedule([a, b]) f = hcl.build(s) np_a = np.random.rand(10) np_b = np.zeros(10) hcl_a = hcl.asarray(np_a) hcl_b = hcl.asarray(np_b) f(hcl_a, hcl_b) np_golden = np.power(2, np_a) assert np.allclose(np_golden, hcl_b.asnumpy())
def test_sobel_vivado_hls(): width, height = 224, 224 A = hcl.placeholder((height, width, 3), "A") Gx = hcl.placeholder((3, 3), "Gx") Gy = hcl.placeholder((3, 3), "Gy") def sobel(A, Gx, Gy): B = hcl.compute((height, width), lambda x, y: A[x][y][0] + A[x][y][1] + A[x][y][2], "B") r = hcl.reduce_axis(0, 3) c = hcl.reduce_axis(0, 3) D = hcl.compute((height - 2, width - 2), lambda x, y: hcl.sum( B[x + r, y + c] * Gx[r, c], axis=[r, c], name="sum1"), "xx") t = hcl.reduce_axis(0, 3) g = hcl.reduce_axis(0, 3) E = hcl.compute( (height - 2, width - 2), lambda x, y: hcl.sum(B[x + t, y + g] * Gy[t, g], axis=[t, g]), "yy") return hcl.compute((height - 2, width - 2), lambda x, y: hcl.sqrt(D[x][ y] * D[x][y] + E[x][y] * E[x][y]) * 0.05891867, "Fimg") s = hcl.create_schedule([A, Gx, Gy], sobel) LBX = s.reuse_at(sobel.B._op, s[sobel.xx], sobel.xx.axis[0], "LBX") LBY = s.reuse_at(sobel.B._op, s[sobel.yy], sobel.yy.axis[0], "LBY") WBX = s.reuse_at(LBX, s[sobel.xx], sobel.xx.axis[1], "WBX") WBY = s.reuse_at(LBY, s[sobel.yy], sobel.yy.axis[1], "WBY") s.partition(LBX) s.partition(LBY) s.partition(WBX) s.partition(WBY) s.partition(Gx) s.partition(Gy) s[sobel.xx].pipeline(sobel.xx.axis[1]) s[sobel.yy].pipeline(sobel.yy.axis[1]) target = hcl.Platform.xilinx_zc706 s.to([A, Gx, Gy], target.xcel) s.to(sobel.Fimg, target.host) target.config(compiler="vivado_hls", mode="debug") print(hcl.build(s, target))
def test_stages_one_to_many(): A = hcl.placeholder((10, 32), "A") B = hcl.placeholder((10, 32), "B") def kernel(A, B): C = hcl.compute(A.shape, lambda i, j: A[i][j] + B[i][j], "C") D = hcl.compute(C.shape, lambda i, j: C[i][j] + 1, "D") E = hcl.compute(C.shape, lambda i, j: C[i][j] * 2, "E") return D, E target = hcl.Platform.aws_f1 s = hcl.create_schedule([A, B], kernel) s.to(kernel.C, s[kernel.D]) s.to(kernel.C, s[kernel.E]) code = str(hcl.lower(s)) print(code) assert "allocate C.pipe.1[int32 * 10 * 32]" in code assert "allocate C.pipe.2[int32 * 10 * 32]" in code
def test_multi_stage(): hcl.init() def test(A): r = hcl.reduce_axis(0, 10) B = hcl.compute((10, ), lambda x: hcl.sum(A[x, r], axis=r), "B") return B A = hcl.placeholder((10, 10)) s = hcl.create_schedule([A], test) s[test.B].split(test.B.axis[0], 5) f = hcl.build(s) a_np = np.random.randint(0, 10, size=(10, 10)) b_np = np.zeros(shape=(10, ), dtype="int") a_hcl = hcl.asarray(a_np) b_hcl = hcl.asarray(b_np) f(a_hcl, b_hcl) d_np = np.sum(a_np, axis=1) np.testing.assert_array_equal(d_np, b_hcl.asnumpy())
def test_compute_at_no_dep_diff_shape_larger(): hcl.init() A = hcl.compute((12, 12), lambda y, x: y + x, "A") B = hcl.compute((10, 10), lambda y, x: y - x, "B") s = hcl.create_schedule([A, B]) # the outer one will be truncated s[A].compute_at(s[B], B.axis[1]) f = hcl.build(s) a_hcl = hcl.asarray(np.zeros(A.shape, dtype="int")) b_hcl = hcl.asarray(np.zeros(B.shape, dtype="int")) f(a_hcl, b_hcl) a_np = np.fromfunction(lambda i, j: i + j, A.shape, dtype="int") b_np = np.fromfunction(lambda i, j: i - j, B.shape, dtype="int") for i in range(0, 12): for j in range(0, 12): if (i >= 10 or j >= 10): a_np[i][j] = 0 np.testing.assert_array_equal(a_np, a_hcl.asnumpy()) np.testing.assert_array_equal(b_np, b_hcl.asnumpy())
def test_compute_at_with_reuse_2D(): hcl.init() A = hcl.compute((10, 10), lambda y, x: x + y, "A") B = hcl.compute( (8, 8), lambda y, x: A[y, x] + A[y + 1, x + 1] + A[y + 2, x + 2], "B") s = hcl.create_schedule([B]) s[A].compute_at(s[B], B.axis[1]) ir = hcl.lower(s) assert "allocate A[int32 * 3 * 3]" in str(ir) f = hcl.build(s) a_np = np.fromfunction(lambda i, j: i + j, A.shape, dtype="int") b_np = np.zeros(B.shape, dtype="int") c_np = np.zeros(B.shape, dtype="int") for y in range(0, 8): for x in range(0, 8): c_np[y][x] = a_np[y][x] + a_np[y + 1][x + 1] + a_np[y + 2][x + 2] b_hcl = hcl.asarray(b_np) f(b_hcl) np.testing.assert_array_equal(c_np, b_hcl.asnumpy())
def test_binary_conv(): hcl.init() A = hcl.placeholder((1, 32, 14, 14), dtype=hcl.UInt(1), name="A") B = hcl.placeholder((64, 32, 3, 3), dtype=hcl.UInt(1), name="B") rc = hcl.reduce_axis(0, 32) ry = hcl.reduce_axis(0, 3) rx = hcl.reduce_axis(0, 3) C = hcl.compute((1, 64, 12, 12), lambda nn, ff, yy, xx: hcl.sum(A[nn, rc, yy + ry, xx + rx] * B[ff, rc, ry, rx], axis=[rc, ry, rx]), dtype=hcl.UInt(8), name="C") s = hcl.create_schedule([A, B, C]) s[C].split(C.axis[1], factor=5) code = hcl.build(s, target='aocl') assert "for (int ff_outer = 0; ff_outer < 13; ++ff_outer)" in code assert "for (int ff_inner = 0; ff_inner < 5; ++ff_inner)" in code assert "if (ff_inner < (64 - (ff_outer * 5)))" in code
def systolic(m=16, k=16, n=16, dtype=hcl.Int(), target=None): hcl.init(dtype) dim_x, dim_y = 16, 16 A = hcl.placeholder((m, k), dtype=dtype, name="A") B = hcl.placeholder((k, n), dtype=dtype, name="B") def kernel(A, B): localA = hcl.compute((m, k - 1), lambda *args: 0, "localA") localB = hcl.compute((k - 1, n), lambda *args: 0, "localB") output = hcl.compute((m, n), lambda *args: 0, "output") def update(k, y, x): localA[y, x] = hcl.select(x > 0, localA[y, x - 1], A[y, k]) localB[y, x] = hcl.select(y > 0, localB[y - 1, x], B[k, x]) output[y, x] = hcl.select( k == 0, 0, output[y, x]) + localA[y, x] * localB[y, x] hcl.mutate((m, dim_y, dim_x), lambda k, y, x: update(k, y, x), name="update") return output s = hcl.create_schedule([A, B], kernel) k = kernel.update s[k].pipeline(k.axis[0]) # self loopback streaming s.to(k.localA, kernel.update) s.to(k.localB, kernel.update) # move to xcel scope if not host_only: s.to([A, B], target.xcel) s.to(k.output, target.host) print(hcl.lower(s)) f = hcl.build(s, target=target) return f
def test_dtype_struct(): hcl.init() A = hcl.placeholder((100, ), dtype=hcl.Int(8)) B = hcl.placeholder((100, ), dtype=hcl.Fixed(13, 11)) C = hcl.placeholder((100, ), dtype=hcl.Float()) def kernel(A, B, C): stype = hcl.Struct({ "fa": hcl.Int(8), "fb": hcl.Fixed(13, 11), "fc": hcl.Float() }) D = hcl.compute(A.shape, lambda x: (A[x], B[x], C[x]), dtype=stype) E = hcl.compute(A.shape, lambda x: D[x].fa, dtype=hcl.Int(8)) F = hcl.compute(A.shape, lambda x: D[x].fb, dtype=hcl.Fixed(13, 11)) G = hcl.compute(A.shape, lambda x: D[x].fc, dtype=hcl.Float()) # Check the data type assert D[0].fa.dtype == "int8" assert D[0].fb.dtype == "fixed13_11" assert D[0].fc.dtype == "float32" return E, F, G s = hcl.create_schedule([A, B, C], kernel) print(hcl.lower(s)) f = hcl.build(s) np_A = np.random.randint(0, 500, size=100) - 250 np_B = np.random.rand(100) - 0.5 np_C = np.random.rand(100) - 0.5 np_E = np.zeros(100) np_F = np.zeros(100) np_G = np.zeros(100) hcl_A = hcl.asarray(np_A, dtype=hcl.Int(8)) hcl_B = hcl.asarray(np_B, dtype=hcl.Fixed(13, 11)) hcl_C = hcl.asarray(np_C, dtype=hcl.Float()) hcl_E = hcl.asarray(np_E, dtype=hcl.Int(8)) hcl_F = hcl.asarray(np_F, dtype=hcl.Fixed(13, 11)) hcl_G = hcl.asarray(np_G, dtype=hcl.Float()) f(hcl_A, hcl_B, hcl_C, hcl_E, hcl_F, hcl_G) assert np.allclose(hcl_A.asnumpy(), hcl_E.asnumpy()) assert np.allclose(hcl_B.asnumpy(), hcl_F.asnumpy()) assert np.allclose(hcl_C.asnumpy(), hcl_G.asnumpy())
def test_for_step_negative(): def kernel(A): with hcl.Stage(): with hcl.for_(9, -1, -1) as i: A[i] = i A = hcl.placeholder((10,)) s = hcl.create_schedule(A, kernel) f = hcl.build(s) np_A = np.random.randint(10, size=(10,)) golden_A = [i for i in range(0, 10)] hcl_A = hcl.asarray(np_A) f(hcl_A) ret_A = hcl_A.asnumpy() assert np.array_equal(golden_A, ret_A)
def test_for_irregular_bound(): def kernel(A): with hcl.for_(4, 8) as i: A[i] = i A = hcl.placeholder((10, )) s = hcl.create_schedule(A, kernel) f = hcl.build(s) np_A = np.random.randint(10, size=(10, )) golden_A = np.copy(np_A) for i in range(4, 8): golden_A[i] = i hcl_A = hcl.asarray(np_A) f(hcl_A) ret_A = hcl_A.asnumpy() assert np.array_equal(golden_A, ret_A)
def test_dtype_long_int(): # the longest we can support right now is 255-bit hcl.init(hcl.UInt(32)) A = hcl.placeholder((100, )) def kernel(A): B = hcl.compute(A.shape, lambda x: hcl.cast(hcl.UInt(255), A[x]) << 200, dtype=hcl.UInt(255)) C = hcl.compute(A.shape, lambda x: B[x] >> 200) return C s = hcl.create_schedule(A, kernel) f = hcl.build(s) np_A = np.random.randint(0, 1 << 31, 100) hcl_A = hcl.asarray(np_A) hcl_C = hcl.asarray(np.zeros(A.shape)) f(hcl_A, hcl_C) assert np.array_equal(np_A, hcl_C.asnumpy())
def bias_add_test(d_shape, b_shape, axis=1): hcl.init() data = hcl.placeholder(d_shape) bias = hcl.placeholder(b_shape) def func(data, bias, axis=axis): return hlib.op.nn.bias_add(data, bias, axis=axis) s = hcl.create_schedule([data, bias], func) f = hcl.build(s) _in = np.random.randint(10, size=d_shape) b = np.random.randint(10, size=b_shape) out = hcl.asarray(np.zeros(d_shape)) f(hcl.asarray(_in), hcl.asarray(b), out) def add(a): return np.add(a, b) if axis < 0: axis += len(d_shape) t_out = np.apply_along_axis(add, axis, _in) tst.assert_almost_equal(t_out, out.asnumpy())
def test_assert_exception(): hcl.init() A = hcl.placeholder((10, )) def kernel(A): hcl.assert_(5 == 6) return hcl.compute(A.shape, lambda x: A[x]) s = hcl.create_schedule([A], kernel) f = hcl.build(s) hclA = hcl.asarray(np.zeros(A.shape)) hclO = hcl.asarray(np.zeros(A.shape)) try: f(hclA, hclO) except hcl.debug.AssertError: return assert False
def test_cast_removal(): hcl.init() A = hcl.placeholder((10, 10), dtype=hcl.UInt(16), name="A") B = hcl.placeholder((10, 10), dtype=hcl.Int(16), name="B") def algo(A, B): def f_mutate(i, j): factor = hcl.scalar(B[0][0][13:11], name="factor") idx = hcl.scalar(B[0][0][11:0], dtype=hcl.UInt(16), name="idx") idx += i * hcl.cast(hcl.UInt(16), factor.v) A[idx][j] = B[idx][j] bound = hcl.scalar(5, dtype=hcl.Int(32)) domain = (hcl.cast(hcl.UInt(32), bound.v), hcl.cast(hcl.UInt(32), bound.v)) hcl.mutate(domain, f_mutate) s = hcl.create_schedule([A, B], algo) f = hcl.build(s, target="vhls")
def test_while_basic(): def kernel(A): a = hcl.scalar(0) with hcl.while_(a[0] < 10): A[a[0]] = a[0] a[0] += 1 A = hcl.placeholder((10, )) s = hcl.create_schedule(A, kernel) f = hcl.build(s) np_A = np.random.randint(10, size=(10, )) golden_A = [i for i in range(0, 10)] hcl_A = hcl.asarray(np_A) f(hcl_A) ret_A = hcl_A.asnumpy() assert np.array_equal(golden_A, ret_A)
def test_mem_if(): hcl.init(raise_assert_exception=False) matrix_1 = hcl.placeholder((m, k)) matrix_2 = hcl.placeholder((k, n)) def kernel(matrix_1, matrix_2): return_matrix = hcl.compute((m, k), lambda x, y : matrix_1[x, y] + matrix_2[x, y], "return_matrix") with hcl.if_(matrix_2[0, 0] == 0): matrix_A = hcl.compute((m, k), lambda x, y : matrix_1[x, y] + matrix_2[x, y], "matrix_A") with hcl.else_(): matrix_B = hcl.compute((m, k), lambda x, y : matrix_1[x, y] + matrix_2[x, y] + 2, "matrix_B") hcl.assert_(matrix_1[0, 0] != 0, "customized assert message 1") #result is false matrix_C = hcl.compute((m, k), lambda x, y : matrix_1[x, y] + matrix_2[x, y], "matrix_C") hcl.print(0, "this shouldn't be printed") return return_matrix s = hcl.create_schedule([matrix_1, matrix_2], kernel) return s
def test_if(): def kernel(A): with hcl.Stage(): with hcl.if_(A[0] > 5): A[0] = 5 A = hcl.placeholder((1,)) s = hcl.create_schedule(A, kernel) f = hcl.build(s) np_A = np.random.randint(10, size=(1,)) golden_A = [5 if np_A[0]>5 else np_A[0]] hcl_A = hcl.asarray(np_A) f(hcl_A) ret_A = hcl_A.asnumpy() assert np.array_equal(golden_A, ret_A)
def inter_stage_join(): hcl.init() A = hcl.placeholder((10, 32), "A") B = hcl.placeholder((10, 32), "B") def kernel(A, B): C = hcl.compute(A.shape, lambda i, j: 0, "C") hcl.update(C, lambda i, j: A[i, j] + 1, "s1") hcl.update(C, lambda i, j: B[i, j] * 2, "s2") return hcl.compute(C.shape, lambda *args: C[args] + 3, "ret") target = hcl.Platform.aws_f1 s = hcl.create_schedule([A, B], kernel) s.to(kernel.s1.C, kernel.ret.C) s.to(kernel.s2.C, kernel.ret.C) code = str(hcl.lower(s)) assert "allocate C.pipe.2[int32 * 10 * 32]" in code assert "allocate C.pipe.1[int32 * 10 * 32]" in code