diff --git a/calyx-py/calyx/queue_call.py b/calyx-py/calyx/queue_call.py index b58768e359..b722d6c6d2 100644 --- a/calyx-py/calyx/queue_call.py +++ b/calyx-py/calyx/queue_call.py @@ -3,6 +3,7 @@ import calyx.builder_util as util MAX_CMDS = 15 +ANS_MEM_LEN = 10 def insert_raise_err_if_i_eq_max_cmds(prog): @@ -58,7 +59,7 @@ def insert_main(prog, queue): # - one ref register, `err`, which is raised if an error occurs. commands = main.seq_mem_d1("commands", 32, MAX_CMDS, 32, is_external=True) - ans_mem = main.seq_mem_d1("ans_mem", 32, 10, 32, is_external=True) + ans_mem = main.seq_mem_d1("ans_mem", 32, ANS_MEM_LEN, 32, is_external=True) # The two components we'll use: queue = main.cell("myqueue", queue) diff --git a/calyx-py/test/correctness/fifo.py b/calyx-py/test/correctness/fifo.py index 4789f40332..17ca08520c 100644 --- a/calyx-py/test/correctness/fifo.py +++ b/calyx-py/test/correctness/fifo.py @@ -3,13 +3,15 @@ import calyx.builder_util as util import calyx.queue_call as qc +MAX_QUEUE_LEN = 10 + def insert_fifo(prog, name): """Inserts the component `fifo` into the program. It has: - one input, `cmd`. - - one memory, `mem`, of size 10. + - one memory, `mem`, of size MAX_QUEUE_LEN. - two registers, `next_write` and `next_read`. - two ref registers, `ans` and `err`. """ @@ -18,11 +20,11 @@ def insert_fifo(prog, name): cmd = fifo.input("cmd", 32) # If this is 0, we pop. If it is 1, we peek. Otherwise, we push the value. - mem = fifo.seq_mem_d1("mem", 32, 10, 32) + mem = fifo.seq_mem_d1("mem", 32, MAX_QUEUE_LEN, 32) write = fifo.reg("next_write", 32) # The next address to write to read = fifo.reg("next_read", 32) # The next address to read from # We will orchestrate `mem`, along with the two pointers above, to - # simulate a circular queue of size 10. + # simulate a circular queue of size MAX_QUEUE_LEN. ans = fifo.reg("ans", 32, is_ref=True) # If the user wants to pop, we will write the popped value to `ans` @@ -37,12 +39,16 @@ def insert_fifo(prog, name): cmd_eq_1 = util.insert_eq(fifo, cmd, 1, "cmd_eq_1", 32) # `cmd` == 1 cmd_gt_1 = util.insert_gt(fifo, cmd, 1, "cmd_gt_1", 32) # `cmd` > 1 - write_eq_10 = util.insert_eq( - fifo, write.out, 10, "write_eq_10", 32 - ) # `write` == 10 - read_eq_10 = util.insert_eq(fifo, read.out, 10, "read_eq_10", 32) # `read` == 10 + write_eq_max_queue_len = util.insert_eq( + fifo, write.out, MAX_QUEUE_LEN, "write_eq_MAX_QUEUE_LEN", 32 + ) # `write` == MAX_QUEUE_LEN + read_eq_max_queue_len = util.insert_eq( + fifo, read.out, MAX_QUEUE_LEN, "read_eq_MAX_QUEUE_LEN", 32 + ) # `read` == MAX_QUEUE_LEN len_eq_0 = util.insert_eq(fifo, len.out, 0, "len_eq_0", 32) # `len` == 0 - len_eq_10 = util.insert_eq(fifo, len.out, 10, "len_eq_10", 32) # `len` == 10 + len_eq_max_queue_len = util.insert_eq( + fifo, len.out, MAX_QUEUE_LEN, "len_eq_MAX_QUEUE_LEN", 32 + ) # `len` == MAX_QUEUE_LEN # Cells and groups to increment read and write registers write_incr = util.insert_incr(fifo, write, "write_incr") # write++ @@ -89,8 +95,8 @@ def insert_fifo(prog, name): read_incr, # Increment the read pointer. cb.if_( # Wrap around if necessary. - read_eq_10[0].out, - read_eq_10[1], + read_eq_max_queue_len[0].out, + read_eq_max_queue_len[1], read_wrap, ), len_decr, # Decrement the length. @@ -118,16 +124,16 @@ def insert_fifo(prog, name): cmd_gt_1[1], cb.if_( # Yes, the user called push. But is the queue full? - len_eq_10[0].out, - len_eq_10[1], + len_eq_max_queue_len[0].out, + len_eq_max_queue_len[1], [raise_err, zero_out_ans], # The queue is full: overflow. [ # The queue is not full. Proceed. write_to_mem, # Write to the queue. write_incr, # Increment the write pointer. cb.if_( # Wrap around if necessary. - write_eq_10[0].out, - write_eq_10[1], + write_eq_max_queue_len[0].out, + write_eq_max_queue_len[1], write_wrap, ), len_incr, # Increment the length. diff --git a/calyx-py/test/correctness/pifo.py b/calyx-py/test/correctness/pifo.py index c9d36626e6..d260eae5e9 100644 --- a/calyx-py/test/correctness/pifo.py +++ b/calyx-py/test/correctness/pifo.py @@ -4,6 +4,8 @@ import calyx.builder_util as util import calyx.queue_call as qc +MAX_QUEUE_LEN = 10 + def insert_flow_inference(comp: cb.ComponentBuilder, cmd, flow, boundary, group): """The flow is needed when the command is a push. @@ -53,14 +55,15 @@ def insert_pifo(prog, name, queue_l, queue_r, boundary): violation of the 50/50 rule) until the silent flow starts transmitting again. At that point we go back to 50/50. - The PIFO's maximum capacity is 10. + The PIFO's maximum capacity is MAX_QUEUE_LEN. Let's say the two flows are called `0` and `1`. - We orchestrate two sub-queues, `queue_l` and `queue_r`, each of capacity 10. + We orchestrate two sub-queues, `queue_l` and `queue_r`, + each of capacity MAX_QUEUE_LEN. We maintain a register that points to which of these sub-queues is "hot". Start off with `hot` pointing to `queue_l` (arbitrarily). - `push(v, PIFO)`: - + If len(PIFO) = 10, raise an "overflow" err and exit. + + If len(PIFO) = MAX_QUEUE_LEN, raise an "overflow" err and exit. + Otherwise, the charge is to enqueue value `v`. Find out which flow `f` the value `v` should go to; `f` better be either `0` or `1`. @@ -109,7 +112,9 @@ def insert_pifo(prog, name, queue_l, queue_r, boundary): flow_eq_0 = util.insert_eq(pifo, flow.out, 0, "flow_eq_0", 1) flow_eq_1 = util.insert_eq(pifo, flow.out, 1, "flow_eq_1", 1) len_eq_0 = util.insert_eq(pifo, len.out, 0, "len_eq_0", 32) - len_eq_10 = util.insert_eq(pifo, len.out, 10, "len_eq_10", 32) + len_eq_max_queue_len = util.insert_eq( + pifo, len.out, MAX_QUEUE_LEN, "len_eq_MAX_QUEUE_LEN", 32 + ) cmd_eq_0 = util.insert_eq(pifo, cmd, 0, "cmd_eq_0", 32) cmd_eq_1 = util.insert_eq(pifo, cmd, 1, "cmd_eq_1", 32) cmd_gt_1 = util.insert_gt(pifo, cmd, 1, "cmd_gt_1", 32) @@ -267,8 +272,8 @@ def insert_pifo(prog, name, queue_l, queue_r, boundary): cmd_gt_1[1], cb.if_( # Yes, the user called push. But is the queue full? - len_eq_10[0].out, - len_eq_10[1], + len_eq_max_queue_len[0].out, + len_eq_max_queue_len[1], [raise_err, zero_out_ans], # The queue is full: overflow. [ # The queue is not full. Proceed. lower_err,