Пример #1
0
 public Void caseActor(Actor actor) {
   for (Var var : new ArrayList<Var>(actor.getStateVars())) {
     if (var.getType().isString()) {
       IrUtil.delete(var);
     }
   }
   return super.caseActor(actor);
 }
Пример #2
0
 @Override
 public Argument getArgument(String name) {
   for (Argument argument : getArguments()) {
     Var variable = argument.getVariable();
     if (variable != null && variable.getName().equals(name)) {
       return argument;
     }
   }
   return null;
 }
Пример #3
0
 public Void caseProcedure(Procedure proc) {
   for (Param param : new ArrayList<Param>(proc.getParameters())) {
     if (param.getVariable().getType().isString()) {
       IrUtil.delete(param);
     }
   }
   for (Var var : new ArrayList<Var>(proc.getLocals())) {
     if (var.getType().isString()) {
       IrUtil.delete(var);
     }
   }
   return super.caseProcedure(proc);
 }
  @Override
  protected void writeValuesToModel(final Widget widget) {
    final Instance instance = (Instance) getSelectedBusinessObject();

    // Only parameters of this instance's refinement (Actor or Network) can
    // be used as argument name
    final EObject refinement = instance.getEntity();
    List<Var> declaredVars = Collections.emptyList();
    if (refinement instanceof Network) {
      declaredVars = ((Network) refinement).getParameters();
    } else if (refinement instanceof Actor) {
      declaredVars = ((Actor) refinement).getParameters();
    }

    // Variables and parameters declared in the current network can be used
    // as value for an instance argument
    calParser.addDeclaredVars(getCurrentNetwork().getParameters());
    calParser.addDeclaredVars(getCurrentNetwork().getVariables());

    instance.getArguments().clear();

    for (final TableItem item : table.getItems()) {
      final String paramNameText = item.getText(0);
      final String valueText = item.getText(1);

      try {
        Var variable = null;
        for (final Var declaredVar : declaredVars) {
          if (declaredVar.getName().equals(paramNameText)) {
            variable = declaredVar;
          }
        }
        if (variable == null) {
          throw new OrccRuntimeException(
              "Variable " + paramNameText + " has not been found in this instance's refinement.");
        }
        final Expression exprValue = calParser.parseExpression(valueText);
        final Argument arg = DfFactory.eINSTANCE.createArgument(variable, exprValue);

        instance.getArguments().add(arg);
      } catch (OrccRuntimeException e) {
        MessageDialog.openError(XdfUtil.getDefaultShell(), "Error", e.getMessage());
      }
    }
  }
