stubbed out mkBus for now - awaits full implementation

bs/Bus.bs

@@ -6,60 +6,66 @@ import TagEngine
 import Vector
 import Util
 import Arbiter
+import FIFO
+import FIFOF
+import SpecialFIFOs
 
 clientRequest :: Arbiter.ArbiterClient_IFC -> Action
 clientRequest ifc = ifc.request
 
-busRequestToAddr :: BusRequest -> Addr
+busRequestToAddr :: BusRequest -> Maybe Addr
 busRequestToAddr req = case req of
     BusReadRequest (ReadRequest addr _) -> addr
-    WriteReadRequest (WriteRequest addr _) -> addr
+    BusWriteRequest (WriteRequest addr _) -> addr
 
-mkBus :: (Addr -> Integer)
-      -> Vector numClients (BusClient inFlightTransactions)
-      -> Vector numServers (BusServer inFlightTransactions numClients)
-      -> Module Empty
-mkBus addrToServerTranslation clientVec serverVec = do
+mkBus :: (Addr -> Maybe Integer)
+      -> Module (Bus inFlightTransactions numClients numServers)
+mkBus addrToServerTranslation = do
+    -- Tag engines for each client to manage transaction tags
     tagEngineByClientVec :: Vector numClients (TagEngine inFlightTransactions)
     tagEngineByClientVec <- replicateM mkTagEngine
 
-    arbiterByServerVec :: Vector numServers (Arbiter_IFC numClients)
-    arbiterByServerVec <- replicateM (mkArbiter False)
+    -- Arbitration for clients to send requests to servers
+    clientArbiter :: Arbiter.Arbiter_IFC numClients
+    clientArbiter <- mkArbiter False
 
-    -- statically determinate criteria
-    let 
-        clientIdx :: Integer = 0
-        selectedClient ::(BusClient inFlightTransactions)
-        selectedClient = (select clientVec clientIdx)
-        selectedTagEngine = (select tagEngineByClientVec clientIdx)
+    dummyVar :: Reg(Bool)
+    dummyVar <- mkReg False
 
-    addRules |>
-        rules
-            "placeholder rule": when True ==> do
-                let selectedServerArbiter = (select arbiterByServerVec 0)
-                mapM_ clientRequest selectedServerArbiter.clients
+    -- Queues to hold requests from clients to servers
+    requestQueues :: Vector numServers (FIFOF BusRequest)
+    requestQueues <- replicateM (mkSizedBypassFIFOF (valueOf inFlightTransactions))
 
-            "connect request client 0": 
-                when True 
-                ==> do
-                tag <- selectedTagEngine.requestTag
+    -- Queues to hold responses from servers to clients
+    responseQueues :: Vector numClients (FIFOF (BusResponse, MkTagType inFlightTransactions))
+    responseQueues <- replicateM (mkSizedBypassFIFOF (valueOf inFlightTransactions))
 
-                busRequest      :: BusRequest
-                busRequest      <- selectedClient.dequeueRequest tag
+    -- Client interface vector
+    let clients :: Vector numClients (BusClient inFlightTransactions)
+        clients = genWith $ \clientIdx ->
+            interface BusClient
+                submitRequest req = do
+                    dummyVar := (not dummyVar)
+                    return 0
 
-                -- let
-                --     addr = busRequestToAddr busRequest
-                --     targetServerIdx  = addrToServerTranslation addr
-                --     targetServer  = (select serverVec targetServerIdx)
-                --     targetServerArbiter  = (select arbiterByServerVec targetServerIdx)
-                
-                -- targetServerArbiter.request
+                consumeResponse = do
+                    dummyVar := (not dummyVar)
+                    let dummyResponse = BusReadResponse (Left UnMapped)
+                    return (dummyResponse, 0)
 
-                -- if targetServerArbiter.grant
-                --     then targetServer.enqueueRequest (tag, busRequest)
-                --     else action {}
-                
-                -- targetServer
-                action {}
+    -- Server interface vector
+    let servers :: Vector numServers (BusServer inFlightTransactions numClients)
+        servers = genWith $ \serverIdx ->
+            interface BusServer
+                consumeRequest = do
+                    dummyVar := (not dummyVar)
+                    let dummyBusRequest = BusReadRequest (ReadRequest 0 SizeByte)
+                    return (0, dummyBusRequest)
 
-    return $ interface Empty { }
+                submitResponse (clientTag, busResponse, transactionTag) = do
+                    dummyVar := (not dummyVar)
+
+    return $
+        interface Bus
+            clients = clients
+            servers = servers