Round Robin oracle and eDSL

calyx-py/calyx/builder.py

@@ -1026,6 +1026,14 @@ def le_store_in_reg(
         cell = self.le(width, cellname, signed)
         return self.op_store_in_reg(cell, left, right, cell.name, 1, ans_reg)
 
+    def ge_store_in_reg(
+        self, left, right, ans_reg=None, cellname=None, width=None, signed=False
+    ):
+        """Inserts wiring into `self` to perform `reg := left <= right`."""
+        width = width or self.try_infer_width(width, left, right)
+        cell = self.ge(width, cellname, signed)
+        return self.op_store_in_reg(cell, left, right, cell.name, 1, ans_reg)
+
     def mult_store_in_reg(
         self, left, right, ans_reg=None, cellname=None, width=None, signed=False
     ):

calyx-py/calyx/queues.py

@@ -192,6 +192,109 @@ def __len__(self) -> int:
         return self.len
 
 
+@dataclass
+class RRQueue:
+   """
+   This is a version of a PIFO generalized to n flows, with a round robin policy
+   that is work conserving. Just as with the PIFO, if a flow falls silent, the 
+   remaining flows will take their turns. That flow effectively skips its turn.
+
+   Supports the operations `push`, `pop`, and `peek`.
+   It takes in a list `boundaries` that must be of length `n`, the user can
+   divide the flows however they like.
+
+   - Push works analagously to that of the PIFO, except it checks the `boundaries`
+   list to determine which flow to push to.
+   - Pop first tries to pop from `hot`, given the length is not 0. If this fails, 
+   it continues to check all flows after. It then increments hot at the end and
+   decreases the length.
+   - Peek works the same as `pop`, except `hot` remains unchanged.
+   """
+
+   def __init__(self, n, boundaries, max_len: int):
+       self.data = []
+       self.hot = 0
+       self.n_flows = n
+       self.pifo_len = 0
+       self.boundaries = boundaries
+       for i in range(n):
+           queue = Fifo(max_len)
+           self.data.append(queue)
+
+       self.max_len = max_len
+       assert (
+           self.pifo_len <= self.max_len
+       )  # We can't be initialized with a PIFO that is too long.
+
+
+   def push(self, val: int):
+       """Pushes `val` to the PIFO."""
+       if self.pifo_len == self.max_len:
+            raise QueueError("Cannot push to full PIFO.")
+       for b in range(len(self.boundaries)):
+          if val <= self.boundaries[b]:
+            self.data[b].push(val)
+            self.pifo_len += 1
+            break
+
+
+   def increment_hot(self):
+       """Increments hot, taking into account wrap around."""
+       if self.hot == (self.n_flows - 1): # handle wrap around when updating hot
+            self.hot = 0
+       else:
+            self.hot = self.hot + 1
+
+
+   def pop(self) -> Optional[int]:
+       """Pops the PIFO. Updates `hot`."""
+       if self.pifo_len == 0:
+        raise QueueError("Cannot pop from empty PIFO.")
+
+       original_hot = self.hot
+
+       while True:
+        try:
+            val = self.data[self.hot].pop()
+            if val is not None:
+                self.increment_hot() 
+                self.pifo_len -= 1              
+                return val
+            else:
+                self.increment_hot()
+                if self.hot == original_hot:
+                    return None
+        except QueueError:
+            self.increment_hot()
+            if self.hot == original_hot:
+                return None
+
+
+   def peek(self) -> Optional[int]:
+       """Peeks into the PIFO. Does not affect what `hot` is."""
+       if self.pifo_len == 0:
+           raise QueueError("Cannot peek into empty PIFO.")
+
+       original_hot = self.hot
+       while True:
+            try:
+                val = self.data[self.hot].peek()
+                if val is not None:
+                    self.hot = original_hot
+                    return val
+                else:
+                    self.increment_hot()
+                    if self.hot == original_hot:
+                        return None
+            except QueueError:
+                self.increment_hot()
+                if self.hot == original_hot:
+                    return None
+
+
+   def __len__(self) -> int:
+       return self.pifo_len
+
 def operate_queue(queue, max_cmds, commands, values, ranks=None, keepgoing=False):
     """Given the two lists, one of commands and one of values.
     Feed these into our queue, and return the answer memory.

calyx-py/calyx/rrqueue_oracle.py

@@ -0,0 +1,18 @@
+# For usage, see gen_queue_data_expect.sh
+import sys
+import calyx.queues as queues
+from calyx import queue_util
+
+if __name__ == "__main__":
+    max_cmds, len = int(sys.argv[1]), int(sys.argv[2])
+    keepgoing = "--keepgoing" in sys.argv
+    commands, values, _ = queue_util.parse_json()
+
+    # Our Round Robin Queue (formerly known as generalized pifo) is simple: it 
+    # just orchestrates n FIFOs, in this case 3. It takes in a list of
+    # boundaries of length n (in this case 3).
+    pifo = queues.RRQueue(3, [133, 266, 400], len)
+
+    ans = queues.operate_queue(pifo, max_cmds, commands, values, keepgoing=keepgoing)
+
+    queue_util.dump_json(ans, commands, values)

calyx-py/test/correctness/queues/rr_queues/rr_queue.data

@@ -0,0 +1,89 @@
+{
+  "commands": {
+    "data": [
+      2,
+      2,
+      2,
+      1,
+      0,
+      0,
+      1,
+      0,
+      2,
+      2,
+      0,
+      0,
+      1,
+      2,
+      1,
+      2,
+      2,
+      2,
+      0,
+      1
+    ],
+    "format": {
+      "is_signed": false,
+      "numeric_type": "bitnum",
+      "width": 2
+    }
+  },
+  "values": {
+    "data": [
+      52,
+      293,
+      127,
+      6,
+      374,
+      110,
+      208,
+      143,
+      93,
+      392,
+      199,
+      81,
+      390,
+      36,
+      71,
+      316,
+      316,
+      227,
+      64,
+      67
+    ],
+    "format": {
+      "is_signed": false,
+      "numeric_type": "bitnum",
+      "width": 32
+    }
+  },
+  "ans_mem": {
+    "data": [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0
+    ],
+    "format": {
+      "is_signed": false,
+      "numeric_type": "bitnum",
+      "width": 32
+    }
+  }
+}

calyx-py/test/correctness/queues/rr_queues/rr_queue.expect

@@ -0,0 +1,68 @@
+{
+  "ans_mem": [
+    52,
+    52,
+    293,
+    127,
+    127,
+    392,
+    93,
+    36,
+    316,
+    36,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "commands": [
+    2,
+    2,
+    2,
+    1,
+    0,
+    0,
+    1,
+    0,
+    2,
+    2,
+    0,
+    0,
+    1,
+    2,
+    1,
+    2,
+    2,
+    2,
+    0,
+    1
+  ],
+  "values": [
+    52,
+    293,
+    127,
+    6,
+    374,
+    110,
+    208,
+    143,
+    93,
+    392,
+    199,
+    81,
+    390,
+    36,
+    71,
+    316,
+    316,
+    227,
+    64,
+    67
+  ]
+}