Sat Jul 21 00:32:08 EDT 2018
Something really strange is going on with memories. There seems to be
some interference between the two feedback parts that do trace input
I don't understand, so I wonder, why does it need to be so opaque?
Can other kinds of feedback be just the same as closeReg?
The reason I didn't do this is because registers get re-initialized
completely on every round. But that isn't much different from being
closeProcess has this
-- Compute update using the update function bundled with current
-- state. Repack with update function to do the same next time.
o <- modifyProcess r p0 $ \(Process (s, u)) -> do
(s', o) <- u s
return (Process (s', u), o)
I think what happens is that the u in there calls modifyProcess again.
But it seems fine. There was a bug in here before.. The inner
routine can call modifyProcess, as long as it is a different r. Can
the r be the same?
modifyProcess r def f = do
ps <- getProcesses
let p = Map.findWithDefault def r ps
(p', o) <- f p
modify $ appProcesses $ insert r p'
Here's the routine. It appears as if the closeMem captures the first
instance of the input.
-- This does something really strange
x_mem_bad = do
let writes = [[0,1,x,x+20] | x <- [1..10]]
reads = [[x,0,0,0] | x <- [1..10]]
outs = t_mem $ writes ++ reads
t_mem = trace [8,1,8,8] $ \i@[ra,we,wa,wd] -> do
t <- stype wd
SeqEmu.closeMem [t] $ \[rd] ->
return ([(we, wa, wd, ra)], (rd:i))
putStrLn "-- x_mem_bad rd,ra,we,wa,wd"
Why does it capture the first value?
I think I'm assuming that the update equation is constant.
Yes, it's passed from call to call.
That's the problem.
Trouble is that once the equation is tucked away, I can't use it any
So the solution is to make the state typable.
EDIT: OK, works.