@Override
 public String toString() {
   /*
    * Don't return a string with spaces in it becase this is used to
    * create a name for the object, and we cannot have spaces in our
    * name, or else it messes up the XML/XMI processing.
    */
   final StringBuffer name = new StringBuffer();
   EList ml = getCurrentModes();
   for (Iterator it = ml.iterator(); it.hasNext(); ) {
     final ModeInstance mi = (ModeInstance) it.next();
     final ComponentInstance ci = (ComponentInstance) mi.eContainer();
     name.append(ci.getComponentInstancePath());
     if (name.length() > 0) {
       name.append(".");
     }
     name.append(mi.getName());
     if (it.hasNext()) {
       name.append("#");
     }
   }
   return name.toString();
 }
  /**
   * check the load from connections bound to the given bus
   *
   * @param curBus Component Instance of bus
   * @param doBindings if true do bindings to all buses, if false do them only for EtherSwitch
   * @param somName String somName to be used in messages
   */
  protected void checkBandWidthLoad(final ComponentInstance curBus, SystemOperationMode som) {
    UnitLiteral kbspsliteral = GetProperties.getKBytespsUnitLiteral(curBus);
    double Buscapacity = GetProperties.getBandWidthCapacityInKbps(curBus, 0.0);
    boolean doBroadcast = GetProperties.isBroadcastProtocol(curBus);
    SystemInstance root = curBus.getSystemInstance();
    double totalBandWidth = 0.0;
    EList<ConnectionInstance> budgetedConnections = InstanceModelUtil.getBoundConnections(curBus);

    // filters out to use only Port connections or feature group connections
    // it also tries to be smart about not double accounting for budgets on FG that now show for
    // every port instance inside.

    /*
    ConnectionGroupIterator cgi = new ConnectionGroupIterator(connections);
    while (cgi.hasNext())
    {
    	ConnectionInstance obj = cgi.next();
    	if (obj != null)
    	{
    		if (InstanceModelUtil.isBoundToBus(obj, curBus)||
    				// we derived a bus connection from the connection end bindings
    			(!InstanceModelUtil.hasBusBinding(obj)&&InstanceModelUtil.connectedByBus(obj, curBus)) )
    		{
    			if ((obj.getSource().isActive(som)) && (obj.getDestination().isActive(som)))
    			{
    				budgetedConnections.add(obj);
    			}
    		}
    	}
    }*/
    if (doBroadcast) {
      budgetedConnections = filterSameSourceConnections(budgetedConnections);
    }
    if (Buscapacity == 0) {
      if (!budgetedConnections.isEmpty()) {
        errManager.warningSummary(
            curBus,
            som.getName(),
            curBus.getComponentInstancePath() + " has no capacity but bound connections");
      } else {
        errManager.warningSummary(
            curBus, som.getName(), curBus.getComponentInstancePath() + " has no capacity");
        return;
      }
    }
    if (budgetedConnections.isEmpty()) {
      errManager.infoSummary(
          curBus,
          som.getName(),
          curBus.getComponentInstancePath()
              + " with bandwidth capacity "
              + Buscapacity
              + "KBytesps has no bound connections");
      return;
    }
    if (som != null) {
      errManager.logInfo(
          "\n\nConnection Budget Details for bus "
              + curBus.getFullName()
              + " in mode "
              + som.getName()
              + " with capacity "
              + Buscapacity
              + "KBytesps\n");
    } else {
      errManager.logInfo(
          "\n\nConnection Budget Details for bus "
              + curBus.getFullName()
              + " with capacity "
              + Buscapacity
              + "KBytesps\n");
    }

    errManager.logInfo("Connection,Budget,Actual (Data Size * Sender Rate),Note");
    for (ConnectionInstance connectionInstance : budgetedConnections) {
      double budget = 0.0;
      double actual = 0.0;

      if ((!connectionInstance.getSource().isActive(som))
          || (!connectionInstance.getDestination().isActive(som))) {
        continue;
      }

      // we have a binding, is it to the current bus
      budget = GetProperties.getBandWidthBudgetInKbps(connectionInstance, 0.0);
      actual = calcBandwidthKBytesps(connectionInstance.getSource());
      String note = "";
      if (budget > 0) {
        if ((actual > 0) && (actual > budget)) {
          totalBandWidth += actual;
          note = "Actual bandwidth exceeds bandwidth budget. Using actual";
        } else {
          totalBandWidth += budget;
          note = "Using budget bandwidth";
        }
      } else {
        if (actual > 0) {
          totalBandWidth += actual;
          note = "No bandwidth budget. Using actual";
        } else {
          note = "No bandwidth budget or actual bandwidth from port data size&rate";
        }
      }
      detailedLog(connectionInstance, budget, actual, note);
    }
    detailedLog(null, totalBandWidth, kbspsliteral);
    if (totalBandWidth > Buscapacity) {
      errManager.errorSummary(
          curBus,
          som.getName(),
          curBus.getComponentInstancePath()
              + " bandwidth capacity "
              + Buscapacity
              + " KBytesps exceeded by connection bandwidth budget totals "
              + totalBandWidth
              + " Kbps");
    } else if (totalBandWidth > 0.0 && Buscapacity > 0.0) {
      errManager.infoSummary(
          curBus,
          som.getName(),
          curBus.getComponentInstancePath()
              + " bandwidth capacity "
              + Buscapacity
              + " KBytesps sufficient for connection bandwidth  budget totals "
              + totalBandWidth
              + " Kbps");
    }
  }
 /**
  * check the load from components bound to the given memory The components can be threads or
  * higher level components.
  *
  * @param curMemory Component Instance of memory
  */
 protected void doMemoryLoad(
     ComponentInstance curMemory, String somName, EList boundComponents, boolean isROM) {
   double totalMemory = 0.0;
   UnitLiteral kbliteral = GetProperties.getKBUnitLiteral(curMemory);
   String resourceName = isROM ? "ROM" : "RAM";
   double Memorycapacity =
       isROM
           ? GetProperties.getROMCapacityInKB(curMemory, 0.0)
           : GetProperties.getRAMCapacityInKB(curMemory, 0.0);
   if (boundComponents.size() == 0 && Memorycapacity > 0) {
     errManager.infoSummary(
         curMemory,
         somName,
         "No application components bound to "
             + curMemory.getComponentInstancePath()
             + " with "
             + resourceName
             + " capacity "
             + GetProperties.toStringScaled(Memorycapacity, kbliteral));
     return;
   }
   if (Memorycapacity == 0) {
     errManager.errorSummary(
         curMemory,
         somName,
         "Memory "
             + curMemory.getComponentInstancePath()
             + " has no "
             + resourceName
             + " capacity but has bound components.");
   }
   logHeader(
       "\n\nDetailed Workload Report for memory "
           + curMemory.getComponentInstancePath()
           + " with Capacity "
           + GetProperties.toStringScaled(Memorycapacity, kbliteral)
           + "\n\nComponent,Budget,Actual");
   Set budgeted = new HashSet();
   for (Iterator it = boundComponents.iterator(); it.hasNext(); ) {
     String notes = "";
     ComponentInstance bci = (ComponentInstance) it.next();
     double totalactual = sumMemoryActuals(bci, isROM);
     double budget =
         isROM
             ? GetProperties.getROMBudgetInKB(bci, 0.0)
             : GetProperties.getRAMBudgetInKB(bci, 0.0);
     if (totalactual > 0) {
       // only compare if there were actuals
       if (totalactual > budget) {
         notes =
             notes
                 + ",Error: "
                 + resourceName
                 + " subtotal exceeds budget by "
                 + (totalactual - budget)
                 + " KB";
       } else if (totalactual < budget) {
         notes =
             notes
                 + ",Warning: "
                 + resourceName
                 + " Subtotal under budget by "
                 + (budget - totalactual)
                 + " KB";
       }
     }
     if (totalactual == 0.0) {
       // we use a budget number as there are no actuals
       if (budget > 0 && !budgeted.contains(bci)) {
         // only add it if no children budget numbers have been added
         totalMemory += budget;
         detailedLog(bci, budget, kbliteral);
         // add ancestors to budgeted list so their budget does not get added later
         while ((bci = bci.getContainingComponentInstance()) != null) {
           budgeted.add(bci);
         }
       }
     } else {
       // add only the current actual; the children actual have been added before
       double currentActual =
           isROM
               ? GetProperties.getROMActualInKB(bci, 0.0)
               : GetProperties.getRAMActualInKB(bci, 0.0);
       detailedLog(bci, budget, kbliteral);
       totalMemory += currentActual;
     }
   }
   if (Memorycapacity == 0)
     errManager.errorSummary(
         curMemory,
         somName,
         ""
             + (isROM ? "ROM" : "RAM")
             + " memory "
             + curMemory.getComponentInstancePath()
             + " has no memory capacity specified");
   if (totalMemory > Memorycapacity) {
     errManager.errorSummary(
         curMemory,
         somName,
         "Total Memory "
             + totalMemory
             + " KB of bounds tasks exceeds Memory capacity "
             + Memorycapacity
             + " KB of "
             + curMemory.getComponentInstancePath());
   } else if (totalMemory == 0.0 && Memorycapacity == 0.0) {
     errManager.warningSummary(
         curMemory,
         somName,
         ""
             + (isROM ? "ROM" : "RAM")
             + " memory "
             + curMemory.getComponentInstancePath()
             + " has no capacity. Bound app's have no memory budget.");
   } else {
     errManager.infoSummary(
         curMemory,
         somName,
         "Total "
             + (isROM ? "ROM" : "RAM")
             + " memory "
             + totalMemory
             + " KB of bound tasks within Memory capacity "
             + Memorycapacity
             + " KB of "
             + curMemory.getComponentInstancePath());
   }
 }
  /**
   * check the load from components bound to the given processor The components can be threads or
   * higher level components.
   *
   * @param curProcessor Component Instance of processor
   */
  protected void checkProcessorLoad(ComponentInstance curProcessor, final SystemOperationMode som) {
    boolean isCPUActive;

    if (curProcessor.getSubcomponent().getAllInModes().size() == 0) {
      isCPUActive = true;
    } else {
      isCPUActive = false;

      for (Mode mi : curProcessor.getSubcomponent().getAllInModes()) {
        // OsateDebug.osateDebug("somName=" + somName + " mi=" + mi);
        if (som.getName().equalsIgnoreCase(mi.getName())) {
          //	OsateDebug.osateDebug("cpu " + curProcessor.getName() +  "is active for mode" +
          // somName);
          isCPUActive = true;
        }
      }
    }

    if (isCPUActive == false) {
      return;
    }

    UnitLiteral mipsliteral = GetProperties.getMIPSUnitLiteral(curProcessor);
    double MIPScapacity = GetProperties.getMIPSCapacityInMIPS(curProcessor, 0.0);
    if (MIPScapacity == 0 && InstanceModelUtil.isVirtualProcessor(curProcessor)) {
      MIPScapacity = GetProperties.getMIPSBudgetInMIPS(curProcessor);
    }
    long timeBefore = System.currentTimeMillis();
    OsateDebug.osateDebug(
        "[CPU] before get sw comps (CPU="
            + curProcessor.getName()
            + ",cat="
            + curProcessor.getComponentClassifier().getCategory().getName()
            + ")");
    EList<ComponentInstance> boundComponents = InstanceModelUtil.getBoundSWComponents(curProcessor);
    long timeAfter = System.currentTimeMillis();
    long period = timeAfter - timeBefore;
    OsateDebug.osateDebug("[CPU] after get sw comps, time taken=" + period + "ms");

    if (boundComponents.size() == 0 && MIPScapacity > 0) {
      errManager.infoSummary(
          curProcessor,
          som.getName(),
          "No application components bound to "
              + curProcessor.getComponentInstancePath()
              + " with MIPS capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral));
      return;
    }
    if (MIPScapacity == 0 && InstanceModelUtil.isVirtualProcessor(curProcessor)) {
      errManager.warningSummary(
          curProcessor,
          som.getName(),
          "Virtual processor "
              + curProcessor.getComponentInstancePath()
              + " has no MIPS capacity or budget.");
      return;
    }
    if (MIPScapacity == 0 && InstanceModelUtil.isProcessor(curProcessor)) {
      errManager.errorSummary(
          curProcessor,
          som.getName(),
          "Processor "
              + curProcessor.getComponentInstancePath()
              + " has no MIPS capacity but has bound components.");
    }
    if (InstanceModelUtil.isVirtualProcessor(curProcessor)) {
      logHeader(
          "\n\nDetailed Workload Report for Virtual Processor "
              + curProcessor.getComponentInstancePath()
              + " with Capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + "\n\nComponent,Budget,Actual");
    } else {
      logHeader(
          "\n\nDetailed Workload Report for Processor "
              + curProcessor.getComponentInstancePath()
              + " with Capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + "\n\nComponent,Budget,Actual");
    }
    double totalMIPS = 0.0;
    for (Iterator<ComponentInstance> it = boundComponents.iterator(); it.hasNext(); ) {
      ComponentInstance bci = (ComponentInstance) it.next();
      boolean isComponentActive;

      if ((som == null) || (bci.getSubcomponent().getAllInModes().size() == 0)) {
        isComponentActive = true;
      } else {
        isComponentActive = false;
        for (Mode mi : bci.getSubcomponent().getAllInModes()) {
          // OsateDebug.osateDebug("somName=" + somName + " mi=" + mi);
          if (som.getName().equalsIgnoreCase(mi.getName())) {
            //	OsateDebug.osateDebug("cpu " + curProcessor.getName() +  "is active for mode" +
            // somName);
            isComponentActive = true;
          }
        }
      }

      if (isComponentActive == true) {
        double actualmips = sumBudgets(bci, ResourceKind.MIPS, mipsliteral, true, som, "");
        totalMIPS += actualmips;
      }
    }
    logHeader("Total," + GetProperties.toStringScaled(totalMIPS, mipsliteral));
    if (totalMIPS > MIPScapacity) {
      errManager.errorSummary(
          curProcessor,
          som.getName(),
          "Total MIPS "
              + GetProperties.toStringScaled(totalMIPS, mipsliteral)
              + " of bound tasks exceeds MIPS capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + " of "
              + curProcessor.getComponentInstancePath());
    } else if (totalMIPS == 0.0) {
      errManager.warningSummary(curProcessor, som.getName(), "Bound app's have no MIPS budget.");
    } else {
      errManager.infoSummary(
          curProcessor,
          som.getName(),
          "Total MIPS "
              + GetProperties.toStringScaled(totalMIPS, mipsliteral)
              + " of bound tasks within "
              + "MIPS capacity "
              + GetProperties.toStringScaled(MIPScapacity, mipsliteral)
              + " of "
              + curProcessor.getComponentInstancePath());
    }
  }