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

remove waw stall from issue unit

add an IssueUnitGroup which has a priority picker

stop on shadow for the moment

have to bring in a reset signal into the shadow units to get them to go to
a known state, after a branch result is known

separate out go_die from go_rd/go_wr to stop reg read/write triggering

get fake branch delay time working

whoops, operation supposed to be tested, not counter

branch success/fail nearly there

experimenting with branch shadowing

add branch speculation using shadows

use internal latch qlq value instead of creating a separate sync register

remove dummy values for branch setup

replace m.d.comb += with comb += etc. increases readability