Esempio n. 1
0
  /**
   * Create a resource from the given URI and append a new Network instance to its contents. The
   * resourceSet used must be authorized to write on the disk. This means that the default
   * EditingDomain's resourceSet must be used in a write transaction (for example). If it is not
   * possible, do not provide a resourceSet, the default one will be used.
   *
   * @param resourceSet
   * @param uri
   * @return The created network
   * @throws IOException
   */
  public static Network createNetworkResource(final ResourceSet resourceSet, final URI uri)
      throws IOException {

    final String fileName;
    if (uri.isPlatform()) {
      fileName = uri.toPlatformString(true);
    } else {
      fileName = uri.toString();
    }

    // Create the network
    final Network network = DfFactory.eINSTANCE.createNetwork(fileName);

    // Compute the new network name
    final Path networkPath = new Path(uri.trimFileExtension().path());
    // 3 first segments are resource/<PROJECT>/src
    network.setName(networkPath.removeFirstSegments(3).toString().replace('/', '.'));

    // Create the resource
    Resource res = resourceSet.createResource(uri);
    res.getContents().add(network);
    res.save(Collections.EMPTY_MAP);

    return network;
  }
Esempio n. 2
0
 @Override
 public Void casePort(Port port) {
   List<Edge> connections = new ArrayList<Edge>(port.getOutgoing());
   if (connections.size() > 1) {
     createBroadcast(network.getSimpleName(), port, connections);
   }
   return null;
 }
Esempio n. 3
0
  /**
   * Check if the given network contains a vertex (instance or port) with the given base name. If
   * yes, return a new unique name formed from the given base and a numeric suffix. If not, returns
   * the given base.
   *
   * @param network The network to check for existing vertex with the given name
   * @param base The base name to assign to a new vertex
   * @return A unique name to assign to a new Instance / Port in the given network
   */
  public static String uniqueVertexName(final Network network, final String base) {
    final Set<String> existingNames = new HashSet<String>();
    for (Vertex vertex : network.getVertices()) {
      existingNames.add(vertex.getLabel());
    }

    if (!existingNames.contains(base)) {
      return base;
    } else {
      int index = 0;
      while (existingNames.contains(base + '_' + index)) {
        ++index;
      }
      return base + '_' + index;
    }
  }
Esempio n. 4
0
  @Override
  public Void caseNetwork(Network network) {
    this.network = network;
    // make a copy of the existing vertex set because the set returned is
    // modified when broadcasts are added
    List<Vertex> vertexSet = new ArrayList<Vertex>(network.getVertices());

    for (Vertex vertex : vertexSet) {
      if (vertex instanceof Network) {
        new BroadcastAdder().doSwitch(vertex);
      } else {
        doSwitch(vertex);
      }
    }

    handle(network);

    return null;
  }
Esempio n. 5
0
  protected void createBroadcast(String id, Port port, List<? extends Edge> outList) {

    // Add broadcast vertex
    Actor bcast = dfFactory.createActor();
    bcast.setName(id + "_" + port.getName());

    Instance instance = dfFactory.createInstance(id + "_" + port.getName() + "_bcast", bcast);
    network.add(instance);

    Type portVarType = irFactory.createTypeList(1, port.getType());

    Pattern inputPattern = dfFactory.createPattern();
    Pattern outputPattern = dfFactory.createPattern();

    Port input = dfFactory.createPort(EcoreUtil.copy(port.getType()), "input");
    bcast.getInputs().add(input);

    // Creates a connection between the vertex and the broadcast
    Connection conn = (Connection) outList.get(0);
    Connection incoming =
        dfFactory.createConnection(
            conn.getSource(),
            conn.getSourcePort(),
            instance,
            input,
            EcoreUtil.copyAll(conn.getAttributes()));
    incoming.getAttributes().addAll(EcoreUtil.copyAll(conn.getAttributes()));
    network.getConnections().add(incoming);

    inputPattern.setNumTokens(input, 1);
    inputPattern.setVariable(input, irFactory.createVar(portVarType, "input", true, 0));

    // Change the source of the other connections
    int i = 0;
    for (Edge edge : outList) {
      Port output = dfFactory.createPort(EcoreUtil.copy(port.getType()), "output_" + i);
      bcast.getOutputs().add(output);

      Connection connection = (Connection) edge;
      connection.setSourcePort(output);
      connection.setSource(instance);

      outputPattern.setNumTokens(output, 1);
      outputPattern.setVariable(output, irFactory.createVar(portVarType, "output_" + i, true, 0));

      i++;
    }

    // Create body of the broadcast
    Procedure body = irFactory.createProcedure("copy", 0, irFactory.createTypeVoid());
    Var tmpVar = body.newTempLocalVariable(IrUtil.copy(port.getType()), "tmp");
    BlockBasic block = IrUtil.getLast(body.getBlocks());

    block.add(irFactory.createInstLoad(tmpVar, inputPattern.getVariable(input), 0));
    for (Port output : bcast.getOutputs()) {
      block.add(irFactory.createInstStore(outputPattern.getVariable(output), 0, tmpVar));
    }

    // Create the scheduler
    Procedure scheduler =
        irFactory.createProcedure("isSchedulable_copy", 0, irFactory.createTypeBool());
    BlockBasic block2 = IrUtil.getLast(scheduler.getBlocks());
    block2.add(irFactory.createInstReturn(irFactory.createExprBool(true)));

    Action copy =
        dfFactory.createAction(
            "copy", inputPattern, outputPattern, dfFactory.createPattern(), scheduler, body);

    bcast.getActions().add(copy);
    bcast.getActionsOutsideFsm().add(copy);
  }