Пример #5
0
  @SuppressWarnings("unchecked")
  @Override
  public Loop caseBlockWhile(BlockWhile blockWhile) {
    // Initialize members
    Map<Var, Port> inputs = new HashMap<Var, Port>();
    Map<Var, Bus> outputs = new HashMap<Var, Bus>();

    Map<Bus, Var> feedbackBusVar = new HashMap<Bus, Var>();
    Map<Bus, Var> completeBusVar = new HashMap<Bus, Var>();
    // -- Decision
    // Construct decision from the block while condition
    Block decisionBlock = null;
    Component valueComponent = new ExprToComponent().doSwitch(blockWhile.getCondition());

    Map<Var, Port> dBlockDataPorts = null;

    if (!(valueComponent instanceof Block)) {
      dBlockDataPorts = new HashMap<Var, Port>();
      Map<Var, Port> valueDataPorts =
          (Map<Var, Port>) blockWhile.getCondition().getAttribute("inputs").getObjectValue();
      decisionBlock = new Block(Arrays.asList(valueComponent));
      // Propagate DataPorts
      ComponentUtil.propagateDataPorts(decisionBlock, dBlockDataPorts, valueDataPorts);
      // Propagate DataBuses
      for (Bus dataBus : valueComponent.getExit(Exit.DONE).getDataBuses()) {
        Bus blockDataBus = decisionBlock.getExit(Exit.DONE).makeDataBus();
        Port blockDataBuspeer = blockDataBus.getPeer();
        ComponentUtil.connectDataDependency(dataBus, blockDataBuspeer, 0);
      }
    } else {
      decisionBlock = (Block) valueComponent;
      dBlockDataPorts =
          (Map<Var, Port>) blockWhile.getCondition().getAttribute("inputs").getObjectValue();
    }

    Component decisionComponent = ComponentUtil.decisionFindConditionComponent(decisionBlock);

    // Create decision
    Decision decision = new Decision(decisionBlock, decisionComponent);

    Debug.depGraphTo(decision, "deicions", "/tmp/decision1.dot", 1);

    // Propagate decisionBlockInputs to the decision one
    Map<Var, Port> dDataPorts = new HashMap<Var, Port>();
    ComponentUtil.propagateDataPorts(decision, dDataPorts, dBlockDataPorts);

    // -- Loop Body
    // Construct Loop Body Block from the block while blocks
    Map<Var, Port> blockDataPorts = new HashMap<Var, Port>();
    Map<Var, Bus> blockDataBuses = new HashMap<Var, Bus>();

    Module body =
        (Module)
            new BlocksToBlock(blockDataPorts, blockDataBuses, false)
                .doSwitch(blockWhile.getBlocks());

    // Loop body (While Body) inputs and outputs
    Map<Var, Port> lbDataPorts = new HashMap<Var, Port>();

    LoopBody loopBody = new WhileBody(decision, body);
    Debug.depGraphTo(loopBody, "loopBody", "/tmp/loopBody.dot", 1);
    // Propagate decision and body inputs to the loopBody
    // -- Propagate Decision data ports
    ComponentUtil.propagateDataPorts(loopBody, lbDataPorts, dDataPorts);

    // -- Propagate Body Blocks data ports
    ComponentUtil.propagateDataPorts(loopBody, lbDataPorts, blockDataPorts);

    // -- Complete Exit
    for (Var var : blockDataBuses.keySet()) {
      Type type = var.getType();
      Bus bus = blockDataBuses.get(var);
      // -- Make an complete exit data bus
      Bus cBus =
          loopBody
              .getLoopCompleteExit()
              .makeDataBus(var.getName() + "_fb", type.getSizeInBits(), type.isInt());
      // -- Connect
      Port cBusPeer = cBus.getPeer();
      ComponentUtil.connectDataDependency(bus, cBusPeer);
      // -- Save it to the feedbackBusVar
      completeBusVar.put(cBus, var);
    }

    // -- FeedBack Exit
    for (Var var : blockDataBuses.keySet()) {
      Type type = var.getType();
      // -- If the input does not exist create one because this is a
      // feedback
      if (!lbDataPorts.containsKey(var)) {
        Port lbPort =
            loopBody.makeDataPort(var.getName() + "_fb", type.getSizeInBits(), type.isInt());
        lbDataPorts.put(var, lbPort);
      }
      Bus bus = blockDataBuses.get(var);
      // -- Make an feedback exit data bus
      Bus fbBus =
          loopBody
              .getFeedbackExit()
              .makeDataBus(var.getName() + "_fb", type.getSizeInBits(), type.isInt());
      // -- Connect
      Port fbBusPeer = fbBus.getPeer();
      ComponentUtil.connectDataDependency(bus, fbBusPeer);
      // -- Save it to the feedbackBusVar
      feedbackBusVar.put(fbBus, var);
    }

    // -- From input to Complete Exit dependency
    for (Bus bus : completeBusVar.keySet()) {
      Var var = completeBusVar.get(bus);
      Port port = lbDataPorts.get(var);
      // -- Connect it
      Port busPeer = bus.getPeer();
      Bus portpeer = port.getPeer();
      ComponentUtil.connectDataDependency(portpeer, busPeer);
    }

    // Create Loop
    Loop loop = new Loop(loopBody);

    // -- Loop inputs comes from decision and body
    Set<Var> inVars = new HashSet<Var>();
    inVars.addAll(dDataPorts.keySet());
    inVars.addAll(lbDataPorts.keySet());

    for (Var var : inVars) {
      Type type = var.getType();
      Port dataPort = loop.makeDataPort(var.getName(), type.getSizeInBits(), type.isInt());
      inputs.put(var, dataPort);
    }

    // -- Init Dependencies
    Entry initEntry = loop.getBodyInitEntry();
    for (Var var : inputs.keySet()) {
      if (feedbackBusVar.containsValue(var)) {
        Port lPort = inputs.get(var);
        Port lbPort = lbDataPorts.get(var);
        Bus lPortPeer = lPort.getPeer();
        Dependency dep =
            (lbPort == lbPort.getOwner().getGoPort())
                ? new ControlDependency(lPortPeer)
                : new DataDependency(lPortPeer);
        initEntry.addDependency(lbPort, dep);
      }
    }

    // -- Feedback Dependencies
    Entry fbEntry = loop.getBodyFeedbackEntry();
    for (Bus bus : feedbackBusVar.keySet()) {
      Var var = feedbackBusVar.get(bus);
      Exit lfbExit = loop.getBody().getFeedbackExit();
      Port lbPort = lbDataPorts.get(var);

      // -- Create a feedback register
      Reg fbReg = loop.createDataRegister();
      fbReg.setIDLogical("fbReg_" + var.getName());
      // fbReg.getDataPort().setIDLogical(var.getName());
      // fbReg.getResultBus().setIDLogical(var.getName());

      // -- Dependencies
      Entry entry = fbReg.makeEntry(lfbExit);
      entry.addDependency(fbReg.getDataPort(), new DataDependency(bus));
      fbEntry.addDependency(lbPort, new DataDependency(fbReg.getResultBus()));
    }

    // -- Latch Dependencies
    Collection<Dependency> goInitDeps = initEntry.getDependencies(loop.getBody().getGoPort());
    Bus initDoneBus = goInitDeps.iterator().next().getLogicalBus();
    for (Var var : inVars) {
      if (!feedbackBusVar.containsValue(var)) {
        Port lPort = inputs.get(var);
        Bus lPortPeer = lPort.getPeer();

        // -- Create a latch
        Latch latch = loop.createDataLatch();
        latch.setIDLogical("latched_" + var.getName());

        // -- Dependencies
        Entry latchEntry = latch.makeEntry(initDoneBus.getOwner());
        latch.getDataPort().setIDLogical(var.getName());
        // -- Control dependency
        latchEntry.addDependency(latch.getEnablePort(), new ControlDependency(initDoneBus));
        // -- Data dependency in latch
        latchEntry.addDependency(latch.getDataPort(), new DataDependency(lPortPeer));
        // -- Data dependency out latch
        Bus latchResultBus = latch.getResultBus();
        latchResultBus.setIDLogical(var.getName() + "_result");

        Port lbPort = lbDataPorts.get(var);
        fbEntry.addDependency(lbPort, new DataDependency(latchResultBus));
      }
    }

    // -- Done Dependencies
    Entry outbufEntry = loop.getExit(Exit.DONE).getPeer().getEntries().get(0);
    for (Bus bus : loopBody.getLoopCompleteExit().getDataBuses()) {
      Var var = completeBusVar.get(bus);
      Type type = var.getType();
      Bus dataBus =
          loop.getExit(Exit.DONE).makeDataBus(var.getName(), type.getSizeInBits(), type.isInt());
      Port dataBusPeer = dataBus.getPeer();
      Dependency dep = new DataDependency(bus);
      outbufEntry.addDependency(dataBusPeer, dep);
      outputs.put(var, dataBus);
    }

    // -- Set control dependency
    Port lbDonePort = loopBody.getLoopCompleteExit().getDoneBus().getPeer();
    Bus lDoneBus = loop.getExit(Exit.DONE).getDoneBus();
    Dependency dep = new ControlDependency(lDoneBus);
    outbufEntry.addDependency(lbDonePort, dep);

    // -- IDSourceInfo
    Procedure procedure = EcoreHelper.getContainerOfType(blockWhile, Procedure.class);
    IDSourceInfo sinfo = new IDSourceInfo(procedure.getName(), blockWhile.getLineNumber());
    loop.setIDSourceInfo(sinfo);
    Debug.depGraphTo(loop, "loopBody", "/tmp/loop_new.dot", 1);

    // -- Set attributes
    blockWhile.setAttribute("inputs", inputs);
    blockWhile.setAttribute("outputs", outputs);
    return loop;
  }
