From 525e62be311ae61494a5771ef6c7fb0709545ec5 Mon Sep 17 00:00:00 2001 From: Anshuman Mohan Date: Mon, 14 Aug 2023 12:02:56 -0400 Subject: [PATCH] Begin to add command Please ask your administrator.. --- calyx-py/test/correctness/pifo.data | 2 +- calyx-py/test/correctness/pifo.expect | 4 +- calyx-py/test/correctness/pifo.py | 95 +++++++++++++++++++++++++-- 3 files changed, 91 insertions(+), 10 deletions(-) diff --git a/calyx-py/test/correctness/pifo.data b/calyx-py/test/correctness/pifo.data index 303b30a41c..954df2114b 100644 --- a/calyx-py/test/correctness/pifo.data +++ b/calyx-py/test/correctness/pifo.data @@ -9,12 +9,12 @@ 104, 201, 202, + 1, 0, 0, 0, 0, 105, - 106, 0 ], "format": { diff --git a/calyx-py/test/correctness/pifo.expect b/calyx-py/test/correctness/pifo.expect index 307166fe21..3e76673b64 100644 --- a/calyx-py/test/correctness/pifo.expect +++ b/calyx-py/test/correctness/pifo.expect @@ -3,12 +3,12 @@ 101, 102, 201, + 201, 103, 202, 104, 105, 0, - 0, 0 ], "commands": [ @@ -20,12 +20,12 @@ 104, 201, 202, + 1, 0, 0, 0, 0, 105, - 106, 0 ] } diff --git a/calyx-py/test/correctness/pifo.py b/calyx-py/test/correctness/pifo.py index 18e754b6fa..8b1cd02fc6 100644 --- a/calyx-py/test/correctness/pifo.py +++ b/calyx-py/test/correctness/pifo.py @@ -64,7 +64,7 @@ def insert_pifo(prog, name): pifo: cb.ComponentBuilder = prog.component(name) cmd = pifo.input("cmd", 32) - # If this is 0, we pop. Otherwise, we push the value. + # If this is 0, we pop. If it is 1, we peek. Otherwise, we push the value. # Create the two FIFOs and ready them for invocation. fifo_0 = pifo.cell("myfifo_0", fifo.insert_fifo(prog, "fifo_0")) @@ -92,14 +92,17 @@ def insert_pifo(prog, name): flow_eq_1 = util.insert_eq(pifo, flow.out, 1, "flow_eq_1", 1) # flow == 1 len_eq_0 = util.insert_eq(pifo, len.out, 0, "len_eq_0", 32) # `len` == 0 len_eq_10 = util.insert_eq(pifo, len.out, 10, "len_eq_10", 32) # `len` == 10 - cmd_eq_0 = util.insert_eq(pifo, cmd, cb.const(32, 0), "cmd_eq_0", 32) # cmd == 0 - cmd_neq_0 = util.insert_neq(pifo, cmd, cb.const(32, 0), "cmd_neq_0", 32) # cmd != 0 + + cmd_eq_0 = util.insert_eq(pifo, cmd, 0, "cmd_eq_0", 32) # `cmd` == 0 + cmd_eq_1 = util.insert_eq(pifo, cmd, 1, "cmd_eq_1", 32) # `cmd` == 1 + cmd_gt_1 = util.insert_gt(pifo, cmd, 1, "cmd_gt_1", 32) # `cmd` > 1 + err_eq_0 = util.insert_eq(pifo, err.out, 0, "err_eq_0", 1) # err == 0 err_neq_0 = util.insert_neq( pifo, err.out, cb.const(1, 0), "err_neq_0", 1 ) # err != 0 - flip_hot = util.insert_bitwise_flip_reg(pifo, hot, "flip_hot", 1) # Flip `hot`. + flip_hot = util.insert_bitwise_flip_reg(pifo, hot, "flip_hot", 1) # flip `hot`. raise_err = util.insert_reg_store(pifo, err, 1, "raise_err") # set `err` to 1 lower_err = util.insert_reg_store(pifo, err, 0, "lower_err") # set `err` to 0 zero_out_ans = util.insert_reg_store(pifo, ans, 0, "zero_out_ans") # zero out `ans` @@ -110,7 +113,7 @@ def insert_pifo(prog, name): # The main logic. pifo.control += [ cb.par( - # Was it a pop or a push? We can do both cases in parallel. + # Was it a pop, peek, or a push? We can do all cases in parallel. cb.if_( # Did the user call pop? cmd_eq_0[0].out, @@ -212,10 +215,88 @@ def insert_pifo(prog, name): ], ), ), + cb.if_( + # Did the user call peek? + cmd_eq_1[0].out, + cmd_eq_1[1], + cb.if_( + # Yes, the user called peek. But is the queue empty? + len_eq_0[0].out, + len_eq_0[1], + [raise_err, zero_out_ans], # The queue is empty: underflow. + [ # The queue is not empty. Proceed. + # We must check if `hot` is 0 or 1. + lower_err, + cb.par( # We'll check both cases in parallel. + cb.if_( + # Check if `hot` is 0. + hot_eq_0[0].out, + hot_eq_0[1], + [ # `hot` is 0. We'll invoke `peek` on `fifo_0`. + cb.invoke( # First we call peek + fifo_0, + in_cmd=cb.const(32, 1), + ref_ans=ans, # Its answer is our answer. + ref_err=err, + ), + # Our next step depends on whether `fifo_0` + # raised the error flag. + cb.if_( + err_neq_0[0].out, + err_neq_0[1], + [ # `fifo_0` raised an error. + # We'll try to peek from `fifo_1`. + # We'll pass it a lowered `err`. + lower_err, + cb.invoke( + fifo_1, + in_cmd=cb.const(32, 1), + ref_ans=ans, + # Its answer is our answer. + ref_err=err, + # Its error is our error, + # whether it raised one or not. + ), + ], + ), + # Peeking does not affect `hot`. + # Peeking does not affect the length. + ], + ), + # If `hot` is 1, we proceed symmetrically. + cb.if_( + hot_eq_1[0].out, + hot_eq_1[1], + [ + cb.invoke( + fifo_1, + in_cmd=cb.const(32, 1), + ref_ans=ans, + ref_err=err, + ), + cb.if_( + err_neq_0[0].out, + err_neq_0[1], + [ + lower_err, + cb.invoke( + fifo_0, + in_cmd=cb.const(32, 1), + ref_ans=ans, + ref_err=err, + ), + ], + ), + ], + ), + ), + ], + ), + ), cb.if_( # Did the user call push? - cmd_neq_0[0].out, - cmd_neq_0[1], + cmd_gt_1[0].out, + cmd_gt_1[1], cb.if_( # Yes, the user called push. But is the queue full? len_eq_10[0].out,