+class Trial(Elaboratable):
+ def __init__(self, core_config, trial_bits, current_shift, log2_radix):
+ self.core_config = core_config
+ self.trial_bits = trial_bits
+ self.current_shift = current_shift
+ self.log2_radix = log2_radix
+ bw = core_config.bit_width
+ self.divisor_radicand = Signal(bw, reset_less=True)
+ self.quotient_root = Signal(bw, reset_less=True)
+ self.root_times_radicand = Signal(bw * 2, reset_less=True)
+ self.compare_rhs = Signal(bw * 3, reset_less=True)
+ self.trial_compare_rhs = Signal(bw * 3, reset_less=True)
+ self.operation = DP.create_signal(reset_less=True)
+
+ def elaborate(self, platform):
+
+ m = Module()
+
+ dr = self.divisor_radicand
+ qr = self.quotient_root
+ rr = self.root_times_radicand
+
+ trial_bits_sig = Const(self.trial_bits, self.log2_radix)
+ trial_bits_sqrd_sig = Const(self.trial_bits * self.trial_bits,
+ self.log2_radix * 2)
+
+ tblen = self.core_config.bit_width+self.log2_radix
+ tblen2 = self.core_config.bit_width+self.log2_radix*2
+ dr_times_trial_bits_sqrd = Signal(tblen2, reset_less=True)
+ m.d.comb += dr_times_trial_bits_sqrd.eq(dr * trial_bits_sqrd_sig)
+
+ # UDivRem
+ with m.If(self.operation == int(DP.UDivRem)):
+ dr_times_trial_bits = Signal(tblen, reset_less=True)
+ m.d.comb += dr_times_trial_bits.eq(dr * trial_bits_sig)
+ div_rhs = self.compare_rhs
+
+ div_term1 = dr_times_trial_bits
+ div_term1_shift = self.core_config.fract_width
+ div_term1_shift += self.current_shift
+ div_rhs += div_term1 << div_term1_shift
+
+ m.d.comb += self.trial_compare_rhs.eq(div_rhs)
+
+ # SqrtRem
+ with m.Elif(self.operation == int(DP.SqrtRem)):
+ qr_times_trial_bits = Signal((tblen+1)*2, reset_less=True)
+ m.d.comb += qr_times_trial_bits.eq(qr * trial_bits_sig)
+ sqrt_rhs = self.compare_rhs
+
+ sqrt_term1 = qr_times_trial_bits
+ sqrt_term1_shift = self.core_config.fract_width
+ sqrt_term1_shift += self.current_shift + 1
+ sqrt_rhs += sqrt_term1 << sqrt_term1_shift
+ sqrt_term2 = trial_bits_sqrd_sig
+ sqrt_term2_shift = self.core_config.fract_width
+ sqrt_term2_shift += self.current_shift * 2
+ sqrt_rhs += sqrt_term2 << sqrt_term2_shift
+
+ m.d.comb += self.trial_compare_rhs.eq(sqrt_rhs)
+
+ # RSqrtRem
+ with m.Else():
+ rr_times_trial_bits = Signal((tblen+1)*3, reset_less=True)
+ m.d.comb += rr_times_trial_bits.eq(rr * trial_bits_sig)
+ rsqrt_rhs = self.compare_rhs
+
+ rsqrt_term1 = rr_times_trial_bits
+ rsqrt_term1_shift = self.current_shift + 1
+ rsqrt_rhs += rsqrt_term1 << rsqrt_term1_shift
+ rsqrt_term2 = dr_times_trial_bits_sqrd
+ rsqrt_term2_shift = self.current_shift * 2
+ rsqrt_rhs += rsqrt_term2 << rsqrt_term2_shift
+
+ m.d.comb += self.trial_compare_rhs.eq(rsqrt_rhs)
+
+ return m
+
+
+class DivPipeCoreCalculateStage(Elaboratable):
+ """ Calculate Stage of the core of the div/rem/sqrt/rsqrt pipeline. """
+
+ def __init__(self, core_config, stage_index):
+ """ Create a ``DivPipeCoreSetupStage`` instance. """
+ self.core_config = core_config
+ assert stage_index in range(core_config.n_stages)
+ self.stage_index = stage_index
+ self.i = self.ispec()
+ self.o = self.ospec()
+
+ def ispec(self):
+ """ Get the input spec for this pipeline stage. """
+ return DivPipeCoreInterstageData(self.core_config)
+
+ def ospec(self):
+ """ Get the output spec for this pipeline stage. """
+ return DivPipeCoreInterstageData(self.core_config)
+
+ def setup(self, m, i):
+ """ Pipeline stage setup. """
+ setattr(m.submodules,
+ f"div_pipe_core_calculate_{self.stage_index}",
+ self)
+ m.d.comb += self.i.eq(i)
+
+ def process(self, i):
+ """ Pipeline stage process. """
+ return self.o
+
+ def elaborate(self, platform):
+ """ Elaborate into ``Module``. """
+ m = Module()
+
+ # copy invariant inputs to outputs (for next stage)
+ m.d.comb += self.o.divisor_radicand.eq(self.i.divisor_radicand)
+ m.d.comb += self.o.operation.eq(self.i.operation)
+ m.d.comb += self.o.compare_lhs.eq(self.i.compare_lhs)
+
+ # constants
+ log2_radix = self.core_config.log2_radix
+ current_shift = self.core_config.bit_width
+ current_shift -= self.stage_index * log2_radix
+ log2_radix = min(log2_radix, current_shift)
+ assert log2_radix > 0
+ current_shift -= log2_radix
+ radix = 1 << log2_radix
+
+ # trials within this radix range. carried out by Trial module,
+ # results stored in pass_flags. pass_flags are unary priority.
+ trial_compare_rhs_values = []
+ pfl = []
+ for trial_bits in range(radix):
+ t = Trial(self.core_config, trial_bits, current_shift, log2_radix)
+ setattr(m.submodules, "trial%d" % trial_bits, t)
+
+ m.d.comb += t.divisor_radicand.eq(self.i.divisor_radicand)
+ m.d.comb += t.quotient_root.eq(self.i.quotient_root)
+ m.d.comb += t.root_times_radicand.eq(self.i.root_times_radicand)
+ m.d.comb += t.compare_rhs.eq(self.i.compare_rhs)
+ m.d.comb += t.operation.eq(self.i.operation)
+
+ # get the trial output
+ trial_compare_rhs_values.append(t.trial_compare_rhs)
+
+ # make the trial comparison against the [invariant] lhs.
+ # trial_compare_rhs is always decreasing as trial_bits increases
+ pass_flag = Signal(name=f"pass_flag_{trial_bits}", reset_less=True)
+ m.d.comb += pass_flag.eq(self.i.compare_lhs >= t.trial_compare_rhs)
+ pfl.append(pass_flag)
+
+ # Cat all the pass flags list together (easier to handle, below)
+ pass_flags = Signal(radix, reset_less=True)
+ m.d.comb += pass_flags.eq(Cat(*pfl))
+
+ # convert pass_flags (unary priority) to next_bits (binary index)
+ #
+ # Assumes that for each set bit in pass_flag, all previous bits are
+ # also set.
+ #
+ # Assumes that pass_flag[0] is always set (since
+ # compare_lhs >= compare_rhs is a pipeline invariant).
+
+ m.submodules.pe = pe = PriorityEncoder(radix)
+ next_bits = Signal(log2_radix, reset_less=True)
+ m.d.comb += pe.i.eq(~pass_flags)
+ with m.If(~pe.n):
+ m.d.comb += next_bits.eq(pe.o-1)
+ with m.Else():
+ m.d.comb += next_bits.eq(radix-1)
+
+ # get the highest passing rhs trial (indexed by next_bits)
+ ta = Array(trial_compare_rhs_values)
+ m.d.comb += self.o.compare_rhs.eq(ta[next_bits])
+
+ # create outputs for next phase
+ m.d.comb += self.o.root_times_radicand.eq(self.i.root_times_radicand
+ + ((self.i.divisor_radicand
+ * next_bits)
+ << current_shift))
+ m.d.comb += self.o.quotient_root.eq(self.i.quotient_root
+ | (next_bits << current_shift))
+ return m
+
+
+class DivPipeCoreFinalStage(Elaboratable):
+ """ Final Stage of the core of the div/rem/sqrt/rsqrt pipeline. """
+
+ def __init__(self, core_config):
+ """ Create a ``DivPipeCoreFinalStage`` instance."""
+ self.core_config = core_config
+ self.i = self.ispec()
+ self.o = self.ospec()
+
+ def ispec(self):
+ """ Get the input spec for this pipeline stage."""
+ return DivPipeCoreInterstageData(self.core_config)
+
+ def ospec(self):
+ """ Get the output spec for this pipeline stage."""
+ return DivPipeCoreOutputData(self.core_config)
+
+ def setup(self, m, i):
+ """ Pipeline stage setup. """
+ m.submodules.div_pipe_core_final = self
+ m.d.comb += self.i.eq(i)
+
+ def process(self, i):
+ """ Pipeline stage process. """
+ return self.o # return processed data (ignore i)
+
+ def elaborate(self, platform):
+ """ Elaborate into ``Module``. """
+ m = Module()
+
+ m.d.comb += self.o.quotient_root.eq(self.i.quotient_root)
+ m.d.comb += self.o.remainder.eq(self.i.compare_lhs
+ - self.i.compare_rhs)
+
+ return m