Exemplo n.º 1
0
 private void addNetName(Name name) {
   GenMath.MutableInteger nn = netNames.get(name);
   if (nn == null) {
     nn = new GenMath.MutableInteger(-1);
     netNames.put(name, nn);
   }
   if (nn.intValue() < 0) {
     nn.setValue(netNameCount++);
   }
 }
Exemplo n.º 2
0
  private void localConnections(int netMap[]) {

    // Exports
    for (int k = 0; k < numExports; k++) {
      ImmutableExport e = exports.get(k);
      int portOffset = portOffsets[k];
      Name expNm = e.name;
      int busWidth = expNm.busWidth();
      int drawn = drawns[k];
      int drawnOffset = drawnOffsets[drawn];
      for (int i = 0; i < busWidth; i++) {
        ImmutableNetLayout.connectMap(
            netMap,
            portOffset + i,
            drawnOffset + (busWidth == drawnWidths[drawn] ? i : i % drawnWidths[drawn]));
        GenMath.MutableInteger nn = netNames.get(expNm.subname(i));
        ImmutableNetLayout.connectMap(netMap, portOffset + i, netNamesOffset + nn.intValue());
      }
    }

    // PortInsts
    for (int k = 0; k < numNodes; k++) {
      ImmutableNodeInst n = nodes.get(k);
      if (isIconOfParent(n)) {
        continue;
      }
      //            NodeProto np = ni.getProto();
      if (n.protoId instanceof PrimitiveNodeId) {
        // Connect global primitives
        Global g = globalInst(n);
        if (g != null) {
          int drawn = drawns[ni_pi[k]];
          ImmutableNetLayout.connectMap(netMap, globals.indexOf(g), drawnOffsets[drawn]);
        }
        if (n.protoId == schem.wireConNode.getId()) {
          connectWireCon(netMap, n);
        }
        continue;
      }
      IconInst iconInst = iconInsts[k];
      if (iconInst == null || iconInst.iconOfParent) {
        continue;
      }

      assert iconInst.nodeInst == n;
      CellId subCellId = (CellId) n.protoId;
      assert subCellId.isIcon() || subCellId.isSchematic();
      EquivalentSchematicExports iconEq = iconInst.eq;
      EquivalentSchematicExports schemEq = iconEq.implementation;
      assert schemEq != null;
      Name nodeName = n.name;
      int arraySize = nodeName.busWidth();
      int numPorts = getNumPorts(n.protoId);
      CellBackup subCell = snapshot.getCell(subCellId);
      for (int m = 0; m < numPorts; m++) {
        ImmutableExport e = subCell.cellRevision.exports.get(m);
        Name busExportName = e.name;
        int busWidth = busExportName.busWidth();
        int drawn = drawns[ni_pi[k] + m];
        if (drawn < 0) {
          continue;
        }
        int width = drawnWidths[drawn];
        if (width != busWidth && width != busWidth * arraySize) {
          continue;
        }
        for (int arrayIndex = 0; arrayIndex < arraySize; arrayIndex++) {
          int nodeOffset = iconInst.netMapOffset + arrayIndex * iconInst.numExtendedExports;
          int busOffset = drawnOffsets[drawn];
          if (width != busWidth) {
            busOffset += busWidth * arrayIndex;
          }
          for (int j = 0; j < busWidth; j++) {
            Name exportName = busExportName.subname(j);
            int portOffset = schemEq.getExportNameMapOffset(exportName);
            if (portOffset < 0) {
              continue;
            }
            ImmutableNetLayout.connectMap(netMap, busOffset + j, nodeOffset + portOffset);
          }
        }
      }
    }

    // Arcs
    for (int arcIndex = 0; arcIndex < numArcs; arcIndex++) {
      ImmutableArcInst a = arcs.get(arcIndex);
      int drawn = drawns[arcsOffset + arcIndex];
      if (drawn < 0) {
        continue;
      }
      if (!a.isUsernamed()) {
        continue;
      }
      int busWidth = drawnWidths[drawn];
      Name arcNm = a.name;
      if (arcNm.busWidth() != busWidth) {
        continue;
      }
      int drawnOffset = drawnOffsets[drawn];
      for (int i = 0; i < busWidth; i++) {
        GenMath.MutableInteger nn = netNames.get(arcNm.subname(i));
        ImmutableNetLayout.connectMap(netMap, drawnOffset + i, netNamesOffset + nn.intValue());
      }
    }

    // Globals of proxies
    for (IconInst iconInst : iconInsts) {
      if (iconInst == null || iconInst.iconOfParent) {
        continue;
      }
      Set<Global> excludeGlobals = null;
      if (iconInstExcludeGlobals != null) {
        excludeGlobals = iconInstExcludeGlobals.get(iconInst);
      }
      for (int k = 0; k < iconInst.nodeInst.name.busWidth(); k++) {
        EquivalentSchematicExports eq = iconInst.eq.implementation;
        assert eq.implementation == eq;
        int numGlobals = eq.portOffsets[0];
        if (numGlobals == 0) {
          continue;
        }
        int nodableOffset = iconInst.netMapOffset + k * iconInst.numExtendedExports;
        for (int i = 0; i < numGlobals; i++) {
          Global g = eq.globals.get(i);
          if (excludeGlobals != null && excludeGlobals.contains(g)) {
            continue;
          }
          ImmutableNetLayout.connectMap(netMap, this.globals.indexOf(g), nodableOffset + i);
        }
      }
    }

    ImmutableNetLayout.closureMap(netMap);
  }