src/soc/fu/compunits.py

   1 ###################################################################
   2 """Function Units Construction
   3
   4 This module pulls all of the pipelines together (soc.fu.*) and, using
   5 the regspec and Computation Unit APIs, constructs Scoreboard-aware
   6 Function Units that may systematically and automatically be wired up
   7 to appropriate Register Files.
   8
   9 Two types exist:
  10
  11 * Single-cycle Function Units.  these are FUs that will only block for
  12   one cycle.  it is expected that multiple of these be instantiated,
  13   because they are simple and trivial, and not many gates.
  14
  15   - ALU, Logical: definitely several
  16   - CR: not so many needed (perhaps)
  17   - Branch: one or two of these (depending on speculation run-ahead)
  18   - Trap: yeah really only one of these
  19   - ShiftRot (perhaps not too many of these)
  20
  21 * Multi-cycle (and FSM) Function Units.  these are FUs that can only
  22   handle a limited number of values, and take several cycles to complete.
  23   Given that under Scoreboard Management, start and completion must be
  24   fully managed, a "Reservation Station" style approach is required:
  25   *one* multiple-stage (N stage) pipelines need a minimum of N (plural)
  26   "CompUnit" front-ends.  this includes:
  27
  28   - MUL (all versions including MAC)
  29   - DIV (including modulo)
  30
  31 In either case, there will be multiple MultiCompUnits: it's just that
  32 single-cycle ones are instantiated individually (one single-cycle pipeline
  33 per MultiCompUnit, and multi-cycle ones need to be instantiated en-masse,
  34 where *only one* actual pipeline (or FSM) has *multiple* Reservation
  35 Stations.
  36
  37 see:
  38
  39 * https://libre-soc.org/3d_gpu/architecture/regfile/ section on regspecs
  40
  41 """
  42
  43 from nmigen.cli import rtlil
  44 from soc.experiment.compalu_multi import MultiCompUnit
  45
  46 # pipeline / spec imports
  47
  48 from soc.fu.alu.pipeline import ALUBasePipe
  49 from soc.fu.alu.pipe_data import ALUPipeSpec
  50
  51 from soc.fu.cr.pipeline import CRBasePipe
  52 from soc.fu.cr.pipe_data import CRPipeSpec
  53
  54 from soc.fu.branch.pipeline import BranchBasePipe
  55 from soc.fu.branch.pipe_data import BranchPipeSpec
  56
  57 from soc.fu.shift_rot.pipeline import ShiftRotBasePipe
  58 from soc.fu.shift_rot.pipe_data import ShiftRotPipeSpec
  59
  60
  61 ###################################################################
  62 ###### FunctionUnitBaseSingle - use to make single-stge pipes #####
  63
  64 class FunctionUnitBaseSingle(MultiCompUnit):
  65     """FunctionUnitBaseSingle
  66
  67     main "glue" class that brings everything together.
  68     ONLY use this class for single-stage pipelines.
  69
  70     * :speckls:  - the specification.  contains regspec and op subset info,
  71                    and contains common "stuff" like the pipeline ctx,
  72                    what type of nmutil pipeline base is to be used (etc)
  73     * :pipekls:  - the type of pipeline.  actually connects things together
  74
  75     note that it is through MultiCompUnit.get_in/out that we *actually*
  76     connect up the association between regspec variable names (defined
  77     in the pipe_data).
  78     """
  79     def __init__(self, speckls, pipekls):
  80         pspec = speckls(id_wid=2)                # spec (NNNPipeSpec instance)
  81         opsubset = pspec.opsubsetkls             # get the operand subset class
  82         regspec = pspec.regspec                  # get the regspec
  83         alu = pipekls(pspec)                     # create actual NNNBasePipe
  84         super().__init__(regspec, alu, opsubset) # pass to MultiCompUnit
  85
  86
  87 ##############################################################
  88 # TODO: ReservationStations-based (FunctionUnitBaseConcurrent)
  89
  90 class FunctionUnitBaseMulti:
  91     pass
  92
  93
  94 ######################################################################
  95 ###### actual Function Units: these are "single" stage pipelines #####
  96
  97 class ALUFunctionUnit(FunctionUnitBaseSingle):
  98     def __init__(self): super().__init__(ALUPipeSpec, ALUBasePipe)
  99
 100 class CRFunctionUnit(FunctionUnitBaseSingle):
 101     def __init__(self): super().__init__(CRPipeSpec, CRBasePipe)
 102
 103 class BranchFunctionUnit(FunctionUnitBaseSingle):
 104     def __init__(self): super().__init__(BranchPipeSpec, BranchBasePipe)
 105
 106 class ShiftRotFunctionUnit(FunctionUnitBaseSingle):
 107     def __init__(self): super().__init__(ShiftRotPipeSpec, ShiftRotBasePipe)
 108
 109 #####################################################################
 110 ###### actual Function Units: these are "multi" stage pipelines #####
 111
 112 # TODO: ReservationStations-based.
 113
 114
 115 def tst_single_fus_il():
 116     for (name, kls) in (('alu', ALUFunctionUnit),
 117                         ('cr', CRFunctionUnit),
 118                         ('branch', BranchFunctionUnit),
 119                         ('shiftrot', ShiftRotFunctionUnit)):
 120         fu = kls()
 121         vl = rtlil.convert(fu, ports=fu.ports())
 122         with open("fu_%s.il" % name, "w") as f:
 123             f.write(vl)
 124
 125 if __name__ == '__main__':
 126     tst_single_fus_il()