Пример #6
0
  @Override
  public Void caseAction(Action action) {
    // FIXME: Do not detect a pathological case for the moment,
    // extra clock cycles

    for (Port port : action.getOutputPattern().getPorts()) {
      int size = action.getOutputPattern().getNumTokensMap().get(port);
      if (size > 1) {
        Var newVar = newPortToVarMap.get(port);
        Var var = action.getOutputPattern().getPortToVarMap().get(port);

        EList<Use> uses = var.getUses();
        while (!uses.isEmpty()) {
          uses.get(0).setVariable(newVar);
        }
        EList<Def> defs = var.getDefs();
        while (!defs.isEmpty()) {
          defs.get(0).setVariable(newVar);
        }

        // Create the Block while for the repeat
        BlockWhile whileBlock = IrFactory.eINSTANCE.createBlockWhile();
        whileBlock.setJoinBlock(IrFactory.eINSTANCE.createBlockBasic());

        // Create the condition
        Type type = IrFactory.eINSTANCE.createTypeInt(32);
        Var index = IrFactory.eINSTANCE.createVar(type, "rp_Index_" + port.getName(), true, 0);

        action.getBody().getLocals().add(index);

        ExprVar condE0 = IrFactory.eINSTANCE.createExprVar(index);
        ExprInt condE1 = IrFactory.eINSTANCE.createExprInt(size);

        ExprBinary whileCond =
            IrFactory.eINSTANCE.createExprBinary(
                condE0, OpBinary.LT, condE1, IrFactory.eINSTANCE.createTypeBool());

        whileBlock.setCondition(whileCond);

        // Create an if block with a pin Status as condition

        Var pinStatus =
            IrFactory.eINSTANCE.createVar(
                IrFactory.eINSTANCE.createTypeBool(), "portStatus_" + port.getName(), true, 0);
        action.getBody().getLocals().add(pinStatus);

        // Add portStatus to the first block of the while
        BlockBasic firstWhileBlock = IrFactory.eINSTANCE.createBlockBasic();
        InstPortStatus portStatus = XronosIrUtil.createInstPortStatus(pinStatus, port);
        firstWhileBlock.add(portStatus);
        whileBlock.getBlocks().add(firstWhileBlock);

        BlockIf blockIf = IrFactory.eINSTANCE.createBlockIf();
        blockIf.setJoinBlock(IrFactory.eINSTANCE.createBlockBasic());

        ExprVar ifCond = IrFactory.eINSTANCE.createExprVar(pinStatus);
        blockIf.setCondition(ifCond);

        // -----------------------------------------------------------
        // Then Block

        // Create While blockBasic
        BlockBasic thenBlock = IrFactory.eINSTANCE.createBlockBasic();

        // Create a Load instruction
        Type tmpLoadType = IrUtil.copy(port.getType());
        Var tmpLoad =
            IrFactory.eINSTANCE.createVar(tmpLoadType, "tmp_rp_" + port.getName(), true, 0);
        action.getBody().getLocals().add(tmpLoad);

        ExprVar loadIndex = IrFactory.eINSTANCE.createExprVar(index);

        InstLoad load =
            IrFactory.eINSTANCE.createInstLoad(
                tmpLoad, newVar, Arrays.asList((Expression) loadIndex));

        thenBlock.add(load);

        // Create the Port Write instruction
        InstPortWrite portWrite = XronosIrUtil.createInstPortWrite(port, tmpLoad, false);

        thenBlock.add(portWrite);

        // Create the instruction assign with index++
        ExprVar assignE0 = IrFactory.eINSTANCE.createExprVar(index);
        ExprInt assignE1 = IrFactory.eINSTANCE.createExprInt(1);

        ExprBinary assignValue =
            IrFactory.eINSTANCE.createExprBinary(
                assignE0, OpBinary.PLUS, assignE1, IrFactory.eINSTANCE.createTypeInt());

        InstAssign assignIndex = IrFactory.eINSTANCE.createInstAssign(index, assignValue);
        thenBlock.add(assignIndex);

        // -----------------------------------------------------------

        // Add to thenBlocks the thenBlock
        blockIf.getThenBlocks().add(thenBlock);

        // Add the ifBlock to the Block While
        whileBlock.getBlocks().add(blockIf);

        // Create a Block Basic with rp_Index_ to 0
        BlockBasic initRpIndex = IrFactory.eINSTANCE.createBlockBasic();
        InstAssign rpAssignZero = IrFactory.eINSTANCE.createInstAssign(index, 0);
        initRpIndex.add(rpAssignZero);

        // Add the BlockWhile to the body of the procedure
        int indexBlock = action.getBody().getBlocks().size();
        Block lastBlock = action.getBody().getBlocks().get(indexBlock - 1);
        if (isSinlgeReturnBlock(lastBlock)) {
          action.getBody().getBlocks().add(indexBlock - 1, initRpIndex);
          action.getBody().getBlocks().add(indexBlock, whileBlock);
        } else {
          if (lastBlock.isBlockBasic()) {
            BlockBasic basic = (BlockBasic) lastBlock;
            int instrSize = basic.getInstructions().size();
            if (basic.getInstructions().get(instrSize - 1).isInstReturn()) {
              Instruction returnInst = basic.getInstructions().get(instrSize - 1);
              BlockBasic newLastBlock = IrFactory.eINSTANCE.createBlockBasic();
              newLastBlock.add(returnInst);
              action.getBody().getBlocks().add(initRpIndex);
              action.getBody().getBlocks().add(whileBlock);
              action.getBody().getBlocks().add(newLastBlock);
            }
          }
        }
      }
    }

    return null;
  }