/******************************************************************************* | |
* Copyright (C) 2020 | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License v2.0 | |
* which accompanies this distribution, and is available at | |
* http://www.eclipse.org/legal/epl-v20.html | |
******************************************************************************/ | |
/*------------------------------------------------------------------------------ | |
- | |
- Copyright (c) 2015-2016 University of Padova, ITALY - Intecs SpA | |
- All rights reserved. This program and the accompanying materials | |
- are made available under the terms of the Eclipse Public License v2.0 | |
- which accompanies this distribution, and is available at | |
- http://www.eclipse.org/legal/epl-v20.html | |
- | |
- Contributors: | |
- | |
- Alessandro Zovi azovi@math.unipd.it | |
- Stefano Puri stefano.puri@intecs.it | |
- Laura Baracchi laura.baracchi@intecs.it | |
- Nicholas Pacini nicholas.pacini@intecs.it | |
- | |
- Initial API and implementation and/or initial documentation | |
------------------------------------------------------------------------------*/package org.polarsys.chess.multicore.utils; | |
import java.util.ArrayList; | |
import java.util.HashMap; | |
import java.util.HashSet; | |
import java.util.LinkedHashSet; | |
import java.util.LinkedList; | |
import java.util.List; | |
import java.util.Map; | |
import java.util.Set; | |
import javax.crypto.spec.OAEPParameterSpec; | |
import org.eclipse.emf.common.command.CommandStack; | |
import org.eclipse.emf.common.util.BasicEList; | |
import org.eclipse.emf.common.util.EList; | |
import org.eclipse.emf.common.util.Enumerator; | |
import org.eclipse.emf.ecore.EObject; | |
import org.eclipse.emf.transaction.TransactionalEditingDomain; | |
import org.eclipse.emf.transaction.util.TransactionUtil; | |
import org.eclipse.papyrus.MARTE.MARTE_DesignModel.HLAM.CallConcurrencyKind; | |
import org.eclipse.papyrus.MARTE.MARTE_DesignModel.HRM.HwLogical.HwDevice.HwDevice; | |
import org.eclipse.papyrus.MARTE.MARTE_Foundations.Alloc.Assign; | |
import org.eclipse.papyrus.MARTE.MARTE_Foundations.NFPs.NfpConstraint; | |
import org.eclipse.papyrus.uml.tools.model.UmlModel; | |
import org.eclipse.uml2.uml.Activity; | |
import org.eclipse.uml2.uml.ActivityNode; | |
import org.eclipse.uml2.uml.CallOperationAction; | |
import org.eclipse.uml2.uml.Classifier; | |
import org.eclipse.uml2.uml.Comment; | |
import org.eclipse.uml2.uml.Component; | |
import org.eclipse.uml2.uml.Constraint; | |
import org.eclipse.uml2.uml.Element; | |
import org.eclipse.uml2.uml.InstanceSpecification; | |
import org.eclipse.uml2.uml.LiteralString; | |
import org.eclipse.uml2.uml.Model; | |
import org.eclipse.uml2.uml.NamedElement; | |
import org.eclipse.uml2.uml.Package; | |
import org.eclipse.uml2.uml.Slot; | |
import org.eclipse.uml2.uml.Stereotype; | |
import org.eclipse.uml2.uml.UMLPackage; | |
import org.eclipse.uml2.uml.ValueSpecification; | |
import org.polarsys.chess.chessmlprofile.ComponentModel.ComponentImplementation; | |
import org.polarsys.chess.chessmlprofile.ComponentModel.FunctionalPartition; | |
import org.polarsys.chess.chessmlprofile.Core.CHESS; | |
import org.polarsys.chess.chessmlprofile.Core.CHGaResourcePlatform; | |
import org.polarsys.chess.chessmlprofile.Core.FunctionalPartitions; | |
import org.polarsys.chess.chessmlprofile.Predictability.DeploymentConfiguration.HardwareBaseline.CH_HwProcessor; | |
import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtPortSlot; | |
import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtSpecification; | |
import org.polarsys.chess.chessmlprofile.util.Constants; | |
import org.polarsys.chess.core.profiles.CHESSProfileManager; | |
import org.polarsys.chess.core.util.uml.ModelError; | |
import org.polarsys.chess.core.util.uml.UMLUtils; | |
import org.polarsys.chess.multicore.model.CHCore; | |
import org.polarsys.chess.multicore.model.CHTask; | |
import org.polarsys.chess.validator.constraints.StringParser; | |
/** | |
* The Class QueryUtils. | |
*/ | |
public class QueryUtils { | |
/** | |
* The Class OccKindInfo. | |
*/ | |
public static class OccKindInfo { | |
/** The value. */ | |
public double value; | |
/** The type. */ | |
public String type; | |
/** The unit. */ | |
public String unit; | |
} | |
/** The Constant MARTE_ASSIGN. */ | |
private static final String MARTE_ASSIGN = "MARTE::MARTE_Foundations::Alloc::Assign"; | |
/** The Constant MARTE_NFPCONSTRAINT. */ | |
private static final String MARTE_NFPCONSTRAINT = "MARTE::MARTE_Foundations::NFPs::NfpConstraint"; | |
/** The Constant COMPONENT_TO_PARTITION. */ | |
public static final int COMPONENT_TO_PARTITION = 0; | |
/** The Constant PARTITION_TO_CORE. */ | |
public static final int PARTITION_TO_CORE = 1; | |
/** The Constant COMPONENT_TO_CORE. */ | |
public static final int COMPONENT_TO_CORE = 2; | |
/** The Constant TASK_TO_CORE. */ | |
public static final int TASK_TO_CORE = 3; | |
/** | |
* Gets the chess. | |
* | |
* @param umlModel the uml model | |
* @return the chess | |
*/ | |
public static CHESS getCHESS(Model umlModel) { | |
return UMLUtils.getStereotypeApplication(umlModel, CHESS.class); | |
} | |
/** | |
* Gets the command stack. | |
* | |
* @param umlModel the uml model | |
* @return the command stack | |
*/ | |
public static CommandStack getCommandStack(Model umlModel) { | |
TransactionalEditingDomain editingDomain = TransactionUtil.getEditingDomain(umlModel); | |
return editingDomain.getCommandStack(); | |
} | |
/** | |
* returns the component which owns the assigns from components to partitions. | |
* | |
* @param umlModel the uml model | |
* @return the partitions component | |
* @throws ModelError the model error | |
* @deprecated PartitionsComponent stereotype is deprecated | |
*/ | |
public static Component getPartitionsComponent(Model umlModel) throws ModelError { | |
// assumption: assigns are stored in the root SW system i.e. the one | |
// stereotyped with CHGaResourcePlatform | |
CHESS chess = getCHESS(umlModel); | |
Package componentViewP = chess.getComponentView().getBase_Package(); | |
for (Element el : componentViewP.allOwnedElements()) { | |
if (el instanceof Component) { | |
Component c = (Component) el; | |
// LB 20150707 Next line to be reviewed based on considerations about | |
// partitions' component | |
boolean b = c.getName().equalsIgnoreCase("Partitions"); | |
b = b || UMLUtils.getStereotypeApplication(el, FunctionalPartitions.class) != null; | |
if (b) | |
return c; | |
} | |
} | |
throw new ModelError("Partitions component not found."); | |
} | |
/** | |
* Given a Partition returns the list of Components that are assigned to it. | |
* | |
* @param partition the partition | |
* @param assignments the assignments | |
* @return the components assigned 2 partition | |
*/ | |
public static LinkedHashSet<Object> getComponentsAssigned2Partition(InstanceSpecification partition, EList<Assign> assignments) { | |
LinkedHashSet<Object> result = new LinkedHashSet<Object>(); | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
if (theAssignment.getTo().contains((Object) partition) && (elementIsComponentInstance(theAssignment.getFrom().get(0)))) { | |
result.add(theAssignment.getFrom().get(0)); | |
} | |
} catch (Exception e) { | |
// do nothing | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Deletes all the associations of the given type. | |
* | |
* @param parent the parent | |
* @param associationType (PARTITION_TO_CORE | COMPONENT_TO_CORE | TASK_TO_CORE | COMPONENT_TO_PARTITION | |
*/ | |
public static void deleteAssociations(Component parent, int associationType) { | |
for (Object el : parent.getOwnedComments().toArray()) { | |
if (el instanceof Comment) { | |
Comment assignComment = (Comment) el; | |
Assign assign = UMLUtils.getStereotypeApplication(assignComment, Assign.class); | |
// Only delete one kind of associations | |
try { | |
if ((assign != null && associationType == PARTITION_TO_CORE && (elementIsPartitionInstance(assign.getFrom().get(0)))) | |
|| (assign != null && associationType == COMPONENT_TO_CORE && (elementIsComponentInstance(assign.getFrom().get(0))) && (elementIsProcessorInstance(assign.getTo().get(0)))) | |
|| (assign != null && associationType == TASK_TO_CORE && (elementIsSlotInstance(assign.getFrom().get(0))) && (elementIsProcessorInstance(assign.getTo().get(0)))) | |
|| (assign != null && associationType == COMPONENT_TO_PARTITION && (elementIsComponentInstance(assign.getFrom().get(0))) && (elementIsPartitionInstance(assign.getTo().get(0))))) { | |
if (assign != null && assign.getImpliedConstraint().size() > 0) { | |
for (Object c : assign.getImpliedConstraint().toArray()) { | |
if (c instanceof NfpConstraint) { | |
NfpConstraint n = (NfpConstraint) c; | |
n.getBase_Constraint().destroy(); | |
} | |
} | |
} | |
assignComment.destroy(); | |
} | |
} catch (Exception e) { | |
// 20160225 Always delete assignments where one end is null! | |
assignComment.destroy(); | |
} | |
} | |
} | |
// for (Object el : parent.getOwnedRules().toArray()) { | |
// if (el instanceof Constraint) { | |
// Constraint assignComment = (Constraint) el; | |
// assignComment.destroy(); | |
// } | |
// } | |
} | |
/** | |
* Returns the CHTask associated to the given element (if this is a CHRTPortSlot). | |
* | |
* @param element the element | |
* @return task that corresponds to the input slot, if any | |
*/ | |
public static CHTask getTaskFromSlot(Element element) { | |
if (!(element instanceof Slot)) { | |
return null; | |
} | |
Slot slot = (Slot) element; | |
CHRtPortSlot chSlot = UMLUtils.getStereotypeApplication(slot, CHRtPortSlot.class); | |
if (chSlot == null) { | |
return null; | |
} | |
EList<CHRtSpecification> chSpecs = chSlot.getCH_RtSpecification(); | |
for (CHRtSpecification chRtSpecification : chSpecs) { | |
String occKind = chRtSpecification.getOccKind(); | |
if (occKind != null && isOccKindSporadicOrPeriodic(occKind)) { | |
return new CHTask(chSlot, chRtSpecification); | |
} | |
} | |
return null; | |
} | |
/** | |
* Returns all the CHTasks associated to the given element (if this is a CHRTPortSlot). | |
* | |
* @param element the element | |
* @return task that corresponds to the input slot, if any | |
*/ | |
private static EList<CHTask> getAllTasksFromSlot(Element element) { | |
EList<CHTask> chTaskList = new BasicEList<CHTask>(); | |
if (!(element instanceof Slot)) { | |
return chTaskList; | |
} | |
Slot slot = (Slot) element; | |
CHRtPortSlot chSlot = UMLUtils.getStereotypeApplication(slot, CHRtPortSlot.class); | |
if (chSlot == null) { | |
return chTaskList; | |
} | |
EList<CHRtSpecification> chSpecs = chSlot.getCH_RtSpecification(); | |
for (CHRtSpecification chRtSpecification : chSpecs) { | |
String occKind = chRtSpecification.getOccKind(); | |
if (occKind != null && isOccKindSporadicOrPeriodic(occKind)) { | |
chTaskList.add(new CHTask(chSlot, chRtSpecification)); | |
// return new CHTask(chSlot, chRtSpecification); | |
} | |
} | |
return chTaskList; | |
} | |
/** | |
* Element is slot instance. | |
* | |
* @param element the element | |
* @return true, if successful | |
*/ | |
public static boolean elementIsSlotInstance(Element element) { | |
return element instanceof Slot; | |
} | |
/** | |
* Given a component, create all the Component to Partition Assignments. | |
* | |
* @param parent the parent | |
* @param result the result | |
*/ | |
public static void buildComponent2PartitionAssignment(Component parent, Map<InstanceSpecification, LinkedHashSet<Object>> result) { | |
System.out.println(parent.getQualifiedName()); | |
for (InstanceSpecification partitionInst : result.keySet()) { | |
System.out.println(partitionInst.getName()); | |
for (Object o : result.get(partitionInst)) { | |
if (o instanceof InstanceSpecification) { | |
InstanceSpecification componentInst = (InstanceSpecification) o; | |
System.out.println(componentInst.getName()); | |
Comment c = parent.createOwnedComment(); | |
UMLUtils.applyStereotype(c, MARTE_ASSIGN); | |
Assign assign = UMLUtils.getStereotypeApplication(c, Assign.class); | |
assign.getFrom().add(componentInst); | |
assign.getTo().add(partitionInst); | |
} | |
} | |
} | |
} | |
/** | |
* Builds the core name. | |
* | |
* @param coreNumber the core number | |
* @return the string | |
*/ | |
public static String buildCoreName(int coreNumber) { | |
/* coreNumber starts from 0 */ | |
return "core" + coreNumber; | |
} | |
/** | |
* Create all the Partition to Core Assignments. | |
* | |
* @param parent the parent | |
* @param result the result | |
*/ | |
public static void buildPartition2CoreAssignments(Component parent, Map<CHCore, LinkedHashSet<Object>> result) { | |
for (CHCore core : result.keySet()) { | |
for (Object o : result.get(core)) { | |
if (o instanceof InstanceSpecification) { | |
InstanceSpecification partitionInst = (InstanceSpecification) o; | |
Comment c = parent.createOwnedComment(); | |
UMLUtils.applyStereotype(c, MARTE_ASSIGN); | |
Assign assign = UMLUtils.getStereotypeApplication(c, Assign.class); | |
assign.getFrom().add(partitionInst); | |
assign.getTo().add(core.getProcessorInstance()); | |
Constraint n = parent.createOwnedRule(core.getName()); | |
UMLUtils.applyStereotype(n, MARTE_NFPCONSTRAINT); | |
NfpConstraint rule = UMLUtils.getStereotypeApplication(n, NfpConstraint.class); | |
ValueSpecification valueSpec = n.createSpecification("core", null, UMLPackage.Literals.LITERAL_STRING); | |
LiteralString value = (LiteralString) valueSpec; | |
value.setValue(core.getName()); | |
assign.getImpliedConstraint().add(rule); | |
} | |
} | |
} | |
} | |
/** | |
* Returns the first CHGaResourcePlatform that is found inside the given package. | |
* | |
* @param cmpv the cmpv | |
* @return the one resource platform package | |
*/ | |
public static Package getOneResourcePlatformPackage(Package cmpv) { | |
/* breath-first search */ | |
final LinkedList<Package> breadthFirstList = new LinkedList<Package>(); | |
breadthFirstList.addFirst(cmpv); | |
while (!breadthFirstList.isEmpty()) { | |
final Package candidate = breadthFirstList.poll(); | |
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(candidate, CHGaResourcePlatform.class); | |
if (a != null) | |
return candidate; | |
for (final Package p : candidate.getNestedPackages()) { | |
breadthFirstList.addLast(p); | |
} | |
} | |
return null; | |
} | |
/** | |
* Gets the resource platform package. | |
* | |
* @param cmpv the cmpv | |
* @return the resource platform package | |
* @deprecated This method returns only one platform package. In the newer | |
* version of CHESS there can be multiple platform packages. | |
* Replace with getResourcePlatformPackages | |
*/ | |
@Deprecated | |
public static Package getResourcePlatformPackage(Package cmpv) { | |
/* breath-first search */ | |
final LinkedList<Package> breadthFirstList = new LinkedList<Package>(); | |
breadthFirstList.addFirst(cmpv); | |
while (!breadthFirstList.isEmpty()) { | |
final Package candidate = breadthFirstList.poll(); | |
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(candidate, CHGaResourcePlatform.class); | |
if (a != null) | |
return candidate; | |
for (final Package p : candidate.getNestedPackages()) { | |
breadthFirstList.addLast(p); | |
} | |
} | |
return null; | |
} | |
/** | |
* Returns the list of CHGaResourcePlatforms found inside the view with the given name in the given model. | |
* | |
* @param umlModel the uml model | |
* @param viewName the view name | |
* @return the resource platform packages | |
* @throws ModelError the model error | |
*/ | |
public static EList<Package> getResourcePlatformPackages(Model umlModel, String viewName) throws ModelError { | |
Package pack = CHESSProfileManager.getViewByStereotype((Model) umlModel, viewName); | |
if (pack == null) | |
throw new ModelError(viewName + " not found."); | |
// Package cmpv | |
/* breath-first search */ | |
EList<Package> result = new BasicEList<Package>(); | |
final LinkedList<Package> breadthFirstList = new LinkedList<Package>(); | |
breadthFirstList.addFirst(pack); | |
while (!breadthFirstList.isEmpty()) { | |
final Package candidate = breadthFirstList.poll(); | |
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(candidate, CHGaResourcePlatform.class); | |
if (a != null) | |
result.add(candidate); | |
// return candidate; | |
for (final Package p : candidate.getNestedPackages()) { | |
breadthFirstList.addLast(p); | |
} | |
} | |
return result; | |
// return null; | |
} | |
/** | |
* Returns the list of CHGaResourcePlatforms found inside the given Package. | |
* | |
* @param cmpv is the given package | |
* @return the resource platform packages | |
*/ | |
public static List<Package> getResourcePlatformPackages(Package cmpv) { | |
List<Package> candidates = new ArrayList<Package>(); | |
/* breath-first search */ | |
final LinkedList<Package> breadthFirstList = new LinkedList<Package>(); | |
breadthFirstList.addFirst(cmpv); | |
while (!breadthFirstList.isEmpty()) { | |
final Package candidate = breadthFirstList.poll(); | |
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(candidate, CHGaResourcePlatform.class); | |
if (a != null) | |
candidates.add(candidate); | |
for (final Package p : candidate.getNestedPackages()) { | |
breadthFirstList.addLast(p); | |
} | |
} | |
return candidates; | |
} | |
/** | |
* Returns a Component that is stereotyped as CHGaResourcePlatform inside the view with the given name | |
* in the given model. | |
* | |
* @param umlModel the uml model | |
* @param viewName the view name | |
* @return the resource platform component | |
* @throws ModelError the model error | |
*/ | |
public static Component getResourcePlatformComponent(Model umlModel, String viewName) throws ModelError { | |
Package parent = CHESSProfileManager.getViewByStereotype(umlModel, viewName); | |
if (parent == null) | |
throw new ModelError(viewName + " not found."); | |
/* breath-first search */ | |
final LinkedList<Element> breadthFirstList = new LinkedList<Element>(); | |
breadthFirstList.addAll(parent.getOwnedElements()); | |
while (!breadthFirstList.isEmpty()) { | |
final Element t = breadthFirstList.poll(); | |
if (t instanceof Component) { | |
Component candidate = (Component) t; | |
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(candidate, CHGaResourcePlatform.class); | |
if (a != null) | |
return candidate; | |
} | |
for (final Element e : t.getOwnedElements()) { | |
breadthFirstList.addLast(e); | |
} | |
} | |
throw new ModelError("CHGaResourcePlatform not found in " + viewName + " view."); | |
} | |
/** | |
* Returns true if the given InstanceSpecification is a functional Partition, false otherwise. | |
* | |
* @param e the e | |
* @return true, if is partition instance | |
*/ | |
public static boolean isPartitionInstance(InstanceSpecification e) { | |
for (Classifier c : e.getClassifiers()) { | |
if (UMLUtils.getStereotypeApplication(c, FunctionalPartition.class) != null) | |
return true; | |
} | |
return false; | |
} | |
/** | |
* Returns true if the given InstanceSpecification is a ComponentImplementation, false otherwise. | |
* | |
* @param e the e | |
* @return true, if is component instance | |
*/ | |
public static boolean isComponentInstance(InstanceSpecification e) { | |
for (Classifier c : e.getClassifiers()) { | |
if (UMLUtils.getStereotypeApplication(c, ComponentImplementation.class) != null) | |
return true; | |
} | |
return false; | |
} | |
/** | |
* Checks if is guarded. | |
* | |
* @param spec the spec | |
* @return true, if is guarded | |
*/ | |
public static boolean isGuarded(CHRtSpecification spec) { | |
return spec.getProtection().getName().equals(CallConcurrencyKind.GUARDED.getName()); | |
} | |
/** | |
* Checks if is occ kind sporadic or periodic. | |
* | |
* @param occKind the occ kind | |
* @return true, if is occ kind sporadic or periodic | |
*/ | |
public static boolean isOccKindSporadicOrPeriodic(String occKind) { | |
if (occKind == null) | |
return false; | |
return isOccKindSporadic(occKind) || isOccKindPeriodic(occKind); | |
} | |
/** | |
* Checks if is occ kind sporadic. | |
* | |
* @param occKind the occ kind | |
* @return true, if is occ kind sporadic | |
*/ | |
public static boolean isOccKindSporadic(String occKind) { | |
String t = occKind.toLowerCase(); | |
return t.matches(".*sporadic.*"); | |
} | |
/** | |
* Checks if is occ kind periodic. | |
* | |
* @param occKind the occ kind | |
* @return true, if is occ kind periodic | |
*/ | |
public static boolean isOccKindPeriodic(String occKind) { | |
String t = occKind.toLowerCase(); | |
return t.matches(".*periodic.*"); | |
} | |
/** | |
* Returns the OccKindInfo that correspomnds to the input string. | |
* | |
* @param occKind the String with the occurrency kind information | |
* @return OccKindInfo | |
*/ | |
public static OccKindInfo getOccKindInfo(String occKind) { | |
StringParser sp = new StringParser(); | |
OccKindInfo info = new OccKindInfo(); | |
if (isOccKindSporadic(occKind)) { | |
info.value = sp.getValuePattern(occKind, "minInterarrival"); | |
info.type = "sporadic"; | |
info.unit = sp.getUnitPattern(occKind, "minInterarrival"); | |
} else if (occKind.toLowerCase().matches(".*periodic.*")) { | |
info.value = sp.getValuePattern(occKind, "period"); | |
info.unit = sp.getUnitPattern(occKind, "period"); | |
info.type = "periodic"; | |
} else { | |
return null; | |
} | |
return info; | |
} | |
/** | |
* Returns a map with the Component to Partition assignments. | |
* | |
* @param umlModel the uml model | |
* @param parent the parent | |
* @return the map | |
* @throws ModelError the model error | |
*/ | |
public static Map<InstanceSpecification, Set<CHRtSpecification>> buildPartitionComponentMap(Model umlModel, Package parent) throws ModelError { | |
Map<InstanceSpecification, Set<CHRtSpecification>> map = new HashMap<InstanceSpecification, Set<CHRtSpecification>>(); | |
EList<Assign> assignmentList = UMLUtils.getComponent2PartitionAssignments(umlModel, CHESSProfileManager.COMPONENT_VIEW); | |
if (!assignmentList.isEmpty()) { | |
for (Assign assign : assignmentList) { | |
if (assign == null) | |
continue; | |
for (Element i : assign.getFrom()) { | |
if (i instanceof InstanceSpecification) { | |
InstanceSpecification ii = (InstanceSpecification) i; | |
processComponentInstance(map, assign, ii); | |
} | |
} | |
} | |
} | |
return map; | |
} | |
/** | |
* Returns a map with the Partition to Core assignments. | |
* | |
* @param umlModel the uml model | |
* @return the map | |
* @throws ModelError the model error | |
*/ | |
public static Map<String, Set<InstanceSpecification>> buildPartitionCoreMap(Model umlModel) throws ModelError { | |
Map<String, Set<InstanceSpecification>> map = new HashMap<String, Set<InstanceSpecification>>(); | |
EList<Assign> assignmentList = UMLUtils.getPartition2CoreAssignments(umlModel, CHESSProfileManager.DEPLOYMENT_VIEW); | |
if (!assignmentList.isEmpty()) { | |
for (Assign assign : assignmentList) { | |
for (Element i : assign.getFrom()) { | |
if (i instanceof InstanceSpecification) { | |
processPartitionInstance(map, assign); | |
} | |
} | |
} | |
} | |
return map; | |
} | |
// public static Map<InstanceSpecification, Set<CHRtSpecification>> | |
// buildPartitionComponentMap(Component parent) { | |
// Map<InstanceSpecification, Set<CHRtSpecification>> map = new | |
// HashMap<InstanceSpecification, Set<CHRtSpecification>>(); | |
// for (Comment el : parent.getOwnedComments()) { | |
// | |
// Comment assignComment = (Comment) el; | |
// Assign assign = UMLUtils.getStereotypeApplication(assignComment, | |
// Assign.class); | |
// if (assign == null) | |
// continue; | |
// for (Element i : assign.getFrom()) { | |
// if (i instanceof InstanceSpecification) { | |
// InstanceSpecification ii = (InstanceSpecification) i; | |
// processComponentInstance(map, assign, ii); | |
// } | |
// } | |
// | |
// } | |
// return map; | |
// } | |
/** | |
* Process partition instance. | |
* | |
* @param map the map | |
* @param assign the assign | |
*/ | |
private static void processPartitionInstance(Map<String, Set<InstanceSpecification>> map, Assign assign) { | |
try { | |
if (assign.getImpliedConstraint().size() > 0) { | |
for (Object c : assign.getImpliedConstraint().toArray()) { | |
if (c instanceof NfpConstraint) { | |
ValueSpecification x = ((NfpConstraint) c).getBase_Constraint().getSpecification(); | |
if (x instanceof LiteralString) { | |
LiteralString s = (LiteralString) x; | |
String coreName = ((NamedElement) assign.getTo().get(0)).getName() + s.getValue(); | |
InstanceSpecification part = (InstanceSpecification) assign.getFrom().get(0); | |
Set<InstanceSpecification> value = map.get(coreName); | |
if (value == null) | |
value = new HashSet<InstanceSpecification>(); | |
value.add(part); | |
map.put(coreName, value); | |
} | |
} | |
} | |
} | |
} catch (Exception e) { | |
// TODO Auto-generated catch block | |
e.printStackTrace(); | |
} | |
} | |
/** | |
* Process component instance. | |
* | |
* @param map the map | |
* @param assign the assign | |
* @param instanceSpec the instance spec | |
*/ | |
private static void processComponentInstance(Map<InstanceSpecification, Set<CHRtSpecification>> map, Assign assign, InstanceSpecification instanceSpec) { | |
for (Element element : instanceSpec.getOwnedElements()) { | |
if (element instanceof Slot) { | |
Slot slot = (Slot) element; | |
CHRtPortSlot chSlot = UMLUtils.getStereotypeApplication(slot, CHRtPortSlot.class); | |
if (chSlot != null) { | |
EList<CHRtSpecification> chSpecs = chSlot.getCH_RtSpecification(); | |
addToMap(map, assign.getTo(), chSpecs); | |
} | |
} | |
} | |
} | |
/** | |
* Adds the to map. | |
* | |
* @param map the map | |
* @param to the to | |
* @param chSpecs the ch specs | |
*/ | |
/* add only periodic or sporadic components */ | |
private static void addToMap(Map<InstanceSpecification, Set<CHRtSpecification>> map, EList<Element> to, EList<CHRtSpecification> chSpecs) { | |
for (Element partition : to) { | |
if (partition instanceof InstanceSpecification) { | |
InstanceSpecification p = (InstanceSpecification) partition; | |
for (CHRtSpecification chRtSpecification : chSpecs) { | |
String occKind = chRtSpecification.getOccKind(); | |
if (occKind != null) { | |
if (isOccKindSporadicOrPeriodic(occKind)) { | |
addToMap(map, p, chRtSpecification); | |
} | |
} | |
} | |
} | |
} | |
} | |
/** | |
* Adds the to map. | |
* | |
* @param map the map | |
* @param p the p | |
* @param chRtSpecification the ch rt specification | |
*/ | |
private static void addToMap(Map<InstanceSpecification, Set<CHRtSpecification>> map, InstanceSpecification p, CHRtSpecification chRtSpecification) { | |
Set<CHRtSpecification> value = map.get(p); | |
if (value == null) | |
value = new HashSet<CHRtSpecification>(); | |
value.add(chRtSpecification); | |
map.put(p, value); | |
} | |
/** | |
* Returns true if the given InstanceSpecification is sterotyped as CH_HwProcessor. | |
* | |
* @param e the e | |
* @return true, if is processor instance | |
*/ | |
public static boolean isProcessorInstance(InstanceSpecification e) { | |
for (Classifier c : e.getClassifiers()) { | |
if (UMLUtils.getStereotypeApplication(c, CH_HwProcessor.class) != null) | |
return true; | |
} | |
return false; | |
} | |
/** | |
* check if an instance specification is an instance of a MARTE Device. | |
* | |
* @param instSpec the inst spec | |
* @return true if the input is an instance of a MARTE Device, false | |
* otherwise. | |
*/ | |
public static boolean isDeviceInstance(InstanceSpecification instSpec) { | |
Classifier classifier = instSpec.getClassifiers().get(0); | |
EList<Stereotype> stereotypeList = classifier.getAppliedStereotypes(); | |
for (Stereotype theStereo : stereotypeList) { | |
EObject object = classifier.getStereotypeApplication(theStereo); | |
if (object instanceof HwDevice) { | |
return true; | |
} | |
} | |
return false; | |
} | |
/** | |
* Gets the one processor. | |
* | |
* @param umlModel the uml model | |
* @return the one processor | |
*/ | |
public static CH_HwProcessor getOneProcessor(Model umlModel) { | |
Package depv = CHESSProfileManager.getViewByStereotype((Model) umlModel, CHESSProfileManager.DEPLOYMENT_VIEW); | |
depv = QueryUtils.getOneResourcePlatformPackage(depv); | |
if (depv != null) { | |
EList<Element> all = depv.allOwnedElements(); | |
for (Element element : all) { | |
if (element instanceof InstanceSpecification) { | |
InstanceSpecification e = (InstanceSpecification) element; | |
if (e.getQualifiedName() != null && QueryUtils.isProcessorInstance(e)) { | |
CH_HwProcessor t = UMLUtils.getStereotypeApplication(e, CH_HwProcessor.class); | |
return t; | |
} | |
} | |
} | |
} | |
return null; | |
} | |
/** | |
* Gets the all processor instances. | |
* | |
* @param umlModel the uml model | |
* @return the all processor instances | |
* @throws ModelError the model error | |
*/ | |
public static EList<CH_HwProcessor> getAllProcessorInstances(Model umlModel) throws ModelError { | |
EList<CH_HwProcessor> processors = new BasicEList<CH_HwProcessor>(); | |
Package depv = CHESSProfileManager.getViewByStereotype((Model) umlModel, CHESSProfileManager.DEPLOYMENT_VIEW); | |
if (depv == null) | |
throw new ModelError("Deployment view not found."); | |
List<Package> platformPackages = QueryUtils.getResourcePlatformPackages(depv); | |
if (platformPackages.isEmpty()) | |
throw new ModelError("CHGaResourcePlatform not found in Deployment view."); | |
for (Package pp : platformPackages) { | |
EList<Element> all = pp.allOwnedElements(); | |
for (Element element : all) { | |
if (element instanceof InstanceSpecification) { | |
InstanceSpecification e = (InstanceSpecification) element; | |
if (e.getQualifiedName() != null && QueryUtils.isProcessorInstance(e)) { | |
CH_HwProcessor t = UMLUtils.getStereotypeApplication(e, CH_HwProcessor.class); | |
processors.add(t); | |
} | |
} | |
} | |
} | |
if (processors.size() == 0) | |
throw new ModelError("Processors not found."); | |
return processors; | |
} | |
/** | |
* Gets the all processor instances in package. | |
* | |
* @param thePackage the the package | |
* @return the all processor instances in package | |
* @throws ModelError the model error | |
*/ | |
public static EList<CH_HwProcessor> getAllProcessorInstancesInPackage(Package thePackage) throws ModelError { | |
EList<CH_HwProcessor> processors = new BasicEList<CH_HwProcessor>(); | |
EList<Element> all = thePackage.allOwnedElements(); | |
for (Element element : all) { | |
if (element instanceof InstanceSpecification) { | |
InstanceSpecification e = (InstanceSpecification) element; | |
if (e.getQualifiedName() != null && QueryUtils.isProcessorInstance(e)) { | |
CH_HwProcessor t = UMLUtils.getStereotypeApplication(e, CH_HwProcessor.class); | |
processors.add(t); | |
} | |
} | |
} | |
if (processors.size() == 0) | |
throw new ModelError("Processors not found."); | |
return processors; | |
} | |
/** | |
* Filter multi core processors. | |
* | |
* @param processors the processors | |
* @return the e list | |
*/ | |
public static EList<CH_HwProcessor> filterMultiCoreProcessors(EList<CH_HwProcessor> processors) { | |
EList<CH_HwProcessor> candidates = new BasicEList<CH_HwProcessor>(); | |
for (CH_HwProcessor processor : processors) { | |
if (getCores(processor).size() > 1) | |
candidates.add(processor); | |
} | |
return candidates; | |
} | |
/** | |
* Gets the cores. | |
* | |
* @param processor the processor | |
* @return the cores | |
*/ | |
public static EList<CHCore> getCores(CH_HwProcessor processor) { | |
InstanceSpecification processorBaseInst = processor.getBase_InstanceSpecification(); | |
Component processorComponent = (Component) processorBaseInst.getClassifiers().get(0); | |
Stereotype chHwProcessorStereo = processorComponent.getAppliedStereotype(Constants.CH_HWPROCESSOR); | |
CH_HwProcessor chHwProc = (CH_HwProcessor) processorComponent.getStereotypeApplication(chHwProcessorStereo); | |
String coreNumber = null; | |
coreNumber = chHwProc.getNbCores(); | |
int icoreNumber = 1; | |
try { | |
icoreNumber = Integer.parseInt(coreNumber); | |
} catch (Exception e) { | |
icoreNumber = 1; | |
} | |
EList<CHCore> cores = new BasicEList<CHCore>(); | |
for (int i = 0; i < icoreNumber; i++) { | |
cores.add(new CHCore(processor, QueryUtils.buildCoreName(i))); | |
} | |
return cores; | |
} | |
/** | |
* Gets the all partition instances. | |
* | |
* @param umlModel the uml model | |
* @return the all partition instances | |
* @throws ModelError the model error | |
*/ | |
public static EList<InstanceSpecification> getAllPartitionInstances(Model umlModel) throws ModelError { | |
Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel, CHESSProfileManager.COMPONENT_VIEW); | |
if (cmpv == null) | |
throw new ModelError("Component view not found."); | |
cmpv = QueryUtils.getOneResourcePlatformPackage(cmpv); | |
if (cmpv == null) | |
throw new ModelError("CHGaResourcePlatform not found in Component View."); | |
EList<Element> all = cmpv.allOwnedElements(); | |
EList<InstanceSpecification> partitions = new BasicEList<InstanceSpecification>(); | |
for (Element element : all) { | |
if (!(element instanceof InstanceSpecification)) | |
continue; | |
InstanceSpecification is = (InstanceSpecification) element; | |
if (!(is.getQualifiedName() != null && QueryUtils.isPartitionInstance(is))) | |
continue; | |
partitions.add(is); | |
} | |
if (partitions.size() == 0) | |
throw new ModelError("Partition Instances not found."); | |
return partitions; | |
} | |
/** | |
* Gets the all component instances. | |
* | |
* @param umlModel the uml model | |
* @return the all component instances | |
* @throws ModelError the model error | |
*/ | |
public static EList<InstanceSpecification> getAllComponentInstances(Model umlModel) throws ModelError { | |
Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel, CHESSProfileManager.COMPONENT_VIEW); | |
if (cmpv == null) | |
throw new ModelError("Component view not found."); | |
cmpv = QueryUtils.getOneResourcePlatformPackage(cmpv); | |
if (cmpv == null) | |
throw new ModelError("CHGaResourcePlatform not found in Component View."); | |
EList<Element> all = cmpv.allOwnedElements(); | |
EList<InstanceSpecification> components = new BasicEList<InstanceSpecification>(); | |
for (Element element : all) { | |
if (!(element instanceof InstanceSpecification)) | |
continue; | |
InstanceSpecification is = (InstanceSpecification) element; | |
if (!(is.getQualifiedName() != null && QueryUtils.isComponentInstance(is))) | |
continue; | |
components.add(is); | |
} | |
if (components.size() == 0) | |
throw new ModelError("Component Instances not found."); | |
return components; | |
} | |
/** | |
* Gets the all task instances. | |
* | |
* @param umlModel the uml model | |
* @return the all task instances | |
* @throws ModelError the model error | |
*/ | |
public static EList<CHTask> getAllTaskInstances(Model umlModel) throws ModelError { | |
EList<CHTask> tasks = new BasicEList<CHTask>(); | |
EList<InstanceSpecification> x = getAllComponentInstances(umlModel); | |
for (InstanceSpecification instanceSpecification : x) { | |
for (Element element1 : instanceSpecification.getOwnedElements()) { | |
if (!(element1 instanceof Slot)) | |
continue; | |
Slot slot = (Slot) element1; | |
CHRtPortSlot chSlot = UMLUtils.getStereotypeApplication(slot, CHRtPortSlot.class); | |
if (chSlot == null) | |
continue; | |
EList<CHRtSpecification> chSpecs = chSlot.getCH_RtSpecification(); | |
for (CHRtSpecification chRtSpecification : chSpecs) { | |
tasks.add(new CHTask(chSlot, chRtSpecification)); | |
} | |
} | |
} | |
if (tasks.size() == 0) | |
throw new ModelError("Tasks Instances not found."); | |
return tasks; | |
} | |
/** | |
* Delete task 2 core associations. | |
* | |
* @param hwSystem the hw system | |
*/ | |
public static void deleteTask2CoreAssociations(Component hwSystem) { | |
deleteAssociations(hwSystem, TASK_TO_CORE); | |
} | |
/** | |
* Delete component 2 core associations. | |
* | |
* @param hwSystem the hw system | |
*/ | |
public static void deleteComponent2CoreAssociations(Component hwSystem) { | |
deleteAssociations(hwSystem, COMPONENT_TO_CORE); | |
} | |
/** | |
* Delete partition 2 core associations. | |
* | |
* @param hwSystem the hw system | |
*/ | |
public static void deletePartition2CoreAssociations(Component hwSystem) { | |
deleteAssociations(hwSystem, PARTITION_TO_CORE); | |
} | |
/** | |
* Builds the instance 2 core assignments. | |
* | |
* @param hwSystem the hw system | |
* @param result the result | |
*/ | |
public static void buildInstance2CoreAssignments(Component hwSystem, Map<CHCore, LinkedHashSet<Object>> result) { | |
for (CHCore core : result.keySet()) { | |
for (Object o : result.get(core)) { | |
if (o instanceof InstanceSpecification) { | |
InstanceSpecification componentInst = (InstanceSpecification) o; | |
Comment c = hwSystem.createOwnedComment(); | |
UMLUtils.applyStereotype(c, MARTE_ASSIGN); | |
Assign assign = UMLUtils.getStereotypeApplication(c, Assign.class); | |
assign.getFrom().add(componentInst); | |
assign.getTo().add(core.getProcessorInstance()); | |
Constraint n = hwSystem.createOwnedRule(core.getName()); | |
UMLUtils.applyStereotype(n, MARTE_NFPCONSTRAINT); | |
NfpConstraint rule = UMLUtils.getStereotypeApplication(n, NfpConstraint.class); | |
ValueSpecification valueSpec = n.createSpecification("core", null, UMLPackage.Literals.LITERAL_STRING); | |
LiteralString value = (LiteralString) valueSpec; | |
value.setValue(core.getName()); | |
assign.getImpliedConstraint().add(rule); | |
} | |
} | |
} | |
} | |
/** | |
* Gets the CHRT spec from instances. | |
* | |
* @param instances the instances | |
* @return the CHRT spec from instances | |
*/ | |
public static Set<CHRtSpecification> getCHRTSpecFromInstances(EList<InstanceSpecification> instances) { | |
Set<CHRtSpecification> result = new HashSet<CHRtSpecification>(); | |
for (InstanceSpecification is : instances) { | |
for (Element el : is.getOwnedElements()) { | |
if (!(el instanceof Slot)) | |
continue; | |
Slot slot = (Slot) el; | |
CHRtPortSlot chSlot = UMLUtils.getStereotypeApplication(slot, CHRtPortSlot.class); | |
if (chSlot == null) | |
continue; | |
EList<CHRtSpecification> chSpecs = chSlot.getCH_RtSpecification(); | |
for (CHRtSpecification chRtSpecification : chSpecs) { | |
String occKind = chRtSpecification.getOccKind(); | |
if (occKind != null && isOccKindSporadicOrPeriodic(occKind)) { | |
result.add(chRtSpecification); | |
} | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Gets the CH tasks. | |
* | |
* @param instances the instances | |
* @return the CH tasks | |
*/ | |
public static Map<CHRtSpecification, Slot> getCHTasks(EList<InstanceSpecification> instances) { | |
Map<CHRtSpecification, Slot> result = new HashMap<CHRtSpecification, Slot>(); | |
for (InstanceSpecification is : instances) { | |
for (Element el : is.getOwnedElements()) { | |
if (!(el instanceof Slot)) | |
continue; | |
Slot slot = (Slot) el; | |
CHRtPortSlot chSlot = UMLUtils.getStereotypeApplication(slot, CHRtPortSlot.class); | |
if (chSlot == null) | |
continue; | |
EList<CHRtSpecification> chSpecs = chSlot.getCH_RtSpecification(); | |
for (CHRtSpecification chRtSpecification : chSpecs) { | |
String occKind = chRtSpecification.getOccKind(); | |
if (occKind != null) { | |
if (isOccKindSporadicOrPeriodic(occKind)) { | |
result.put(chRtSpecification, slot); | |
} | |
} | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Gets the CH tasks list. | |
* | |
* @param instances the instances | |
* @return the CH tasks list | |
*/ | |
public static EList<CHTask> getCHTasksList(EList<InstanceSpecification> instances) { | |
EList<CHTask> result = new BasicEList<CHTask>(); | |
for (InstanceSpecification is : instances) { | |
for (Element el : is.getOwnedElements()) { | |
if (!(el instanceof Slot)) | |
continue; | |
Slot slot = (Slot) el; | |
CHRtPortSlot chSlot = UMLUtils.getStereotypeApplication(slot, CHRtPortSlot.class); | |
if (chSlot == null) | |
continue; | |
EList<CHRtSpecification> chSpecs = chSlot.getCH_RtSpecification(); | |
for (CHRtSpecification chRtSpecification : chSpecs) { | |
String occKind = chRtSpecification.getOccKind(); | |
if (occKind != null && isOccKindSporadicOrPeriodic(occKind)) { | |
result.add(new CHTask(chSlot, chRtSpecification)); | |
} | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Builds the task 2 core assignments. | |
* | |
* @param hwSystem the hw system | |
* @param processor the processor | |
* @param coresToCHRtSpec the cores to CH rt spec | |
* @param mapCHRtSpecToInstances the map CH rt spec to instances | |
*/ | |
public static void buildTask2CoreAssignments(Component hwSystem, InstanceSpecification processor, Map<String, LinkedHashSet<CHRtSpecification>> coresToCHRtSpec, | |
Map<CHRtSpecification, InstanceSpecification> mapCHRtSpecToInstances) { | |
// TODO Auto-generated method stub | |
} | |
/** | |
* Gets the operation chain. | |
* | |
* @param umlModel the uml model | |
* @param chtasks the chtasks | |
* @return the operation chain | |
* @throws ModelError the model error | |
*/ | |
/* | |
* foreach deferred op get its slot in the instance package get its activity | |
* diagram if any collect the called operations get the corresponding | |
* component and so its specification | |
* | |
* this is useful to calculate the WCET of the task generated from the | |
* deferred op | |
*/ | |
public static HashMap<CHTask, EList<CHTask>> getOperationChain(Model umlModel, EList<CHTask> chtasks) throws ModelError { | |
Package instPkg = InstanceQuery.getInstanceSpecPackage(umlModel); | |
if (instPkg == null) { | |
throw new ModelError("Instance package not in the model: use the create instance command to create this package"); | |
} | |
HashMap<CHTask, EList<CHTask>> map = new HashMap<CHTask, EList<CHTask>>(); | |
for (CHTask dOp : chtasks) { | |
System.out.println(dOp.getCHRtSpecification().getContext().getName()); | |
EList<CHTask> list = new BasicEList<CHTask>(); | |
CHRtPortSlot chRtPortSlot = InstanceQuery.getCHRtPortSlot(instPkg, dOp.getCHRtSpecification()); | |
slot2EndToEndWorkFlow(instPkg, chRtPortSlot, dOp.getCHRtSpecification(), list); | |
map.put(dOp, list); | |
} | |
return map; | |
} | |
/** | |
* Gets the operation chain 2. | |
* | |
* @param umlModel the uml model | |
* @param chtasks the chtasks | |
* @return the operation chain 2 | |
* @throws ModelError the model error | |
*/ | |
public static HashMap<CHRtSpecification, EList<CHTask>> getOperationChain2(Model umlModel, Set<CHRtSpecification> chtasks) throws ModelError { | |
Package instPkg = InstanceQuery.getInstanceSpecPackage(umlModel); | |
if (instPkg == null) { | |
throw new ModelError("Instance package not in the model: use the create instance command to create this package"); | |
} | |
HashMap<CHRtSpecification, EList<CHTask>> map = new HashMap<CHRtSpecification, EList<CHTask>>(); | |
for (CHRtSpecification dOp : chtasks) { | |
System.out.println(dOp.getContext().getName()); | |
EList<CHTask> list = new BasicEList<CHTask>(); | |
CHRtPortSlot chRtPortSlot = InstanceQuery.getCHRtPortSlot(instPkg, dOp); | |
slot2EndToEndWorkFlow(instPkg, chRtPortSlot, dOp, list); | |
map.put(dOp, list); | |
} | |
return map; | |
} | |
/** | |
* Slot 2 end to end work flow. | |
* | |
* @param instPkg the inst pkg | |
* @param currentChSlot the current ch slot | |
* @param dOp the d op | |
* @param list the list | |
* @throws ModelError the model error | |
*/ | |
private static void slot2EndToEndWorkFlow(Package instPkg, CHRtPortSlot currentChSlot, CHRtSpecification dOp, EList<CHTask> list) throws ModelError { | |
InstanceSpecification owningInstance = currentChSlot.getBase_Slot().getOwningInstance(); | |
Activity method = InstanceQuery.getMethod(dOp); | |
if (method == null) | |
return;// TODO throw exception? | |
for (ActivityNode node : method.getNodes()) { | |
if (node instanceof CallOperationAction) { | |
CallOperationAction callOp = (CallOperationAction) node; | |
EList<Slot> riSlot = InstanceQuery.getSlotFromPort(callOp, owningInstance); | |
for (Slot slot : riSlot) { | |
Slot usedPiSlot = InstanceQuery.getOppositeSlot(slot); | |
CHRtSpecification usedCH = InstanceQuery.getCHFromSlot(usedPiSlot, callOp.getOperation()); | |
CHRtPortSlot ch = UMLUtils.getStereotypeApplication(usedPiSlot, CHRtPortSlot.class); | |
if (!InstanceQuery.isDeferred(usedCH)) { | |
list.add(new CHTask(ch, usedCH)); | |
slot2EndToEndWorkFlow(instPkg, ch, usedCH, list); | |
} | |
// | |
// Operation operation = callOp.getOperation();//=>use to match the | |
// context of the chrtspec | |
// Port riPort = callOp.getOnPort();//=>get link and then pi then | |
// chrtspec | |
// Port piPort = getOppositePort(riPort); | |
// getCHRtCommentsfromPort(piPort, operation); | |
} | |
} | |
} | |
} | |
/** | |
* Wcet unit. | |
* | |
* @param wcetSpec the wcet spec | |
* @param theUnit the the unit | |
* @return the int | |
*/ | |
private static int wcetUnit(String wcetSpec, String theUnit) { | |
int ret = -1; | |
if (wcetSpec == null) | |
return ret; | |
StringParser sp = new StringParser(); | |
double value = sp.getValueNFP(wcetSpec); | |
String unit = sp.getUnitNFP(wcetSpec); | |
if (value == -1) | |
return ret; | |
int intValue = unitConversion(value, unit, theUnit); | |
return intValue; | |
} | |
/** | |
* Unit conversion float. | |
* | |
* @param value the value | |
* @param fromUnit the from unit | |
* @param toUnit the to unit | |
* @return the float | |
*/ | |
public static float unitConversionFloat(double value, String fromUnit, String toUnit) { | |
int toFactor = 1000000; | |
if (toUnit.equalsIgnoreCase("s")) { | |
toFactor = 1000000000; | |
} else if (toUnit.equalsIgnoreCase("ms")) { | |
toFactor = 1000000; | |
} else if (toUnit.equalsIgnoreCase("us")) { | |
toFactor = 1000; | |
} else if (toUnit.equalsIgnoreCase("ns")) { | |
toFactor = 1; | |
} | |
int fromFactor = 1000000; | |
if (fromUnit.equalsIgnoreCase("s")) { | |
fromFactor = 1000000000; | |
} else if (fromUnit.equalsIgnoreCase("ms")) { | |
fromFactor = 1000000; | |
} else if (fromUnit.equalsIgnoreCase("us")) { | |
fromFactor = 1000; | |
} else if (fromUnit.equalsIgnoreCase("ns")) { | |
fromFactor = 1; | |
} | |
float ratio = (float) fromFactor / toFactor; | |
float intValue = (float) (value * ratio); | |
return intValue; | |
} | |
/** | |
* Wcet unit float. | |
* | |
* @param wcetSpec the wcet spec | |
* @param theUnit the the unit | |
* @return the float | |
*/ | |
private static float wcetUnitFloat(String wcetSpec, String theUnit) { | |
int ret = -1; | |
if (wcetSpec == null) | |
return ret; | |
StringParser sp = new StringParser(); | |
double value = sp.getValueNFP(wcetSpec); | |
String unit = sp.getUnitNFP(wcetSpec); | |
if (value == -1) | |
return ret; | |
return unitConversionFloat(value, unit, theUnit); | |
} | |
/** | |
* Unit conversion. | |
* | |
* @param value the value | |
* @param fromUnit the from unit | |
* @param toUnit the to unit | |
* @return the int | |
*/ | |
public static int unitConversion(double value, String fromUnit, String toUnit) { | |
int toFactor = 1000000; | |
if (toUnit.equalsIgnoreCase("s")) { | |
toFactor = 1000000000; | |
} else if (toUnit.equalsIgnoreCase("ms")) { | |
toFactor = 1000000; | |
} else if (toUnit.equalsIgnoreCase("us")) { | |
toFactor = 1000; | |
} else if (toUnit.equalsIgnoreCase("ns")) { | |
toFactor = 1; | |
} | |
int fromFactor = 1000000; | |
if (fromUnit.equalsIgnoreCase("s")) { | |
fromFactor = 1000000000; | |
} else if (fromUnit.equalsIgnoreCase("ms")) { | |
fromFactor = 1000000; | |
} else if (fromUnit.equalsIgnoreCase("us")) { | |
fromFactor = 1000; | |
} else if (fromUnit.equalsIgnoreCase("ns")) { | |
fromFactor = 1; | |
} | |
double ratio = (double) fromFactor / toFactor; | |
int intValue = (int) Math.round(value * ratio); | |
return intValue; | |
} | |
/** | |
* Gets the WCE tunit float. | |
* | |
* @param chRtSpecification the ch rt specification | |
* @param unitOfMeasure the unit of measure | |
* @return the WCE tunit float | |
* @throws ModelError the model error | |
*/ | |
public static float getWCETunitFloat(CHRtSpecification chRtSpecification, String unitOfMeasure) throws ModelError { | |
StringParser sp = new StringParser(); | |
String wcet = chRtSpecification.getLocalWCET(); | |
float intValue = wcetUnitFloat(wcet, unitOfMeasure); | |
if (intValue != -1) | |
return intValue; | |
wcet = chRtSpecification.getWCET(); | |
intValue = wcetUnit(wcet, unitOfMeasure); | |
if (intValue != -1) | |
return intValue; | |
throw new ModelError("WCET for %s is not set correctly", chRtSpecification.getContext().getName()); | |
} | |
/** | |
* Gets the WCE tunit. | |
* | |
* @param chRtSpecification the ch rt specification | |
* @param unitOfMeasure the unit of measure | |
* @return the WCE tunit | |
* @throws ModelError the model error | |
*/ | |
public static int getWCETunit(CHRtSpecification chRtSpecification, String unitOfMeasure) throws ModelError { | |
StringParser sp = new StringParser(); | |
String wcet = chRtSpecification.getLocalWCET(); | |
int intValue = wcetUnit(wcet, unitOfMeasure); | |
if (intValue != -1) | |
return intValue; | |
wcet = chRtSpecification.getWCET(); | |
intValue = wcetUnit(wcet, unitOfMeasure); | |
if (intValue != -1) | |
return intValue; | |
throw new ModelError("WCET for %s is not set correctly", chRtSpecification.getContext().getName()); | |
} | |
/** | |
* Gets the wcet. | |
* | |
* @param chRtSpecification the ch rt specification | |
* @return the wcet | |
* @throws ModelError the model error | |
*/ | |
// TODO a similar method is implemented in the m2m plugin (Java4QVTutils.java) | |
public static double getWCET(CHRtSpecification chRtSpecification) throws ModelError { | |
StringParser sp = new StringParser(); | |
double x = -1; | |
String wcet = chRtSpecification.getLocalWCET(); | |
if (wcet != null) { | |
x = sp.getValueNFP(wcet); | |
} | |
if (x != -1) | |
return x; | |
wcet = chRtSpecification.getWCET(); | |
if (wcet != null) { | |
x = sp.getValueNFP(wcet); | |
} | |
if (x != -1) | |
return x; | |
throw new ModelError("WCET for %s is not set correctly", chRtSpecification.getContext().getName()); | |
} | |
/** | |
* Check if Instance Specification in input is assigned to a Partition. | |
* | |
* @param i the i | |
* @param assignments the assignments | |
* @return true, if is assigned 2 partition | |
*/ | |
public static boolean isAssigned2Partition(InstanceSpecification i, EList<Assign> assignments) { | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
if (theAssignment.getFrom().contains((Object) i) && (elementIsPartitionInstance(theAssignment.getTo().get(0)))) { | |
return true; | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return false; | |
} | |
/** | |
* Check if this Partition is assigned to a CPU. | |
* | |
* @param i the i | |
* @param assignments the assignments | |
* @return true, if is assigned 2 processor | |
*/ | |
public static boolean isAssigned2Processor(InstanceSpecification i, EList<Assign> assignments) { | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
if (theAssignment.getFrom().contains((Object) i) && elementIsProcessorInstance(theAssignment.getTo().get(0))) { | |
return true; | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return false; | |
} | |
/** | |
* Check if this Partition is assigned to a CPU. | |
* | |
* @param i the i | |
* @param pack the pack | |
* @param assignments the assignments | |
* @return true, if is assigned 2 core | |
*/ | |
public static boolean isAssigned2Core(InstanceSpecification i, Package pack, EList<Assign> assignments) { | |
String packQN = pack.getQualifiedName(); | |
String assignedTargetQN = ""; | |
String assignedTargetElementName = ""; | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
EList<Element> assignmentSource = theAssignment.getFrom(); | |
Element assignmentTarget = theAssignment.getTo().get(0); | |
assignedTargetQN = ((NamedElement) assignmentTarget).getQualifiedName(); | |
assignedTargetElementName = ((NamedElement) assignmentTarget).getLabel(); | |
if (assignmentSource.contains((Object) i) && elementIsProcessorInstance(assignmentTarget)) { | |
if (!theAssignment.getImpliedConstraint().isEmpty() && theAssignment.getImpliedConstraint().get(0) != null) { | |
if ((packQN + "::" + assignedTargetElementName).equals(assignedTargetQN)) { | |
return true; | |
} | |
} else { | |
// Check if it is a single-core | |
InstanceSpecification instSpecProc = (InstanceSpecification) assignmentTarget; | |
if (processorInstanceIsSingleCore(instSpecProc)) { | |
if ((packQN + "::" + assignedTargetElementName).equals(assignedTargetQN)) { | |
return true; | |
} | |
} | |
} | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return false; | |
} | |
/** | |
* Check if this Partition is assigned to a CPU. | |
* | |
* @param i the i | |
* @param assignments the assignments | |
* @return true, if is assigned 2 core | |
*/ | |
public static boolean isAssigned2Core(InstanceSpecification i, EList<Assign> assignments) { | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
if (theAssignment.getFrom().contains((Object) i) && elementIsProcessorInstance(theAssignment.getTo().get(0))) { | |
if (!theAssignment.getImpliedConstraint().isEmpty() && theAssignment.getImpliedConstraint().get(0) != null) { | |
return true; | |
} else { | |
// Check if it is a single-core | |
Element elem = theAssignment.getTo().get(0); | |
InstanceSpecification instSpecProc = (InstanceSpecification) elem; | |
if (processorInstanceIsSingleCore(instSpecProc)) { | |
return true; | |
} | |
} | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return false; | |
} | |
// /** | |
// * Check if this Partition is assigned to a CPU | |
// * @param i | |
// * @param assignments | |
// * @return | |
// */ | |
// public static boolean isAssigned2Core(InstanceSpecification i, | |
// EList<Assign> assignments) { | |
// for (Assign theAssignment : assignments) { | |
// if (theAssignment != null) { | |
// if (theAssignment.getFrom().contains((Object)i) && | |
// elementIsProcessorInstance(theAssignment.getTo().get(0)) && | |
// !theAssignment.getImpliedConstraint().isEmpty()&& | |
// theAssignment.getImpliedConstraint().get(0)!=null ) { | |
// return true; | |
// } | |
// } | |
// } | |
// return false; | |
// } | |
/** | |
* Returns TRUE if the given Task is assigned to a Core in the Deployment | |
* identified by the given package. | |
* | |
* @param task the task | |
* @param pack the pack | |
* @param assignments the assignments | |
* @return true, if is task assigned 2 core | |
*/ | |
public static boolean isTaskAssigned2Core(CHTask task, Package pack, EList<Assign> assignments) { | |
String taskName = task.getCHRtSpecification().getContext().getName(); | |
String packQN = pack.getQualifiedName(); | |
String assignedTargetQN = ""; | |
String assignedTargetElementName = ""; | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
Element assignmentSource = theAssignment.getFrom().get(0); | |
Element assignmentTarget = theAssignment.getTo().get(0); | |
assignedTargetQN = ((NamedElement) assignmentTarget).getQualifiedName(); | |
assignedTargetElementName = ((NamedElement) assignmentTarget).getLabel(); | |
if ((packQN + "::" + assignedTargetElementName).equals(assignedTargetQN) && QueryUtils.elementIsSlotInstance(assignmentSource) && theAssignment.getImpliedConstraint() != null | |
&& !theAssignment.getImpliedConstraint().isEmpty()) { | |
String theTaskValue = getTaskNameFromImpliedNfpConstraint(theAssignment); | |
if (theTaskValue != null && theTaskValue.length() > 0) { | |
if (theTaskValue.equals(taskName)) { | |
return true; | |
} | |
} | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return false; | |
} | |
/** | |
* Returns true if the given task is assigned to a core, false otherwise. | |
* | |
* @param t the t | |
* @param assignments the assignments | |
* @return true if the given task is assigned to a core | |
*/ | |
public static boolean isTaskAssigned2Core(CHTask t, EList<Assign> assignments) { | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
Element assignmentSource = theAssignment.getFrom().get(0); | |
if (QueryUtils.elementIsSlotInstance(assignmentSource)) { | |
CHTask theTask = getTaskFromSlot(assignmentSource); | |
if ((theTask != null && theTask.equals(t)) && elementIsProcessorInstance(theAssignment.getTo().get(0))) { | |
return true; | |
} | |
} | |
} | |
} | |
return false; | |
} | |
/** | |
* Given the Core (and related processor) get the list of partitions that are | |
* assigned to it. | |
* | |
* @param core the core | |
* @param assignments the assignments | |
* @return the partitions assigned 2 core | |
*/ | |
public static LinkedHashSet<Object> getPartitionsAssigned2Core(CHCore core, EList<Assign> assignments) { | |
LinkedHashSet<Object> result = new LinkedHashSet<Object>(); | |
InstanceSpecification processorInstance = core.getProcessorInstance(); | |
String theCoreName = core.getName(); | |
String theCoreValue = null; | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
Element assignmentSource = theAssignment.getFrom().get(0); | |
// Only look at assignments where: | |
// ASSIGNMENT_SOURCE is a Partition | |
// ASSIGNMENT_TARGET is the Processor that owns the core | |
if (!QueryUtils.elementIsPartitionInstance(assignmentSource) || (!theAssignment.getTo().contains((Object) processorInstance))) { | |
continue; | |
} | |
// found an assignment for the processor that owns the core: | |
// let's look into it so see if it is related to the core we are | |
// analyzing | |
if (theAssignment.getImpliedConstraint() != null && !theAssignment.getImpliedConstraint().isEmpty()) { | |
theCoreValue = getCoreNameFromImpliedNfpConstraint(theAssignment); | |
if (theCoreValue.equals(theCoreName)) { | |
// if target of assignment is a partition | |
result.add(assignmentSource); | |
} | |
} else { | |
if (processorInstanceIsSingleCore(processorInstance)) { | |
// If no core is specified in the Implied Constraint and the | |
// Processor has only 1 Core | |
result.add(assignmentSource); | |
} | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Returns the name of the Core to which the given assignment is related. | |
* | |
* @param theAssignment the the assignment | |
* @return the name of the Core to which theAssignment is related | |
*/ | |
public static String getCoreNameFromImpliedNfpConstraint(Assign theAssignment) { | |
String coreName = null; | |
try { | |
NfpConstraint theImpliedNfpConstraint = theAssignment.getImpliedConstraint().get(0); | |
Constraint cnstr = theImpliedNfpConstraint.getBase_Constraint(); | |
ValueSpecification valueSpec = cnstr.getSpecification(); | |
LiteralString value = (LiteralString) valueSpec; | |
coreName = value.getValue(); | |
} catch (Exception e) { | |
System.out.println("Error in getCoreNameFromImpliedNfpConstraint"); | |
} | |
return coreName; | |
} | |
/** | |
* Gets the task name from implied nfp constraint. | |
* | |
* @param theAssignment the the assignment | |
* @return the task name from implied nfp constraint | |
*/ | |
private static String getTaskNameFromImpliedNfpConstraint(Assign theAssignment) { | |
String taskName = null; | |
try { | |
// the first one is the core, the second one is the task | |
NfpConstraint theImpliedNfpConstraint = theAssignment.getImpliedConstraint().get(1); | |
Constraint cnstr = theImpliedNfpConstraint.getBase_Constraint(); | |
ValueSpecification valueSpec = cnstr.getSpecification(); | |
LiteralString value = (LiteralString) valueSpec; | |
taskName = value.getValue(); | |
} catch (Exception e) { | |
System.out.println("Error in getTaskNameFromImpliedNfpConstraint"); | |
} | |
return taskName; | |
} | |
/** | |
* Returns true if the given element is a partition instance, false otherwise. | |
* | |
* @param element the element | |
* @return true if the element is a partition instance, false otherwise | |
*/ | |
public static boolean elementIsPartitionInstance(Element element) { | |
if (!(element instanceof InstanceSpecification)) { | |
return false; | |
} | |
InstanceSpecification is = (InstanceSpecification) element; | |
if (is.getQualifiedName() != null && QueryUtils.isPartitionInstance(is)) { | |
return true; | |
} | |
return false; | |
} | |
/** | |
* Returns true if the given element is a component instance, false otherwise. | |
* | |
* @param element the element | |
* @return true if the element is a component instance, false otherwise | |
*/ | |
public static boolean elementIsComponentInstance(Element element) { | |
if (!(element instanceof InstanceSpecification)) { | |
return false; | |
} | |
InstanceSpecification is = (InstanceSpecification) element; | |
if (is.getQualifiedName() != null && QueryUtils.isComponentInstance(is)) { | |
return true; | |
} | |
return false; | |
} | |
/** | |
* Returns true if the given element is a processor instance, false otherwise. | |
* | |
* @param element the element | |
* @return true if the element is a processor instance, false otherwise | |
*/ | |
public static boolean elementIsProcessorInstance(Element element) { | |
if (!(element instanceof InstanceSpecification)) { | |
return false; | |
} | |
InstanceSpecification is = (InstanceSpecification) element; | |
if (is.getQualifiedName() != null && QueryUtils.isProcessorInstance(is)) { | |
return true; | |
} | |
return false; | |
} | |
/** | |
* Given the Core (and related processor) get the list of components that are | |
* assigned to it. | |
* | |
* @param core the core | |
* @param assignments the assignments | |
* @return the components assigned 2 core | |
*/ | |
public static LinkedHashSet<Object> getComponentsAssigned2Core(CHCore core, EList<Assign> assignments) { | |
LinkedHashSet<Object> result = new LinkedHashSet<Object>(); | |
InstanceSpecification processorInstance = core.getProcessorInstance(); | |
String theCoreName = core.getName(); | |
String theCoreValue = null; | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
// Only look at assignments where: | |
// ASSIGNMENT_SOURCE is a Component | |
// ASSIGNMENT_TARGET is the Processor that owns the core | |
Element assignmentSource = theAssignment.getFrom().get(0); | |
if (!QueryUtils.elementIsComponentInstance(assignmentSource) || !theAssignment.getTo().contains((Object) processorInstance)) { | |
continue; | |
} | |
// found an assignment for the processor that owns the core: | |
// let's look into it so see if it is related to the core we are | |
// analyzing | |
if (theAssignment.getImpliedConstraint() != null && !theAssignment.getImpliedConstraint().isEmpty()) { | |
theCoreValue = getCoreNameFromImpliedNfpConstraint(theAssignment); | |
if (theCoreValue.equals(theCoreName)) { | |
result.add(assignmentSource); | |
} | |
} else { | |
if (processorInstanceIsSingleCore(processorInstance)) { | |
// If no core is specified in the Implied Constraint and the | |
// Processor has only 1 Core | |
result.add(assignmentSource); | |
} | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Given the Core (and related processor) get the list of tasks that are | |
* assigned to it. | |
* | |
* @param core the core | |
* @param pack the pack | |
* @param assignments the assignments | |
* @return the tasks assigned 2 core | |
*/ | |
public static LinkedHashSet<Object> getTasksAssigned2Core(CHCore core, Package pack, EList<Assign> assignments) { | |
String packQN = pack.getQualifiedName(); | |
LinkedHashSet<Object> result = new LinkedHashSet<Object>(); | |
InstanceSpecification processorInstance = core.getProcessorInstance(); | |
String theCoreName = core.getName(); | |
String theCoreValue = null; | |
String theTaskValue = null; | |
for (Assign theAssignment : assignments) { | |
if (theAssignment != null) { | |
try { | |
if (theAssignment.getTo().contains((Object) processorInstance)) { | |
// found an assignment for the processor that owns the core: | |
// let's look into it so see if it is related to the core we are | |
// analyzing | |
Element assignmentSource = theAssignment.getFrom().get(0); | |
Element assignmentTarget = theAssignment.getTo().get(0); | |
String assignedTargetQN = ((NamedElement) assignmentTarget).getQualifiedName(); | |
String assignedTargetElementName = ((NamedElement) assignmentTarget).getLabel(); | |
EList<CHTask> chTaskList = new BasicEList<CHTask>(); | |
if ((packQN + "::" + assignedTargetElementName).equals(assignedTargetQN) && theAssignment.getImpliedConstraint() != null && !theAssignment.getImpliedConstraint().isEmpty()) { | |
theCoreValue = getCoreNameFromImpliedNfpConstraint(theAssignment); | |
theTaskValue = getTaskNameFromImpliedNfpConstraint(theAssignment); | |
if (theCoreValue.equals(theCoreName)) { | |
if (QueryUtils.elementIsSlotInstance(assignmentSource)) { | |
chTaskList = getAllTasksFromSlot(assignmentSource); | |
for (CHTask theChTask : chTaskList) { | |
String theTaskName = theChTask.getCHRtSpecification().getContext().getName(); | |
if (theChTask != null && theTaskName.equals(theTaskValue)) { | |
result.add(theChTask); | |
} | |
} | |
} | |
} else { | |
// If no core is specified in the Implied Constraint and the | |
// Processor has only 1 Core | |
if (processorInstanceIsSingleCore(processorInstance) && QueryUtils.elementIsSlotInstance(assignmentSource)) { | |
chTaskList = getAllTasksFromSlot(assignmentSource); | |
for (CHTask theChTask : chTaskList) { | |
String theTaskName = theChTask.getCHRtSpecification().getContext().getName(); | |
if (theChTask != null && theTaskName.equals(theTaskValue)) { | |
result.add(theChTask); | |
} | |
} | |
} | |
} | |
} | |
} | |
} catch (Exception e) { | |
continue; | |
} | |
} | |
} | |
return result; | |
} | |
/** | |
* Returns the list of Component to Core assignments in the given view in the given model. | |
* | |
* @param umlModel the uml model | |
* @param viewName the view name | |
* @return the component 2 core assignments | |
* @throws ModelError the model error | |
*/ | |
public static EList<Assign> getComponent2CoreAssignments(Model umlModel, String viewName) throws ModelError { | |
// LB 20150708 we now look for assignments in the CHGA resource platform | |
// component | |
// Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel, | |
// viewName); | |
// cmpv = QueryUtils.getResourcePlatformPackage(cmpv); | |
Component rpc = QueryUtils.getResourcePlatformComponent(umlModel, viewName); | |
EList<Element> all = rpc.allOwnedElements(); | |
EList<Assign> assignments = new BasicEList<Assign>(); | |
Stereotype stereo = null; | |
for (Element element : all) { | |
if ((element.getAppliedStereotype(MARTE_ASSIGN) != null)) { | |
stereo = element.getAppliedStereotype(MARTE_ASSIGN); | |
EObject eobj = element.getStereotypeApplication(stereo); | |
Assign a = (Assign) eobj; | |
Element assignmentSource = a.getFrom().get(0); | |
Element assignmentTarget = a.getTo().get(0); | |
// SOURCE must be a Component | |
// TARGET must be a Processor | |
if (elementIsProcessorInstance(assignmentTarget)) { | |
if (elementIsComponentInstance(assignmentSource)) { | |
InstanceSpecification componentInst = (InstanceSpecification) assignmentSource; | |
if (isComponentInstance(componentInst)) { | |
assignments.add(a); | |
} | |
} | |
} | |
} | |
} | |
return assignments; | |
} | |
/** | |
* Returns the list of Component to Partition assignments in the given view in the given model. | |
* | |
* @param umlModel the uml model | |
* @param viewName the view name | |
* @return the component 2 partition assignments | |
* @throws ModelError the model error | |
*/ | |
public static EList<Assign> getComponent2PartitionAssignments(Model umlModel, String viewName) throws ModelError { | |
// LB 20150708 we now look for assignments in the CHGA resource platform | |
// component | |
// Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel, | |
// viewName); | |
// cmpv = QueryUtils.getResourcePlatformPackage(cmpv); | |
Component rpc = QueryUtils.getResourcePlatformComponent(umlModel, viewName); | |
EList<Element> all = rpc.allOwnedElements(); | |
EList<Assign> assignments = new BasicEList<Assign>(); | |
Stereotype stereo = null; | |
for (Element element : all) { | |
if ((element.getAppliedStereotype(MARTE_ASSIGN) != null)) { | |
stereo = element.getAppliedStereotype(MARTE_ASSIGN); | |
EObject eobj = element.getStereotypeApplication(stereo); | |
Assign a = (Assign) eobj; | |
Element assignmentSource = a.getFrom().get(0); | |
Element assignmentTarget = a.getTo().get(0); | |
// SOURCE must be a Component | |
// TARGET must be a Partition | |
if (elementIsPartitionInstance(assignmentTarget)) { | |
if (elementIsComponentInstance(assignmentSource)) { | |
InstanceSpecification componentInst = (InstanceSpecification) assignmentSource; | |
if (isComponentInstance(componentInst)) { | |
assignments.add(a); | |
} | |
} | |
} | |
} | |
} | |
return assignments; | |
} | |
/** | |
* Returns the list of Partition to Core assignments in the given view in the given model. | |
* | |
* @param umlModel the uml model | |
* @param viewName the view name | |
* @return the partition 2 core assignments | |
* @throws ModelError the model error | |
*/ | |
public static EList<Assign> getPartition2CoreAssignments(Model umlModel, String viewName) throws ModelError { | |
// LB 20150708 we now look for assignments in the CHGA resource platform | |
// component | |
// Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel, | |
// viewName); | |
// cmpv = QueryUtils.getResourcePlatformPackage(cmpv); | |
Component rpc = QueryUtils.getResourcePlatformComponent(umlModel, viewName); | |
EList<Element> all = rpc.allOwnedElements(); | |
EList<Assign> assignments = new BasicEList<Assign>(); | |
Stereotype stereo = null; | |
for (Element element : all) { | |
if ((element.getAppliedStereotype(MARTE_ASSIGN) != null)) { | |
stereo = element.getAppliedStereotype(MARTE_ASSIGN); | |
EObject eobj = element.getStereotypeApplication(stereo); | |
Assign a = (Assign) eobj; | |
Element assignmentSource = a.getFrom().get(0); | |
Element assignmentTarget = a.getTo().get(0); | |
// SOURCE must be a Partition | |
// TARGET must be a Processor | |
if (elementIsPartitionInstance(assignmentSource) && elementIsProcessorInstance(assignmentTarget)) { | |
assignments.add(a); | |
} | |
} | |
} | |
return assignments; | |
} | |
/** | |
* Returns the list of Task to Core assignments in the given view in the given model. | |
* | |
* @param umlModel the uml model | |
* @param viewName the view name | |
* @return the task 2 core assignments | |
* @throws ModelError the model error | |
*/ | |
public static EList<Assign> getTask2CoreAssignments(Model umlModel, String viewName) throws ModelError { | |
// LB 20150708 we now look for assignments in the CHGA resource platform | |
// component | |
// Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel, | |
// viewName); | |
// cmpv = QueryUtils.getResourcePlatformPackage(cmpv); | |
Component rpc = QueryUtils.getResourcePlatformComponent(umlModel, viewName); | |
EList<Element> all = rpc.allOwnedElements(); | |
EList<Assign> assignments = new BasicEList<Assign>(); | |
Stereotype stereo = null; | |
for (Element element : all) { | |
if ((element.getAppliedStereotype(MARTE_ASSIGN) != null)) { | |
stereo = element.getAppliedStereotype(MARTE_ASSIGN); | |
EObject eobj = element.getStereotypeApplication(stereo); | |
Assign a = (Assign) eobj; | |
Element assignmentSource = a.getFrom().get(0); | |
Element assignmentTarget = a.getTo().get(0); | |
// SOURCE must be a Task | |
// TARGET must be a Processor | |
if (elementIsSlotInstance(assignmentSource) && elementIsProcessorInstance(assignmentTarget)) { | |
assignments.add(a); | |
} | |
} | |
} | |
return assignments; | |
} | |
/** | |
* Returns true is the input Instance Processor has only 1 CORE. | |
* | |
* @param processorInstance the processor instance | |
* @return true, if successful | |
*/ | |
public static boolean processorInstanceIsSingleCore(InstanceSpecification processorInstance) { | |
Classifier processorClass = processorInstance.getClassifiers().get(0); | |
CH_HwProcessor processorType = UMLUtils.getStereotypeApplication(processorClass, CH_HwProcessor.class); | |
String coreNumber = null; | |
coreNumber = processorType.getNbCores(); | |
int icoreNumber = 1; | |
try { | |
icoreNumber = Integer.parseInt(coreNumber); | |
} catch (Exception e) { | |
icoreNumber = 1; | |
} | |
if (icoreNumber == 1) { | |
return true; | |
} | |
return false; | |
} | |
/** | |
* Returns the Package (in the Deployment View) that owns the input system. | |
* | |
* @param umlModel the uml model | |
* @param theSystem the the system | |
* @return the owner CH ga resource platform package | |
* @throws ModelError the model error | |
*/ | |
public static Package getOwnerCHGaResourcePlatformPackage(Model umlModel, InstanceSpecification theSystem) throws ModelError { | |
EList<Package> packList = QueryUtils.getResourcePlatformPackages(umlModel, Constants.DEPLOYMENT_VIEW_NAME); | |
for (Package pack : packList) { | |
EList<Element> packElems = pack.allOwnedElements(); | |
for (Element elem : packElems) { | |
if (elem instanceof InstanceSpecification) { | |
if (((InstanceSpecification) elem).equals(theSystem)) { | |
return pack; | |
} | |
} | |
} | |
} | |
return null; | |
} | |
} |