notable progress WRT client requests invoking arbiter request

bs/Bus.bs

@@ -25,8 +25,13 @@ dummyRule =
         "test rule": when True ==> do
             $display "test rule"
 
+data DispatchFromClient inFlightTransactions numServers
+    = DispatchRequest  (TaggedBusRequest inFlightTransactions) (MkServerIdx numServers)
+    | DispatchResponse (TaggedBusResponse inFlightTransactions)
+    deriving (Bits, Eq, FShow)
+
 -- we need a way to make serverMap safer...
-mkBus :: (Addr -> Maybe ServerIdx)
+mkBus :: (Addr -> Maybe (MkServerIdx numServers))
       -> Module (Bus inFlightTransactions numClients numServers)
 mkBus serverMap = do
     -- Tag engines for each client to manage transaction tags
@@ -43,6 +48,13 @@ mkBus serverMap = do
     responseArbiterByClient :: Vector numClients (Arbiter.Arbiter_IFC (TAdd numServers 1))
     responseArbiterByClient <- replicateM (mkArbiter False)
 
+    -- After we inspect the head/oldest request in the `clientRequestQueues` and perform an
+    -- arbiter request to the destination arbiter, we need to inspect for grant in another
+    -- rule as I don't believe grant and request can be called simultaneously.
+    -- The following vector allows us to move
+    dispatchByClient :: Vector numClients (Wire (DispatchFromClient inFlightTransactions numServers))
+    dispatchByClient <- replicateM mkWire
+
     -- There are `numServer` servers, each of which needs its own arbiter as
     -- there are up to `numClient` clients that may wish to submit a response
     -- to a given client.
@@ -76,9 +88,11 @@ mkBus serverMap = do
                             clientRequest = selectedClientRequestQueue.first
 
                             targetAddr :: Addr = busRequestToAddr |> clientRequest.busRequest
-                            targetServerIdx :: (Maybe ServerIdx) = serverMap targetAddr
-                        -- $display "clientRequest" (fshow clientRequest)
-                        $display "Bus.bs:81" (fshow clientRequest)
+                            targetServerIdx :: (Maybe (MkServerIdx numServers)) = serverMap targetAddr
+
+                            dispatchByClientWire :: Wire (DispatchFromClient inFlightTransactions numServers)
+                            dispatchByClientWire = (select dispatchByClient clientIdx)
+
                         case targetServerIdx of
                             Just serverIdx -> do
                                 let
@@ -87,22 +101,30 @@ mkBus serverMap = do
                                     arbiterClientSlot :: Arbiter.ArbiterClient_IFC
                                     arbiterClientSlot = (select targetServerArbiter.clients clientIdx)
                                 arbiterClientSlot.request
+                                dispatchByClientWire := DispatchRequest clientRequest serverIdx
                             Nothing -> do
                                 let
-                                    idx = fromInteger clientIdx
-                                    targetClientResponseArbiter :: Arbiter.Arbiter_IFC numClients
-                                    targetClientResponseArbiter =  (select responseArbiterByClient idx)
+                                    targetClientResponseArbiter :: Arbiter.Arbiter_IFC (TAdd numServers 1)
+                                    targetClientResponseArbiter =  (select responseArbiterByClient clientIdx)
 
                                     clientResponseArbiterSlot :: Arbiter.ArbiterClient_IFC
-                                    -- arbiters 0 to n-1 are where `n:=numServer` are reserved 
+                                    -- arbiters 0 to n-1 where `n:=numServer` are reserved 
                                     -- for servers to make requests to. Arbiter n is reserved for 
                                     -- when this rule needs to skip making a request to a server 
                                     -- and should instead forward the `BusError UnMapped` response
                                     -- back to the client. Vector.last selects arbiter `n`
-                                    clientResponseArbiterSlot = Vector.last targetClientResponseArbiter
+                                    clientResponseArbiterSlot = Vector.last targetClientResponseArbiter.clients
+                                    responseUnMapped = case clientRequest.busRequest of
+                                        BusReadRequest _ -> BusReadResponse (Left UnMapped)
+                                        BusWriteRequest _ -> BusWriteResponse (Left UnMapped)
+                                    response :: TaggedBusResponse inFlightTransactions
+                                    response = TaggedBusResponse { 
+                                        tag = clientRequest.tag; 
+                                        busResponse =  responseUnMapped
+                                        }
+
                                 clientResponseArbiterSlot.request
-
-
+                                dispatchByClientWire := DispatchResponse response
 
     addRules |> foldr (<+>) (rules {}) clientRules
 

bs/BusTypes.bs

@@ -1,6 +1,6 @@
 package BusTypes(
     Bus(..),
-    ServerIdx,
+    MkServerIdx,
     MkClientTagType,
     BusClient(..), BusServer(..),
     BusRequest(..), BusResponse(..),
@@ -14,7 +14,7 @@ import Vector
 import TagEngine
 
 type MkClientTagType numClients = (UInt (TLog numClients))
-type ServerIdx = Integer
+type MkServerIdx numServers = (UInt (TLog numServers))
 
 data BusError
     = UnMapped