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

remove unneeded import

use create_random_ops function

add in branch speculation recorder, link to branch

add branch speculation record

make bgt accessible outside of CU
increase shadow width (make room for branch shadow)

check that bgt test ALU works

add delay on branches

remove unneeded code

add delay on branches

work on branch simulation logic

reset shadow latches if neither success nor fail are applied

split out shared wait for issue and wait for busy clear functions

make a start on a branch simulator

add simple branch-compare example ALU

add priority picker docstring

cleanup, docstrings

shadow seems to do the job of guaranteeing write-after-write

set up the shadow grid

only want a single-bit transition

add in busy_prev/next signal to work out which unit was activated

shadow fail/good signals need to be amalgamated (shadow enable is the matrix)

make shadow inputs/good/fail arrays (actual matrix now)

decide to do write-after-write shadows

connect FUFU/FURegs Matrices to resettable go_rd/go_wr (include go_die)

start wiring up shadow matrix

re-enable shadow/go_die

whoops disconnected go_wr from CUs by mistake

add shadow matrix (unconnected)

add shadow matrix, array of shadow functions

add in shadown and go_die into comp unit

split out shadow into separate module

sort out counter, rename data_o to data_r (register), document CompUnit

invert write pending before use

testing if hazard can be done in current cycle

use global pending vectors for read/write pending accumulation

clean up names, also note that readable is true if no writes are pending
and writable is true if no reads are pending

use shifter opcode