add separate read/write port

whoops syntax error

write out data only on go_write

clarify comment

add address and output mode from LDSTCUs

sort out go_ld_i and go_st_i

add temporary immediate-activation of go_addr on adr_rel request

add transitive accumulation of LD/STs into MDM

remove TODO (done)

fix several test imports, add Elaboratable

fix test run errors

rename match to nomatch, connect ld_i and st_i

convert addr match into latched (SRLatch) version, activate on req_rel,
deactivate on busy

use new ready/valid to ALU in CompLDST

start connecting memory function unit

only set adr_rel_o on LD or ADD/SUB, must wait for go_ad_i

starting to run into things being broken in LD/ST Comp (yay)

properly set the number of integer ALUs (2 at the moment)

set number of ALUs to 2

test LD/ST issue

add in ld/st operand pseudo-opcode

add in a TestMemory class

added in the LD/ST Comp Unit (not connected up yet) and the code didnt fall over
amazing that the unit test still runs, first time.

particularly that the number of INT ALUs was reduced from 4 to 2

move MemFunctionUnits to separate module

move FUMemMatchMatrix to mdm module

link address matching inputs to outside MemMatrix, preliminary test works

bring in cancel array into FURegDepMatrix

use in class which merges Partial Addr Match with FURegDepMatrix to
create a MDM (Memory Dependency Matrix)

make partialaddrmatch a matrix

rename variables

add 2nd test for mem dependency, use FU-Regs and FU-FU matrices

convert Reg_Rsv and rest of FU_Reg Matrix to variable n_src

use loop around src nums in FU Reg Matrix

convert FU_RW_Pend accumulator to src-vector

remove unneeded signals

start propagating arrays of src regs up through dependency matrix

whitespace

whoops use reduce(or_) not bool to merge bitwise src in dep cells

use new array-based dep cell in dep matrix

dependence cell to use arrays

reordering connections on mem-dep matrices

experiment connecting ld/st matrix to fu/mem one

add fu-mem versions of fu-fu matrix and picker vec

rename rsel vectors in mem dep cell

add fu-mem dependency cell based on fu_dep_cell.py

rename v_rd_rsel_o in dependence cell as well

rename fu-regs rd/wr sel vector

extend ld/st mem test

start preliminary test of load/store dependency matrices

continue miss_handler.py conversion

add first conversion of ariane miss handler, WIP

rename load_i and stor_i to ld_pend_i / st_pend_i, match names in MemFUDepMatrix

add mirror copy of FU_Regs Dep Matrix, names changed, adapted to LD/ST

wr -> ld
dest -> ld
rd -> st
src1 -> st

global search and replace.

add addrgen comment

add docstring for address match comparator

add to docstring

connect up LD/ST matrix properly

add ldst_matrix.py back in, needs some work though

whoops connect vector by y not x in FUFU matrix

allow branch immediate

reasonably sure that the pipelined ALU will work...

try random instructions test with immediates, works ok

add immediate to ALU instructions

add immediate arg to instr

remove unneeded code

add operand-is-immediate to sim and instructions

add op is immediate to instruction q

start adding in immediates into CompUnit ALU

remove unneeded code

whoops forgot to make CU decisions based on latched opcode

whoops search/replace error

add MemSim, remove redundant signal

LDSTDepCell can act as a matrix

shorten by adding temp comb = m.d.comb

addr release only on op_ldst

debug comp_ldst

make use of busy_o clearer

add LDST Computation Unit (in progress)

multi-bit LD?ST and add go_die

issue from q is combinatorial so do not need set to zer0

use instruction issue queue to get instructions into engine

got instruction queue working

leave off number being subtracted from "ready_o" calculation

add instruction queue test

do instruction q as array of (flat) Signals, add in and out data

flatten instruction queue using a shift register

remove unneeded imports

remove Shadow class, replace with ShadowFn, use multi-bit SRLatch

return to SRLatches for DependencyRow, simplifies (speeds up)

remove FU Dep Cell, go back to SRLatch direct

wire up FU-FU matrix using inverted row/col

make FU-FU DepCell a row

do dependency row as multi-bit SRLatch

add start of instruction queue

wait for individual batch-units rather than the global signal

whoops wrong mask for branch instruction decode

get issue logic working for issue unit array

latch opcode on instruction issue

use opcode-base issue units, parallel units

add docstring

group computation units together