def last_condition(self): cond = self._make_cond(self.last_cond) if cond is not None: cond = vtypes.AndList(self.state == self.state_count, cond) else: cond = self.state == self.state_count return cond
def make_output(self): data, valid, ready = self.output_vars # Inserting delayed registers ovar = self if self.stage_id is not None: for i in range(self.stage_id, self.df.max_stage_id): ovar = self.df.stage(ovar, preg=ovar) if not isinstance(data, (vtypes.Wire, vtypes.Output)): raise TypeError('Data signal must be Wire, not %s' % str(type(data))) else: ovar.df.m.Assign( data(ovar.data) ) my_valid = vtypes.Int(1) if ovar.valid is None else ovar.valid if valid is None: pass elif not isinstance(valid, (vtypes.Wire, vtypes.Output)): raise TypeError('Valid signal must be Wire, not %s' % str(type(valid))) else: ovar.df.m.Assign( valid(my_valid) ) if ready is None: ready = vtypes.Int(1) if ovar.ready is not None: prev_subst = ovar.ready._get_subst() if len(prev_subst) == 0: ovar.df.m.Assign( ovar.ready(ready) ) elif isinstance(prev_subst[0].right, vtypes.Int) and (prev_subst[0].right.value==1): ovar.ready.subst[0].overwrite_right( ready ) else: ovar.ready.subst[0].overwrite_right( vtypes.AndList(prev_subst[0].right, ready) ) ovar.dst_data = _PipelineInterface(data, valid, ready, output=True)
def current_condition(self): cond = self.next_kwargs['cond'] if 'cond' in self.next_kwargs else None if cond is not None: cond = vtypes.AndList(self.state == self.state_count, cond) else: cond = self.state == self.state_count return cond
def make_valid(self, valid, ready): if ready is not None and valid is not None: next_valid = vtypes.AndList(valid, ready) elif ready is not None: next_valid = ready elif valid is not None: next_valid = valid else: next_valid = None return next_valid
def pack_valid(self, lvalid, rvalid): if rvalid is not None and lvalid is not None: return vtypes.AndList(lvalid, rvalid) elif rvalid is None and lvalid is None: return None elif rvalid is None: return lvalid elif lvalid is None: return rvalid return None
def _and_vars(*vars): if not vars: return vtypes.Int(1) ret = None for var in vars: if var is None: continue if ret is None: ret = var else: ret = vtypes.AndList(ret, var) if ret is None: return vtypes.Int(1) return ret
def _make_prev(self, data, valid, ready, width=None, initval=0): tmp_data = self._add_reg('data', self.tmp_count, width=width, initval=initval) tmp_valid = valid tmp_ready = ready self.tmp_count += 1 if valid is not None and ready is not None: data_cond = vtypes.AndList(valid, ready) elif valid is not None: data_cond = valid elif ready is not None: data_cond = ready else: data_cond = None self.seq.add( tmp_data(data), cond=data_cond ) return tmp_data, tmp_valid, tmp_ready
def _make_tmp(self, data, valid, ready, width=None, initval=0, acc_ops=()): tmp_data = self._add_reg( 'data', self.tmp_count, width=width, initval=initval) if valid is not None: tmp_valid = self._add_reg('valid', self.tmp_count, initval=0) else: tmp_valid = None if ready: tmp_ready = self._add_wire('ready', self.tmp_count) else: tmp_ready = None self.tmp_count += 1 # all ready all_ready = None for r in ready: if r is None: continue if all_ready is None: all_ready = r else: all_ready = vtypes.AndList(all_ready, r) # data data_cond_vars = [] if valid is not None: data_cond_vars.append(valid) if tmp_ready is not None: data_cond_vars.append(all_ready) if tmp_valid is not None: data_cond_vars.append(vtypes.OrList( tmp_ready, vtypes.Not(tmp_valid))) else: data_cond_vars.append(tmp_ready) if len(data_cond_vars) == 0: data_cond = None elif len(data_cond_vars) == 1: data_cond = data_cond_vars[0] else: data_cond = vtypes.AndList(*data_cond_vars) # Accumulator for op in acc_ops: if not isinstance(op, type): data = op(tmp_data, data) elif issubclass(op, vtypes._BinaryOperator): data = op(tmp_data, data) elif issubclass(op, vtypes._UnaryOperator): data = op(data) if not isinstance(data, vtypes._Numeric): raise TypeError("Operator '%s' returns unsupported object type '%s'." % (str(op), str(type(data)))) self.seq.add(tmp_data(data), cond=data_cond) # valid valid_cond_vars = [] if tmp_ready is not None: valid_cond_vars.append(all_ready) ordy = vtypes.OrList(tmp_ready, vtypes.Not(tmp_valid)) valid_cond_vars.append(ordy) if len(valid_cond_vars) == 0: valid_cond = None elif len(valid_cond_vars) == 1: valid_cond = valid_cond_vars[0] else: valid_cond = vtypes.AndList(*valid_cond_vars) if tmp_valid is not None: if tmp_ready is not None: self.seq.add(tmp_valid(0), cond=vtypes.AndList( tmp_valid, tmp_ready)) self.seq.add(tmp_valid(valid), cond=valid_cond) # ready if tmp_ready is not None: ordy = vtypes.AndList(vtypes.OrList( tmp_ready, vtypes.Not(tmp_valid)), valid) for r in ready: _connect_ready(self.m, r, ordy) return tmp_data, tmp_valid, tmp_ready