Example #1
0
    public SignExtend(UnaryOp cast) {
      Iterator<Port> ports = cast.getDataPorts().iterator();
      Port d_port = ports.next();
      assert (d_port.isUsed()) : "Operand port in unary operation is set to unused.";
      Bus d_bus = d_port.getBus();
      assert (d_bus != null) : "Operand port in unary operation not attached to a bus.";
      PortWire pwire = new PortWire(d_port);
      if (pwire.getExpression() instanceof BaseNumber) {
        // input is a constant value, so the resize should be a no-op?
      } else {
        if (pwire.getExpression() instanceof Wire) {
          operand = (Wire) pwire.getExpression();
        } else {
          operand =
              new Wire(ID.toVerilogIdentifier(ID.showLogical(cast)), d_port.getValue().getSize());
          add(new Assign.Continuous(operand, new PortWire(d_port)));
          produced_nets.add(operand);
        }

        result_wire = NetFactory.makeNet(cast.getResultBus());
        produced_nets.add(result_wire);

        int result_width = result_wire.getWidth();

        /** unsigned value will be padded with zeros * */
        add(
            new Assign.Continuous(
                result_wire,
                new org.xronos.openforge.verilog.pattern.SignExtend(operand, result_width)));
      }
    }
Example #2
0
 protected Bus duplicateBus(Component c, Bus bus) {
   Exit exit = getSidebandExit(c);
   Bus dup = exit.makeDataBus(Component.SIDEBAND);
   dup.setIDLogical(ID.showLogical(bus));
   dup.copyAttributes(bus);
   return dup;
 }
Example #3
0
    Output(OutputPin opin, int nodeCount, int fontSize) {
      super(ID.showLogical(opin), nodeCount, fontSize);
      _graph.ln("Output Pin: " + opin);
      graph(opin, nodeCount++);
      Port p = opin.getPort();
      Bus b = p.getBus();
      graph(b.getOwner().getOwner(), nodeCount++);

      graphEdges(opin);
    }
Example #4
0
    Input(InputPin ipin, int nodeCount, int fontSize) {
      super(ID.showLogical(ipin), nodeCount, fontSize);
      graph(ipin, nodeCount++);
      _graph.ln("Input Pin: " + ipin);

      Bus b = ipin.getBus();
      for (Port p : b.getPorts()) {
        Component c = p.getOwner();
        graph(c, nodeCount++);
        graphEdges(c, b);
      }
    }
Example #5
0
 private static String getVerilogName(Object obj) {
   return ID.toVerilogIdentifier(ID.showLogical(obj));
 }
Example #6
0
  private void generateKickers() {
    final GenericJob job = EngineThread.getGenericJob();
    final boolean blockIO = !job.getUnscopedBooleanOptionValue(OptionRegistry.NO_BLOCK_IO); // If
    // Do
    // BlockIO
    final boolean doBlockSched =
        !job.getUnscopedBooleanOptionValue(OptionRegistry.SCHEDULE_NO_BLOCK_SCHEDULING);
    final boolean moduleBuilder =
        EngineThread.getGenericJob().getUnscopedBooleanOptionValue(OptionRegistry.MODULE_BUILDER);

    final Map<String, Kicker> kickers = new HashMap<String, Kicker>();
    for (Task task : design.getTasks()) {
      final Call call = task.getCall();
      final String domainSpec =
          (String)
              ((OptionString) EngineThread.getGenericJob().getOption(OptionRegistry.CLOCK_DOMAIN))
                  .getValue(call.getSearchLabel());

      if (!task.isKickerRequired()) {
        // Ensure that the Go port is validly connected
        if (!call.getGoPort().isConnected()) {
          job.warn("Task " + call.showIDLogical() + " is not autostart and has no enabling signal");
          Constant constant = new SimpleConstant(0, 1, false);
          constant.pushValuesForward();
          call.getGoPort().setBus(constant.getValueBus());
          call.getGoPort().pushValueForward();
        }
        continue;
      }

      Kicker kicker;
      final String kickerKey;
      if (doBlockSched && !moduleBuilder) {
        // Connect up a KickerContinuous that will keep us running at
        // max rate indefinately. We expect only one task in block
        // io, but if we have more than one, we need individual
        // kickers so that we use the right clock/reset for each.
        kicker = new Kicker.KickerContinuous();
        // Use the kickers string b/c there will be a (unique)
        // feedback from the task done
        kickerKey = kicker.toString();
      } else if (blockIO) {
        boolean fbRequired = checkFeedback(call.getProcedure().getBody());
        // System.out.println("Generated perpetual kicker withT/withoutF "
        // + fbRequired + " feedback flop required");
        // Connect up a KickerPerpetual that will keep us running
        // indefinately. We expect only one task in block io, but
        // if we have more than one, each needs its own kicker
        // anyway (since we OR back in the done). We could use
        // just one kicker for all and put the OR external but
        // there is no Design level module to put this stuff in.
        // Argh!
        kicker = new Kicker.KickerPerpetual(fbRequired);
        // Use the kickers string b/c there will be a (unique)
        // feedback from the task done
        kickerKey = kicker.toString();
      } else {
        if (moduleBuilder) {
          continue;
        }

        // find a kicker that matches this calls clk and reset
        // kickerKey = call.getClockName() + call.getResetName();
        kickerKey = domainSpec;
        kicker = kickers.get(kickerKey);
        // if we didn't find it, construct a new one
        if (kicker == null) {
          kicker = new Kicker();
        }
      }
      if (!kickers.containsKey(kickerKey)) {
        kickers.put(kickerKey, kicker);
        design.addComponentToDesign(kicker);
        design.getClockDomain(domainSpec).connectComponentToDomain(kicker);
      }

      if (call.getGoPort().isUsed()) {
        call.getGoPort().setBus(kicker.getDoneBus());
      }

      if (kicker.getRepeatPort() != null) {
        Bus callDone = call.getExit(Exit.DONE).getDoneBus();
        if (!callDone.isUsed()) {
          // there is the off-chance that it has fixed timing
          // and thus needs no done. Create a sequence of flops
          // to bypass.
          if (!call.getLatency().isFixed()) {
            EngineThread.getEngine()
                .fatalError(
                    "Unexpected internal state.  Design does not have a control structure and has variable timing");
          }
          Bus done = kicker.getDoneBus();
          for (int i = 0; i < call.getLatency().getMinClocks(); i++) {
            // Needs RESET b/c it is in the control path
            Reg flop = Reg.getConfigurableReg(Reg.REGR, ID.showLogical(call) + "_go_done_" + i);
            design.getClockDomain(domainSpec).connectComponentToDomain(flop);
            flop.getInternalResetPort().setBus(flop.getResetPort().getBus());
            flop.getDataPort().setBus(done);
            // Ensure that we've constant propagated the flop
            flop.propagateValuesForward();
            done = flop.getResultBus();
            design.addComponentToDesign(flop);
          }
          callDone = done;
        }
        kicker.getRepeatPort().setBus(callDone);
      }
    }
  }