worked on client arbiter but need to consider if starving is possible when multiple client arbiters grant access to the same server

bs/Bus.bs

@@ -26,7 +26,8 @@ dummyRule =
             $display "test rule"
 
 -- we need a way to make serverMap safer...
-mkBus :: (Addr -> Maybe (MkServerIdx numServers))
+mkBus :: (Add n (TLog numServers) (TLog (TAdd numServers 1)))
+      => (Addr -> Maybe (MkServerIdx numServers))
       -> Module (Bus inFlightTransactions numClients numServers)
 mkBus serverMap = do
     -- Tag engines for each client to manage transaction tags
@@ -113,9 +114,51 @@ mkBus serverMap = do
                                         }
                                 clientResponseArbiterSlot.request
 
-                    (sprintf "client[%d] arbit server response" clientIdx): when True ==> do
-                        return |> action {}
+                    (sprintf "client[%d] arbit submission" clientIdx): when True ==> do
+                        let
+                            selectedClientResponseArbiter :: Arbiter.Arbiter_IFC (TAdd numServers 1)
+                            selectedClientResponseArbiter = (select responseArbiterByClient clientIdx)
 
+                            selectedClientResponseQueue :: FIFOF (TaggedBusResponse inFlightTransactions)
+                            selectedClientResponseQueue = (select clientResponseQueues clientIdx)
+
+                            -- `TAdd numServers 1` because we can receive request from all servers
+                            -- as well as a bypass requests from our one corresponding client request
+                            -- queue
+                            grantedIdx :: UInt (TLog (TAdd numServers 1))
+                            grantedIdx = unpack selectedClientResponseArbiter.grant_id
+
+                            isClientRequest :: Bool
+                            isClientRequest = grantedIdx == fromInteger (valueOf numServers)
+                        if isClientRequest then do
+                            let
+                                clientRequest :: TaggedBusRequest inFlightTransactions
+                                clientRequest = selectedClientRequestQueue.first
+
+                                responseUnMapped :: BusResponse
+                                responseUnMapped = case clientRequest.busRequest of
+                                    BusReadRequest _ -> BusReadResponse (Left UnMapped)
+                                    BusWriteRequest _ -> BusWriteResponse (Left UnMapped)
+
+                                response :: TaggedBusResponse inFlightTransactions
+                                response = TaggedBusResponse {
+                                    tag = clientRequest.tag;
+                                    busResponse = responseUnMapped
+                                }
+                            selectedClientResponseQueue.enq response
+                            selectedClientRequestQueue.deq
+                        else do
+                            let
+                                grantedServerIdx :: MkServerIdx numServers
+                                grantedServerIdx = truncate grantedIdx
+
+                                selectedSubmitResponseQueue :: FIFOF (TaggedBusResponse inFlightTransactions)
+                                selectedSubmitResponseQueue = (select submitResponseQueues grantedServerIdx)
+
+                                response :: TaggedBusResponse inFlightTransactions
+                                response = selectedSubmitResponseQueue.first
+                            selectedClientResponseQueue.enq response
+                            selectedSubmitResponseQueue.deq
 
     addRules |> foldr (<+>) (rules {}) clientRules