From c6a177715e3355553642c5d36e9a26ddce6c0c9e Mon Sep 17 00:00:00 2001
From: Alexander Diewald <diewald@fortiss.org>
Date: Thu, 1 Feb 2018 16:08:46 +0000
Subject: [PATCH] Exploration.alg: Reduce the amount of preprocessing code.
Note: Due to the invasive changes, the MOEA-based DSE is currently non-functional. This intermediate commit is intended to separate the overall goal into smaller tasks.
refs 3254
---
.../trunk/META-INF/MANIFEST.MF | 4 +-
.../af3/exploration/alg/backend/.ratings | 2 +-
.../alg/backend/Opt4JDseBackend.java | 19 +-
.../fortiss/af3/exploration/alg/dse/.ratings | 2 +-
.../af3/exploration/alg/dse/Explorer.java | 1 -
.../DeadlineConstraintEvaluator.java | 59 +-
.../alg/dse/sysmodel/arch/.ratings | 4 +-
.../arch/DeprecatedSystemModelAdapter.java | 1164 +++++++++++++++++
.../dse/sysmodel/arch/SystemModelAdapter.java | 224 +---
.../alg/dse/sysmodel/arch/af3/.ratings | 4 +-
.../sysmodel/arch/af3/AF3SignalAdapter.java | 52 +-
.../arch/af3/AF3SystemModelAdapter.java | 550 +++-----
.../fortiss/af3/exploration/alg/port/.ratings | 2 +-
.../exploration/alg/port/DSEPortingUtils.java | 13 +
.../fortiss/af3/exploration/alg/util/.ratings | 2 +-
.../af3/exploration/alg/util/AF3Utils.java | 105 +-
16 files changed, 1478 insertions(+), 729 deletions(-)
create mode 100644 org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/DeprecatedSystemModelAdapter.java
diff --git a/org.fortiss.af3.exploration.alg/trunk/META-INF/MANIFEST.MF b/org.fortiss.af3.exploration.alg/trunk/META-INF/MANIFEST.MF
index ff1f7b1c..b63c12d3 100644
--- a/org.fortiss.af3.exploration.alg/trunk/META-INF/MANIFEST.MF
+++ b/org.fortiss.af3.exploration.alg/trunk/META-INF/MANIFEST.MF
@@ -37,7 +37,9 @@ Require-Bundle: org.fortiss.tooling.base.ui;visibility:=reexport,
org.fortiss.af3.platform;visibility:=reexport,
org.fortiss.af3.project;visibility:=reexport,
org.eclipse.ui.ide;visibility:=reexport,
- org.fortiss.af3.exploration.smt;bundle-version="2.11.0"
+ org.fortiss.af3.exploration.smt;bundle-version="2.11.0",
+ org.fortiss.af3.platform.hierarchic,
+ org.fortiss.af3.task
Export-Package: com.google.common.annotations,
com.google.common.base,
com.google.common.base.internal,
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/.ratings b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/.ratings
index a48886f0..a7ed7a45 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/.ratings
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/.ratings
@@ -1 +1 @@
-Opt4JDseBackend.java a20d2749e8001bbc6e437b7f8422b73db6478be8 RED
+Opt4JDseBackend.java aa46c8c39179a2b6f457cef98d294b222790ed5b RED
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/Opt4JDseBackend.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/Opt4JDseBackend.java
index 9b05ba36..bec7188e 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/Opt4JDseBackend.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/backend/Opt4JDseBackend.java
@@ -15,7 +15,6 @@
+--------------------------------------------------------------------------*/
package org.fortiss.af3.exploration.alg.backend;
-import static org.fortiss.af3.exploration.alg.port.DSEPortingUtils.createSystemParameterContainer;
import static org.fortiss.af3.exploration.alg.util.DesignSpaceExplorationModelElementFactory.createDefaultDesignSpaceExploration;
import static org.fortiss.af3.exploration.util.DesignSpaceExplorationModelElementFactory.createExplorationSpecification;
import static org.fortiss.tooling.common.util.LambdaUtils.getFirst;
@@ -29,12 +28,12 @@ import java.util.Optional;
import java.util.Set;
import org.eclipse.core.runtime.IProgressMonitor;
+import org.fortiss.af3.component.model.Component;
import org.fortiss.af3.component.model.ComponentArchitecture;
import org.fortiss.af3.exploration.alg.dse.CompositeExplorationSolution;
import org.fortiss.af3.exploration.alg.dse.Explorer;
import org.fortiss.af3.exploration.alg.dse.backend.opt4j.solution.StrictTTSchedule;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.SystemModelAdapter;
-import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.SystemParameterContainer;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.af3.AF3SystemModelAdapter;
import org.fortiss.af3.exploration.alg.port.plot.XYPlotter;
import org.fortiss.af3.exploration.alg.service.IExplorationEncoding;
@@ -52,14 +51,12 @@ import org.fortiss.af3.exploration.moea.model.feature.FeatureFactory;
import org.fortiss.af3.exploration.projectmodel.RuleSet;
import org.fortiss.af3.platform.model.ExecutionUnit;
import org.fortiss.af3.platform.model.PlatformArchitecture;
-import org.fortiss.af3.project.model.FileProject;
-import org.fortiss.af3.project.utils.ProjectUtils;
+import org.fortiss.af3.task.model.Signal;
import org.fortiss.af3.task.model.Task;
import org.fortiss.af3.task.model.TaskArchitecture;
import org.fortiss.tooling.base.model.element.IModelElement;
import org.fortiss.tooling.kernel.extension.data.ITopLevelElement;
import org.fortiss.tooling.kernel.service.IPersistencyService;
-import org.fortiss.tooling.kernel.utils.EcoreUtils;
import org.jfree.ui.RefineryUtilities;
/**
@@ -107,16 +104,8 @@ public class Opt4JDseBackend implements IDseBackend {
// Input to DSE: {@link SystemModelAdapter} and {@link DesignSpaceExploration}.
// SystemModelAdapter systemModelAdapter;
- FileProject fp = ProjectUtils.getFileProject(taskArchitecture);
- ComponentArchitecture componentArchitecture =
- EcoreUtils.pickFirstInstanceOf(ComponentArchitecture.class, fp.getRootElements());
-
- PlatformArchitecture platformArchitecture =
- getArchModel(superSets, PlatformArchitecture.class, ExecutionUnit.class);
- SystemParameterContainer paramContainer =
- createSystemParameterContainer(platformArchitecture, taskArchitecture, spec);
- systemModelAdapter = new AF3SystemModelAdapter(componentArchitecture, platformArchitecture,
- paramContainer);
+ systemModelAdapter = new AF3SystemModelAdapter(superSets.get(Component.class),
+ superSets.get(ExecutionUnit.class), superSets.get(Signal.class));
DseSpecification dseSpec = createDefaultDesignSpaceExploration(spec, context);
// Set the requested solutions.
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/.ratings b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/.ratings
index 93bce2fc..822fb461 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/.ratings
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/.ratings
@@ -1,6 +1,6 @@
CompositeExplorationSolution.java 528283a3dd57500539b2e11dd3d3eb35512de9b8 RED
DSEFactory.java d8163c2b1df1b9cc690367140096e4b29d4dd2ae RED
-Explorer.java b14a77607cfadf81aed523d7b53b14559482c44c RED
+Explorer.java c4a8aa9673bb84df89971775c4b0ea1697e725e8 RED
ImplicitExplorationTargetFactory.java 897d89b5d5beb580da9007290acc835ff15e1e7c RED
SolutionQuantification.java efd31f192c3adbf1a4434452a19eb836a17390e2 RED
TaskMappingFactory.java 87cfb7ec5e24acb167fa4ffd7210b093fa5b5b4d RED
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/Explorer.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/Explorer.java
index 554a98ed..44678306 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/Explorer.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/Explorer.java
@@ -71,7 +71,6 @@ public class Explorer {
Set<Class<? extends IExplorationEncoding>> requestedSolutions,
IProgressMonitor progressMonitor, boolean generateImplicitConstraints)
throws Exception {
-
validateDesignSpaceExploration(dse);
validateSystemModelAdapter(systemModelAdapter);
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/evaluator/constraint/DeadlineConstraintEvaluator.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/evaluator/constraint/DeadlineConstraintEvaluator.java
index 83e2dd58..e0cb48b1 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/evaluator/constraint/DeadlineConstraintEvaluator.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/evaluator/constraint/DeadlineConstraintEvaluator.java
@@ -31,7 +31,6 @@ import org.fortiss.af3.exploration.alg.dse.backend.opt4j.extensions.compositegen
import org.fortiss.af3.exploration.alg.dse.backend.opt4j.solution.StrictTTSchedule;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ITaskAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.SystemModelAdapter;
-import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.af3.AF3SystemModelAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.taskgraph.TaskGraph;
import org.fortiss.af3.exploration.alg.service.IExplorationTargetEvaluator;
import org.fortiss.af3.exploration.model.ExplorationConstraint;
@@ -72,34 +71,37 @@ public class DeadlineConstraintEvaluator<S extends InstantiatedTaskMappingEntry,
sourceDeployableComponent = new ArrayList<>();
targetDeployableComponent = new ArrayList<>();
- sourceDeployableComponent.add(systemModelAdapter.getDeployableComponentOf(optGoal
- .getStartComponent()));
- targetDeployableComponent.add(systemModelAdapter.getDeployableComponentOf(explorationTarget
- .getEndComponent()));
+ sourceDeployableComponent
+ .add(systemModelAdapter.getDeployableComponentOf(optGoal.getStartComponent()));
+ targetDeployableComponent.add(
+ systemModelAdapter.getDeployableComponentOf(explorationTarget.getEndComponent()));
deadline = explorationTarget.getDeadline();
+ // TODO(#2960): Reenable the Deadline Constraint evaluator based on DSML expressions.
+ // Currently, it is commented out to allow a reduction of the input code.
+
// TODO: AD: The cast to the AF3 systemmodeladapter breaks the abstration the goals. It
// would be rather required to define the source and sink components as
// IDeployableComponents in the ecore model. The transformation from AF3 components to the
// IDeployableCompontes should be done when the data from the GUI is written to the model.
- ITaskAdapter<?> origStartComponent =
- ((AF3SystemModelAdapter)systemModelAdapter).getDeployableComponentAdapter(explorationTarget
- .getStartComponent());
- if(origStartComponent.isInstantiation()) {
- sourceDeployableComponent.add(origStartComponent);
- } else {
- sourceDeployableComponent.addAll(origStartComponent.getReplacementComponents());
- }
-
- ITaskAdapter<?> origTargetComponent =
- ((AF3SystemModelAdapter)systemModelAdapter).getDeployableComponentAdapter(explorationTarget
- .getEndComponent());
- if(origStartComponent.isInstantiation()) {
- targetDeployableComponent.add(origTargetComponent);
- } else {
- targetDeployableComponent.addAll(origTargetComponent.getReplacementComponents());
- }
+ // ITaskAdapter<?> origStartComponent =
+ // ((AF3SystemModelAdapter)systemModelAdapter).getTaskAdapter(explorationTarget
+ // .getStartComponent());
+ // if(origStartComponent.isInstantiation()) {
+ // sourceDeployableComponent.add(origStartComponent);
+ // } else {
+ // sourceDeployableComponent.addAll(origStartComponent.getReplacementComponents());
+ // }
+ //
+ // ITaskAdapter<?> origTargetComponent =
+ // ((AF3SystemModelAdapter)systemModelAdapter).getTaskAdapter(explorationTarget
+ // .getEndComponent());
+ // if(origStartComponent.isInstantiation()) {
+ // targetDeployableComponent.add(origTargetComponent);
+ // } else {
+ // targetDeployableComponent.addAll(origTargetComponent.getReplacementComponents());
+ // }
}
/**
@@ -130,13 +132,11 @@ public class DeadlineConstraintEvaluator<S extends InstantiatedTaskMappingEntry,
// the start time is the release time of this iteration, which is the beginning
// of the period
// double start = i * tg.getPeriod();
- ITaskAdapter<?> earliestComp =
- sourceDeployableComponent.stream()
- .min(Comparator.comparing(t -> schedule.getFirstStartTime(t, j))).get();
+ ITaskAdapter<?> earliestComp = sourceDeployableComponent.stream()
+ .min(Comparator.comparing(t -> schedule.getFirstStartTime(t, j))).get();
double start = schedule.getFirstStartTime(earliestComp, i);
- ITaskAdapter<?> latestComp =
- targetDeployableComponent.stream()
- .min(Comparator.comparing(t -> schedule.getLastEndTime(t, j))).get();
+ ITaskAdapter<?> latestComp = targetDeployableComponent.stream()
+ .min(Comparator.comparing(t -> schedule.getLastEndTime(t, j))).get();
double end = schedule.getLastEndTime(latestComp, i);
double latency = end - start;
@@ -165,7 +165,8 @@ public class DeadlineConstraintEvaluator<S extends InstantiatedTaskMappingEntry,
public boolean validateInputs() {
// TODO: AD: is this check really required here? Shouldn't this be done by the
// inputvalidator?
- if(explorationTarget.getStartComponent() == null || explorationTarget.getEndComponent() == null ||
+ if(explorationTarget.getStartComponent() == null ||
+ explorationTarget.getEndComponent() == null ||
explorationTarget.getDeadline() <= 0) {
return false;
}
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/.ratings b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/.ratings
index 36dca816..f1c8043b 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/.ratings
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/.ratings
@@ -1,3 +1,4 @@
+DeprecatedSystemModelAdapter.java 58ad7df1f616cf16e27548a5c8e8076978b6468c RED
ICommunicationResourceAdapter.java 54dd128bfa04c5cfd16551eec8983e712636f86a RED
IComponentAdapter.java c8425150287be21b48d686469b88ea7fb77793e4 RED
IExecutionUnitAdapter.java a93c835d5dce6a6054eea7b0abb9663c04a335b8 RED
@@ -12,8 +13,7 @@ IResourceConnectionAdapter.java 7e20a8c3e60a9892597301556c891ba2dd43387f RED
ISafetyFunctionAdapter.java 02c3777272abddd5f60d2c840cf3739827e8287a RED
ISignalAdapter.java a158c54dc238fa5c8891f4355ffa2833f6984f81 RED
ITaskAdapter.java 94fa22a6afe51b29dd67fd81188174e22e96f026 RED
-ITasksAdapter.java cf118b5d3cb7142f9c53e02bca6b8439b0604bb1 RED
ITransmissionUnitAdapter.java 8965b73bfe9ef232a2a6d5427f7001761716d583 RED
InternalComponentParameters.java 2b19f4eeddee84e4c6e558ed9a1613cba33b7665 RED
-SystemModelAdapter.java 47763ad9c87a81b171d92bc926bf00f1a40b82ce RED
+SystemModelAdapter.java 5d1d02fc1653b9528cdb7acc697350325a58f641 RED
SystemParameterContainer.java eddfc430acd8661dfe8ffbf191ef71a83157eff5 RED
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/DeprecatedSystemModelAdapter.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/DeprecatedSystemModelAdapter.java
new file mode 100644
index 00000000..103b6857
--- /dev/null
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/DeprecatedSystemModelAdapter.java
@@ -0,0 +1,1164 @@
+/*-------------------------------------------------------------------------+
+| Copyright 2014 fortiss GmbH |
+| |
+| Licensed under the Apache License, Version 2.0 (the "License"); |
+| you may not use this file except in compliance with the License. |
+| You may obtain a copy of the License at |
+| |
+| http://www.apache.org/licenses/LICENSE-2.0 |
+| |
+| Unless required by applicable law or agreed to in writing, software |
+| distributed under the License is distributed on an "AS IS" BASIS, |
+| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
+| See the License for the specific language governing permissions and |
+| limitations under the License. |
++--------------------------------------------------------------------------*/
+package org.fortiss.af3.exploration.alg.dse.sysmodel.arch;
+
+import static org.fortiss.af3.exploration.util.ExplorationUtils.isDebugVerboseEnabled;
+import static org.fortiss.af3.schedule.utils.MathUtils.lcmDoubleCollection;
+import static org.fortiss.af3.task.util.TaskAllocationUtils.getAllocatedComponentsTo;
+import static org.fortiss.tooling.kernel.utils.EcoreUtils.pickFirstInstanceOf;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.fortiss.af3.component.model.Component;
+import org.fortiss.af3.component.model.ComponentArchitecture;
+import org.fortiss.af3.exploration.alg.dse.backend.opt4j.encoding.platform.PlatformCommunicationGraphEncoding;
+import org.fortiss.af3.exploration.alg.dse.backend.opt4j.encoding.taskgraph.AbstractTaskGraphEncoding;
+import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IResourceConnectionAdapter.ConnectionType;
+import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.taskgraph.AcyclicTaskGraph;
+import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.taskgraph.ChannelAdapterWeightedEdge;
+import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.taskgraph.DefaultTaskGraph;
+import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.taskgraph.TaskGraph;
+import org.fortiss.af3.exploration.alg.exception.InvalidTimingModelException;
+import org.fortiss.af3.exploration.alg.guava.MutableSubClassToInstanceMap;
+import org.fortiss.af3.exploration.alg.guava.SubClassToInstanceMap;
+import org.fortiss.af3.exploration.alg.service.IExplorationEncoding;
+import org.fortiss.af3.platform.model.ExecutionUnit;
+import org.fortiss.af3.platform.model.IPlatformArchitectureElement;
+import org.fortiss.af3.platform.model.IPlatformCommunicationResource;
+import org.fortiss.af3.platform.model.IPlatformExport;
+import org.fortiss.af3.platform.model.IPlatformResource;
+import org.fortiss.af3.platform.model.PlatformArchitecture;
+import org.fortiss.af3.platform.model.annotation.ResourceLink;
+import org.fortiss.af3.platform.utils.PlatformArchitectureUtils;
+import org.fortiss.af3.task.model.Task;
+import org.fortiss.af3.task.model.TaskArchitecture;
+import org.fortiss.tooling.base.model.element.IConnection;
+import org.fortiss.tooling.base.model.element.IConnector;
+import org.fortiss.tooling.base.model.element.IHierarchicElement;
+import org.fortiss.tooling.base.model.element.IModelElement;
+import org.jgrapht.DirectedGraph;
+import org.jgrapht.Graphs;
+import org.jgrapht.alg.ConnectivityInspector;
+import org.jgrapht.graph.DefaultDirectedGraph;
+import org.jgrapht.graph.DefaultEdge;
+
+/**
+ * Adapter to the system model used as input for the DSE which is created for a specific DSE run.
+ *
+ * @author barner, huang
+ */
+public class DeprecatedSystemModelAdapter<C, E, S, G, TR, M> {
+
+ /**
+ * Constant defining the allowed tolerance for the calculation of the greatest common divisor
+ * used in the calculation of the effective periods.
+ */
+ protected final static int GCD_PRECISION = 3;
+
+ /** Logical architecture of this {@link DeprecatedSystemModelAdapter}. */
+ protected ILogicalArchitectureAdapter<?> logicalArchitecture;
+
+ /** Platform architecture of this {@link DeprecatedSystemModelAdapter}. */
+ protected IPlatformArchitectureAdapter<?> platformArchitecture;
+
+ /**
+ * Input models that can be retrieved via {@code this} {@link DeprecatedSystemModelAdapter}. It
+ * references
+ * the original
+ */
+ protected SubClassToInstanceMap<EObject> inputModels = MutableSubClassToInstanceMap.create();
+
+ /** Deployable software components, to be mapped to deployment targets provided by platform. */
+ protected Collection<ITaskAdapter<C>> deployableComponents;
+
+ /** Collection of deployable components from the base model. */
+ protected Collection<C> deployableComponentObjects;
+
+ /**
+ * Look up table to determine the input/output directions of {@link IConnector} types of the
+ * target {@link PlatformArchitecture}.
+ */
+ protected Map<Class<? extends IConnector>, ConnectionType> connectionTypeLUT;
+
+ /**
+ * Deployable software components that may be replicated (per default: all @{code
+ * deployableComponent}s.
+ */
+ protected Collection<ITaskAdapter<C>> replicableComponents;
+
+ /** Schedulable software components, to be scheduled by the internal scheduling algorithm. */
+ protected Collection<ITaskAdapter<C>> schedulableComponents = new ArrayList<>();
+
+ /**
+ * Collection of software components that will be actually executed. This includes realizations
+ * of "abstract" software components (-> interfaces) that are contained in the
+ * {@code deployableComponents} collection.
+ */
+ protected Collection<ITaskAdapter<C>> realizableDeployableComponents;
+
+ /**
+ * Deployment targets, i.e. the execution units of the target platform, where deployable
+ * software components will be mapped to.
+ */
+ protected Collection<IExecutionUnitAdapter<E>> deploymentTargets;
+
+ /** Channels that define the (allowed) data exchange between logical components. */
+ protected Collection<ISignalAdapter<S>> messages;
+
+ /** All {@link ExecutionUnit}s that are present in the target platform. */
+ protected Collection<IExecutionUnitAdapter<E>> allPresentExecutionUnits;
+
+ /** {@link Collection} of memories present in the system. */
+ protected Collection<IMemoryUnitAdapter<M>> memoryUnits;
+
+ /**
+ * Gateway units that are employed to manage the communication between multiple networks
+ * (connecting the same or different layers).
+ */
+ protected Collection<IGatewayUnitAdapter<G>> gatewayUnits;
+
+ // TODO Consider more than one transmission unit
+ /** TDMA arbitrated transmission unit */
+ protected Collection<ITransmissionUnitAdapter<TR>> transmissionUnits;
+
+ /** Contains all available communication resources of the platform. */
+ protected Collection<ICommunicationResourceAdapter<TR>> availableCommunicationResource;
+
+ /** Contains all resources that are available in the given platform. */
+ protected Collection<IResourceAdapter<?>> availableResources;
+
+ /**
+ * Contains all deployment target resources, i.e. the deployment targets and their
+ * interconnects.
+ */
+ protected Collection<IResourceAdapter<?>> deploymentTargetResources;
+
+ /** Contains the connections between the {@link IResourceAdapter}s of the platform. */
+ private Collection<IResourceConnectionAdapter> deploymentTargetConnectors;
+
+ /**
+ * Collection of the safety functions adapters that represent the safety functions from the
+ * input models.
+ */
+ protected Collection<ISafetyFunctionAdapter<C>> safetyFunctionAdapters = new ArrayList<>();
+
+ /** The {@link PlatformCommunicationGraphEncoding} that is given by the current platform. */
+ protected PlatformCommunicationGraphEncoding platformCommunicationGraph;
+
+ /** The set of independent {@link DefaultTaskGraph}s derived from the logical architecture. */
+ protected Collection<TaskGraph> taskGraphs;
+
+ /**
+ * The set of independent directed acyclic {@link DefaultTaskGraph}s derived from the logical
+ * architecture.
+ */
+ protected Collection<AcyclicTaskGraph> acyclicTaskGraphs;
+
+ /** The "messages" emitted by the sender {@link ITaskAdapter}. */
+ protected Map<ITaskAdapter<C>, Collection<ISignalAdapter<S>>> emittedMessagesBySender;
+
+ /** Hyper-period of independent tasks graphs */
+ protected Double hyperPeriod;
+
+ /**
+ * Map: deployable component (= task) -> corresponding (independent, connected)
+ * {@link DefaultTaskGraph}.
+ */
+ protected Map<ITaskAdapter<C>, TaskGraph> componentInGraph;
+
+ /**
+ * Map: deployable component (= task) -> corresponding (independent, connected)
+ * {@link AcyclicTaskGraph}.
+ */
+ protected Map<ITaskAdapter<C>, AcyclicTaskGraph> componentInAcyclicGraph;
+
+ /**
+ * Mapping virtual resource -> hardware resource onto which virtual resource is (statically)
+ * mapped, e.g., partition -> hardware execution unit / processor core.
+ *
+ * The virtual resources are considered as deployment targets where {@link IRequestAdapter}s can
+ * be allocated to.
+ *
+ * However, deployment targets running on the same core share the same time line.
+ * Hence,a map between the deployment targets and the "time line" is maintained which
+ * will be considered during scheduling to separate partitions in time.
+ */
+ protected Map<IResourceAdapter<?>, IResourceAdapter<?>> virtualResourceToHardwareResourceMap;
+
+ /** Defines the fault containment region defined for the target {@link PlatformArchitecture}. */
+ protected Class<? extends IPlatformResource> faultContainmentRegion;
+
+ /**
+ * Maintains a map of {@link IExplorationEncoding}s that can be provided by {@code this}
+ * {@link DeprecatedSystemModelAdapter} by their corresponding types.
+ */
+ private Map<Class<? extends IExplorationEncoding>, IExplorationEncoding> inputEncodings =
+ new HashMap<>();
+
+ /** Registers a given input encoding with {@code this} {@link DeprecatedSystemModelAdapter}. */
+ protected <T extends IExplorationEncoding> void registerInputEncoding(T encoding) {
+ @SuppressWarnings("unchecked") Class<T> encodingType = (Class<T>)encoding.getClass();
+ assert (!inputEncodings.containsKey(
+ encodingType)) : "You are trying to add an encoding to the input encoding whose type is already registered. This is not supported";
+ inputEncodings.put(encodingType, encoding);
+ }
+
+ /** Returns the input encoding of the given type. */
+ @SuppressWarnings("unchecked")
+ public <T extends IExplorationEncoding> T getInputEncoding(Class<T> encodingType) {
+ return (T)inputEncodings.get(encodingType);
+ }
+
+ /**
+ * Returns the collection of {@link IExplorationEncoding} types that are availably through
+ * {@code this} {@link DeprecatedSystemModelAdapter}.
+ */
+ public Set<Class<? extends IExplorationEncoding>> getRegisteredEncodingTypes() {
+ return inputEncodings.keySet();
+ }
+
+ /**
+ * Returns the input models accessible via {@code this} {@link DeprecatedSystemModelAdapter}.
+ */
+ public SubClassToInstanceMap<EObject> getInputModels() {
+ return inputModels;
+ }
+
+ /**
+ * Adds the given model to the input models that can be obtained via {@code this}
+ * {@link DeprecatedSystemModelAdapter}.
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends EObject> void putInputModel(Class<? extends T> modelType, T inputModel) {
+ inputModels.putInstance((Class<T>)modelType, inputModel);
+ }
+
+ /**
+ * Creates and registers an {@link AbstractTaskGraphEncoding} with @code this}
+ * {@link DeprecatedSystemModelAdapter}.
+ */
+ protected void createAbstractTaskGraphEncoding() {
+ // AbstractTaskGraphEncoding<AbstractTaskMappingEncoding, C> atgEnc =
+ // new AbstractTaskGraphEncoding<>(this);
+ // registerInputEncoding(atgEnc);
+ }
+
+ /**
+ * Setups the list of {@link ITaskAdapter}s that are scheduleable by a
+ * time-triggered scheduler.
+ */
+ protected void setupScheduleableComponents() {
+ for(ITaskAdapter<C> comp : deployableComponents) {
+ if(comp.getTimingRequirementPeriod() != null) {
+ schedulableComponents.add(comp);
+ }
+ }
+ }
+
+ // TODO: Make the task graph setup independent from the AF3-Component Architecture and write a
+ // wrapper in the specific AF3 SystemModelAdapter.
+ /**
+ * Sets up the {@link DefaultTaskGraph}s for all (independent) connected sub-component
+ * model contained in the logical {@link ComponentArchitecture}. This method
+ * also determines the hyper-period of all {@link DefaultTaskGraph}s.
+ *
+ * @throws Exception
+ */
+ protected void setupTaskGraphs() throws Exception {
+ // - Add data dependencies to {@link TaskGraph}s
+ // - Print some debugging output
+ // - Determine the hyper-period of all {@link TaskGraph}s contained in this {@link
+ // SystemModelAdapter}.
+ taskGraphs = new ArrayList<TaskGraph>();
+ acyclicTaskGraphs = new ArrayList<>();
+
+ // Temporary task graph: add vertices (= software components / tasks that need to be mapped
+ // to processing elements, and that potentially require data from other software components)
+ DefaultTaskGraph<?> temporaryTaskGraph = new DefaultTaskGraph<>();
+ // createTaskForrest();
+ for(ITaskAdapter<?> deployableComponent : deployableComponents) {
+ temporaryTaskGraph.addTask(deployableComponent);
+ }
+ // Temporary task graph: add edges
+ addDataDependenciesToTaskGraph(temporaryTaskGraph);
+
+ // Separate temporary task graph into multiple TaskGraphs that consist of exactly one
+ // connected graph component. I.e., there are no data dependencies between the resulting new
+ // TaskGraphs.
+ // TODO: handle the removal of taskgraphs in another way. Throw an exception / display an
+ // error for inconsistent period specifications?
+
+ // Create a generic TaskGraph of the logical architecture (can contain cycles)
+ taskGraphs = createDefaultTaskGraphs(temporaryTaskGraph);
+ // removeInvalidTaskGraphs(taskGraphs);
+ componentInGraph = registerTaskGraphsForComponents(taskGraphs);
+
+ // Construct an Directed Acyclic TaskGraph (e.g., utilized in scheduling).
+ acyclicTaskGraphs = taskGraphs.stream().map(tg -> new AcyclicTaskGraph(tg))
+ .collect(Collectors.toList());
+ removeInvalidTaskGraphs(acyclicTaskGraphs);
+ componentInAcyclicGraph = registerTaskGraphsForComponents(acyclicTaskGraphs);
+
+ // Print some debugging output: print the taskgraphs and display them in a dialog.
+ if(isDebugVerboseEnabled()) {
+ printAndDisplayTaskGraphs(taskGraphs);
+ printAndDisplayTaskGraphs(acyclicTaskGraphs);
+ }
+
+ Collection<TaskGraph> allTaskGraphs = new ArrayList<TaskGraph>();
+ allTaskGraphs.addAll(taskGraphs);
+ allTaskGraphs.addAll(acyclicTaskGraphs);
+ hyperPeriod = determineHyperPeriod(allTaskGraphs);
+ }
+
+ /**
+ * Creates a set of independent {@link TaskGraph}s of the given type ({#link graphClass}). The
+ * subgraphs may have different implementation to construct themselves (via
+ * addDataDependencies).
+ *
+ * @throws InvalidTimingModelException
+ * if the periods for a single task graph cannot be set up.
+ */
+ private Collection<TaskGraph> createDefaultTaskGraphs(TaskGraph monolithicTaskGraph)
+ throws InvalidTimingModelException {
+ Collection<TaskGraph> independentTaskGraphs = new ArrayList<>();
+
+ // Compute vertex sets of maximum connected components of temporary task graph
+ ConnectivityInspector<ITaskAdapter<?>, ChannelAdapterWeightedEdge> ci =
+ new ConnectivityInspector<ITaskAdapter<?>, ChannelAdapterWeightedEdge>(
+ monolithicTaskGraph.getGraph());
+ List<Set<ITaskAdapter<?>>> connectedSets = ci.connectedSets();
+ // Reconstruct TaskGraphs from vertex sets of connected components
+ for(Set<ITaskAdapter<?>> connectedSet : connectedSets) {
+ TaskGraph taskGraph = new DefaultTaskGraph<>();
+ Graphs.addAllVertices(taskGraph.getGraph(), connectedSet);
+
+ for(ISignalAdapter<?> message : messages) {
+ if(connectedSet.contains(message.getSource()) && !message.getTargets().isEmpty()) {
+ taskGraph.addDataDependency(message.getSource(), message.getTargets(), message);
+ }
+ }
+
+ // Check if tasks within current sub TaskGraph share the same common period
+ taskGraph.updatePeriod();
+ independentTaskGraphs.add(taskGraph);
+ }
+ return independentTaskGraphs;
+ }
+
+ /**
+ * Adds the given collection of {@link ISafetyFunctionAdapter}s to {@code this}
+ * {@link DeprecatedSystemModelAdapter} that represents the input system models. In contrast to
+ * other
+ * input parameters, the {@link ISafetyFunctionAdapter}s are created dynamically if a
+ * safety constraint is present which results in the safety functions to be
+ * extracted <b>after</b> the {@link DeprecatedSystemModelAdapter} has been constructed.
+ * <p>
+ * This method updates the set of replicable components by removing those components that are
+ * referenced by the safety function.
+ */
+ // TODO: remove the enclosed cast. The difficulty is that the ISafetyFunctionAdapters are added
+ // from within the DSE where the system types are not known any more.
+ // It would be more appropriate to shift this addition before launching the DSE.
+ @SuppressWarnings({"unchecked", "rawtypes"})
+ public void
+ addSafetyFunctionAdapters(Collection<ISafetyFunctionAdapter> safetyFunctionAdapters) {
+ if(safetyFunctionAdapters == null) {
+ return;
+ }
+ this.safetyFunctionAdapters
+ .addAll((Collection<? extends ISafetyFunctionAdapter<C>>)safetyFunctionAdapters);
+
+ for(ISafetyFunctionAdapter<?> sfAdapter : safetyFunctionAdapters) {
+ replicableComponents.removeAll(sfAdapter.getDiagnosticComponents());
+ replicableComponents.removeAll(sfAdapter.getRealizingComponents());
+ replicableComponents.remove(sfAdapter.getOutputComponent());
+ }
+ }
+
+ /**
+ * Creates a map for the given collection of {@link TaskGraph}s which allows to identify the
+ * {@link TaskGraph} that contains the given {@link ITaskAdapter} as a vertex.
+ */
+ // TODO: Here, we know that the IDeployableCOmponentAdapters are constructed using Components.
+ // However, we should try to avoid the "SuppressWarnings".
+ @SuppressWarnings("unchecked")
+ private <T extends TaskGraph> Map<ITaskAdapter<C>, T>
+ registerTaskGraphsForComponents(Collection<T> graphs) {
+ Map<ITaskAdapter<C>, T> componentToGraphMap = new HashMap<ITaskAdapter<C>, T>();
+
+ for(T taskGraph : graphs) {
+ for(ITaskAdapter<?> deployableComponent : taskGraph.getGraph().vertexSet()) {
+ componentToGraphMap.put((ITaskAdapter<C>)deployableComponent, taskGraph);
+ }
+ }
+
+ return componentToGraphMap;
+ }
+
+ /**
+ * For a given collection of {@link TaskGraph}s this method removes all the {@link TaskGraph}s
+ * from the given collection and the contained {@link ITaskAdapter}s from the set
+ * of deployable components if the corresponding {@link TaskGraph} has a non-strictly positive
+ * hyperperiod.
+ */
+ private <T extends TaskGraph> void removeInvalidTaskGraphs(Collection<T> taskGraphs) {
+ Set<ITaskAdapter<?>> tasksToBeRemoved = new HashSet<ITaskAdapter<?>>();
+ Collection<T> graphsToBeRemoved = new HashSet<T>();
+ // for(T currentGraph : taskGraphs) {
+ // if(currentGraph.getPeriod() <= 0) {
+ // // No valid period specification: TaskGraph cannot be mapped.
+ // tasksToBeRemoved.addAll((currentGraph).getTasks());
+ // graphsToBeRemoved.add(currentGraph);
+ // System.out.println("No valid period specification: TaskGraph cannot be mapped.");
+ // System.out.println(currentGraph);
+ // }
+ // }
+
+ // TODO: Move these checks to a model validation framework
+ // Remove tasks with invalid specification
+ if(!tasksToBeRemoved.isEmpty()) {
+ System.out.println(
+ "The following deployable components are ignored during design exploration due to lack of timing annotations.");
+ System.out.println(
+ "Each deployable component must be annotated with delay (execution time) and the source commpoent must be annotated with a period!");
+ for(ITaskAdapter<?> deployableComponent : tasksToBeRemoved) {
+ System.out.print(deployableComponent.getName() + " , ");
+ deployableComponents.remove(deployableComponent);
+ }
+ for(T currentGraph : graphsToBeRemoved) {
+ taskGraphs.remove(currentGraph);
+ }
+ System.out.print("\n");
+ }
+
+ }
+
+ /**
+ * Calculates and returns the hyperperiod of the set of all given {@link TaskGraph}s by
+ * calculating the least common multiple from the hyperperiods of the {@link TaskGraph}s.
+ */
+ private Double determineHyperPeriod(Collection<TaskGraph> allTaskGraphs) {
+ Set<Double> taskgraphPeriods = new TreeSet<Double>();
+ for(TaskGraph currentGraph : allTaskGraphs) {
+ Double period = currentGraph.getPeriod();
+ if(period != null && period > 0) {
+ taskgraphPeriods.add(period);
+ }
+ }
+
+ if(taskgraphPeriods.isEmpty()) {
+ return null;
+ }
+ return lcmDoubleCollection(taskgraphPeriods, GCD_PRECISION);
+ }
+
+ /**
+ * Prints the given collection of {@link TaskGraph}s to the standard output and displays them in
+ * a separate dialog.
+ */
+ private <T extends TaskGraph> void printAndDisplayTaskGraphs(Collection<T> taskGraphs) {
+ for(T taskGraph : taskGraphs) {
+ System.out.println(
+ "Application " + taskGraph + ":" + " period = " + taskGraph.getPeriod());
+ System.out.println(taskGraph);
+ System.out.println("");
+
+ // Open a dialog for the visualization of the TaskGraph
+ taskGraph.display();
+ }
+ }
+
+ /**
+ * Add edges to a {@link TaskGraph} that describe the data dependencies between the software
+ * components of the logical {@link ComponentArchitecture}.
+ *
+ * @throws Exception
+ */
+ private void addDataDependenciesToTaskGraph(DefaultTaskGraph<?> taskGraph) throws Exception {
+
+ // TODO: Currently, top-level components are considered as deployable components (=tasks)
+ for(ISignalAdapter<?> channelAdapter : messages) {
+
+ ITaskAdapter<?> sourceDeployableComponent = channelAdapter.getSource();
+ Collection<ITaskAdapter<?>> targetDeployableComponents = channelAdapter.getTargets();
+
+ if(sourceDeployableComponent != null && !(targetDeployableComponents.isEmpty())) {
+ taskGraph.addDataDependency(sourceDeployableComponent, targetDeployableComponents,
+ channelAdapter);
+ }
+ }
+ }
+
+ /**
+ * Creates the {@link PlatformCommunicationGraphEncoding} that is used to determine the routing
+ * of
+ * messages between {@link ITaskAdapter}s and their respective
+ * {@link IExecutionUnitAdapter}s.
+ */
+ protected void setupPlatformGraph() {
+ // platformCommunicationGraph = new PlatformCommunicationGraphEncoding(this, createGraph());
+ }
+
+ /**
+ * Creates the communication (or connection) graph which is implicitly given by the platform
+ * referenced in the {@link DeprecatedSystemModelAdapter}. This graph is used for routing
+ * messages.
+ */
+ public DirectedGraph<IResourceAdapter<?>, DefaultEdge> createGraph() {
+ DirectedGraph<IResourceAdapter<?>, DefaultEdge> tempPlatformCommGraph =
+ new DefaultDirectedGraph<IResourceAdapter<?>, DefaultEdge>(DefaultEdge.class);
+ DirectedGraph<IResourceAdapter<?>, DefaultEdge> platformGraph =
+ new DefaultDirectedGraph<IResourceAdapter<?>, DefaultEdge>(DefaultEdge.class);
+
+ // Add all resources present in the platform as vertices to the "connection graph"
+ for(IResourceAdapter<?> resource : getDeploymentTargets()) {
+ tempPlatformCommGraph.addVertex(resource);
+ }
+ for(IResourceAdapter<?> resource : getMemoryUnits()) {
+ tempPlatformCommGraph.addVertex(resource);
+ }
+ for(IResourceAdapter<?> resource : getGatewayUnits()) {
+ tempPlatformCommGraph.addVertex(resource);
+ }
+ for(IResourceAdapter<?> resource : getTransmissionUnits()) {
+ tempPlatformCommGraph.addVertex(resource);
+ }
+
+ // Successively connect the resources in the graph. The edges are given within the
+ // collection resource connectors are assumed to be fully connected.
+ for(IResourceConnectionAdapter connection : getDeploymentTargetConnectors()) {
+ // We add edges for each receiver in order to support broadcast connections
+ for(IResourceAdapter<?> currentReceiverResource : connection.getTargetResources()) {
+ // If the current resource is a child of a {@link TransmissionUnit} (like a NoC
+ // router), respect the direction of connections such that complex networks are
+ // correctly reflected.
+ if(connection
+ .getConnectionType(currentReceiverResource) == ConnectionType.OUTGOING) {
+ Graphs.addEdgeWithVertices(platformGraph, connection.getSourceResource(),
+ currentReceiverResource);
+ } else if(connection
+ .getConnectionType(currentReceiverResource) == ConnectionType.INCOMING) {
+ Graphs.addEdgeWithVertices(platformGraph, currentReceiverResource,
+ connection.getSourceResource());
+ } else {
+ // Add the edges of a single connection. We add to edges for each connection
+ // such that an undirected graph is generated effectively. It is required to use
+ // this "trick" in order to be able to use the standard shortest path
+ // algorithms.
+ Graphs.addEdgeWithVertices(platformGraph, connection.getSourceResource(),
+ currentReceiverResource);
+ Graphs.addEdgeWithVertices(platformGraph, currentReceiverResource,
+ connection.getSourceResource());
+ }
+ }
+ }
+
+ return platformGraph;
+ }
+
+ /**
+ * Setups the {#link emittedMessagesBySender} map which makes it possible to easily identify the
+ * {@link ISignalAdapter}s that are emitted by the given {@link ITaskAdapter}.
+ */
+ protected void setupEmittedMessages() {
+ emittedMessagesBySender = new HashMap<ITaskAdapter<C>, Collection<ISignalAdapter<S>>>();
+
+ for(ITaskAdapter<C> currentSender : deployableComponents) {
+ Collection<ISignalAdapter<S>> emittedMessages = new ArrayList<ISignalAdapter<S>>();
+ for(ISignalAdapter<S> currentMessage : messages) {
+ if(currentSender == currentMessage.getSource()) {
+ emittedMessages.add(currentMessage);
+ }
+ }
+ emittedMessagesBySender.put(currentSender, emittedMessages);
+ }
+ }
+
+ /**
+ * Returns the logical architecture that is associated with this
+ * {@link DeprecatedSystemModelAdapter}.
+ */
+ public ILogicalArchitectureAdapter<?> getLogicalArchitecture() {
+ return logicalArchitecture;
+ }
+
+ /**
+ * Returns the platform architecture (Middleware/HW) that is associated with this
+ * {@link DeprecatedSystemModelAdapter}.
+ */
+ public IPlatformArchitectureAdapter<?> getPlatformArchitecture() {
+ return platformArchitecture;
+ }
+
+ /**
+ * Returns the deployable (software) component from the original logical architecture. May
+ * contain "abstract" {@link Component}s.
+ */
+ public Collection<ITaskAdapter<C>> getDeployableComponents() {
+ return deployableComponents;
+ }
+
+ /**
+ * Returns the deployable (software) component from the original logical architecture that my be
+ * replicated. May contain "abstract" {@link Component}s.
+ */
+ public Collection<ITaskAdapter<C>> getReplicableComponents() {
+ return replicableComponents;
+ }
+
+ /**
+ * Returns the scheduleable (software) component from the original logical architecture. May
+ * contain "abstract" {@link Component}s.
+ */
+ public Collection<ITaskAdapter<C>> getScheduleableComponents() {
+ return schedulableComponents;
+ }
+
+ /**
+ * Returns the deployable (software) components that can be actually executed on
+ * {@link ExecutionUnit}s, i.e. software components that are backed by an implementation.
+ */
+ public Collection<ITaskAdapter<C>> getRealizableDeployableComponents() {
+ return realizableDeployableComponents;
+ }
+
+ // TODO: Consider implementing this method as a map, since this operation is run often?
+ /**
+ * Returns the {@link ITaskAdapter} that is constructed form the given object.
+ *
+ * @param originalEObject
+ * The object for which the corresponding {@link ITaskAdapter} shall
+ * be identified.
+ * @return The asociated {@link ITaskAdapter}, or {@code null} if none can be
+ * identified.
+ */
+ public synchronized ITaskAdapter<C> getDeployableComponentOf(EObject originalEObject) {
+ // FIXME: HACK to work around the missing consideration of the Task Architecture ATM.
+ if(originalEObject instanceof Task) {
+ TaskArchitecture ta = (TaskArchitecture)((Task)originalEObject).getContainer();
+ Collection<Component> cCol = getAllocatedComponentsTo(ta, (Task)originalEObject);
+ originalEObject = cCol.iterator().next();
+ }
+
+ for(ITaskAdapter<C> deployableComponentAdapter : deployableComponents) {
+ if(deployableComponentAdapter.getObject() == originalEObject) {
+ return deployableComponentAdapter;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns the {@link ITaskAdapter} that wraps the given {@link EObject}. Here,
+ * only those {@link ITaskAdapter} are searched which can be actually executed on
+ * {@link ExecutionUnit}s, i.e. "abstract" components are not considered.
+ */
+ public synchronized ITaskAdapter<C>
+ getRealizeableDeployableComponentOf(EObject originalEObject) {
+ for(ITaskAdapter<C> deployableComponentAdapter : realizableDeployableComponents) {
+ if(deployableComponentAdapter.getObject() == originalEObject) {
+ return deployableComponentAdapter;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns the {@link ISignalAdapter} corresponding the sender and receiver {@link Component}.
+ * Returns null if no channel exists between the two given components.
+ */
+ public synchronized ISignalAdapter<S> getChannelAdapter(ITaskAdapter<C> source,
+ ITaskAdapter<C> target) {
+ // TODO: Currently, top-level components are considered as deployable components (=tasks)
+ for(ISignalAdapter<S> currentChannel : messages) {
+ if(currentChannel.getSource() == source &&
+ currentChannel.getTargets().contains(target)) {
+ return currentChannel;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the deployment targets, i.e. the execution units of the target platform,
+ * where deployable software components will be mapped to.
+ */
+ public Collection<IExecutionUnitAdapter<E>> getDeploymentTargets() {
+ return deploymentTargets;
+ }
+
+ /** Returns the {@link IMemoryUnitAdapter} present in the target platform. */
+ public Collection<IMemoryUnitAdapter<M>> getMemoryUnits() {
+ return memoryUnits;
+ }
+
+ /** Returns the gateway units present in the platform. */
+ public Collection<IGatewayUnitAdapter<G>> getGatewayUnits() {
+ return gatewayUnits;
+ }
+
+ /** Returns the systems TDMA arbitrated transmission unit */
+ public Collection<ITransmissionUnitAdapter<TR>> getTransmissionUnits() {
+ return transmissionUnits;
+ }
+
+ /** Returns all the {@link IResourceAdapter}s present in the platform. */
+ public Collection<IResourceAdapter<?>> getAvailableResources() {
+ return availableResources;
+ }
+
+ /**
+ * Returns the hardware resource (e.g., processor core) onto which a virtual resource
+ * (e.g. partition) is (statically) mapped.
+ */
+ public IResourceAdapter<?> getHardwareResource(IResourceAdapter<?> virtualResource) {
+ return virtualResourceToHardwareResourceMap.get(virtualResource);
+ }
+
+ /**
+ * Returns the {@link ISafetyFunctionAdapter}s constructed from the safety functions that are
+ * present in the input models.
+ */
+ public Collection<ISafetyFunctionAdapter<C>> getSafetyFunctionAdapters() {
+ if(safetyFunctionAdapters != null) {
+ return safetyFunctionAdapters;
+ }
+ return Collections.emptySet();
+ }
+
+ /**
+ * Returns the {@link PlatformCommunicationGraphEncoding} required for routing of the messages
+ * located
+ * in different parts of the platform.
+ */
+ public PlatformCommunicationGraphEncoding getPlatformCommunicationGraph() {
+ return platformCommunicationGraph;
+ }
+
+ /**
+ * Returns the {@link TaskGraph}s of the demanded type that has been constructed by {@code this}
+ * {@link DeprecatedSystemModelAdapter}, if any exists. Otherwise, an empty collection is
+ * returned.
+ */
+ @SuppressWarnings("unchecked")
+ public <T extends TaskGraph> Collection<T> getTaskGraphsByType(Class<T> tgType) {
+ if(DefaultTaskGraph.class.isAssignableFrom(tgType)) {
+ return (Collection<T>)getTaskGraphs();
+ } else if(AcyclicTaskGraph.class.isAssignableFrom(tgType)) {
+ return (Collection<T>)getAcyclicTaskGraphs();
+ }
+ return Collections.emptySet();
+ }
+
+ /**
+ * Returns all independent {@link DefaultTaskGraph}s contained in this
+ * {@link DeprecatedSystemModelAdapter}.
+ */
+ public Collection<? extends TaskGraph> getTaskGraphs() {
+ return taskGraphs;
+ }
+
+ /**
+ * Returns all independent {@link DefaultTaskGraph}s contained in this
+ * {@link DeprecatedSystemModelAdapter}.
+ */
+ public Collection<? extends TaskGraph> getAcyclicTaskGraphs() {
+ return acyclicTaskGraphs;
+ }
+
+ /**
+ * Returns the {@link DefaultTaskGraph} in which a given deployable component (=task) is
+ * contained.
+ */
+ public TaskGraph getTaskGraph(ITaskAdapter<?> deployableComponent) {
+ return componentInGraph.get(deployableComponent);
+ }
+
+ /**
+ * Returns the {@link DefaultTaskGraph} in which a given deployable component (=task) is
+ * contained.
+ */
+ public DefaultTaskGraph<?> getAcyclicTaskGraph(ITaskAdapter<?> deployableComponent) {
+ return componentInAcyclicGraph.get(deployableComponent);
+ }
+
+ /**
+ * Returns the {@link ISignalAdapter}s "emitted" by the given
+ * {@link ITaskAdapter}. Returns an empty collection if the given
+ * {@link ITaskAdapter} does not emit anything.
+ */
+ public Collection<ISignalAdapter<S>> getEmmittedMessages(ITaskAdapter<?> sender) {
+ // TODO: use another representation ro make an access via the reference obsolete
+ if(sender.isInstantiation()) {
+ sender = sender.getReplacedComponent();
+ }
+ // TODO: replace by map or similar.
+ ITaskAdapter<?> origSender = getDeployableComponentOf((EObject)sender.getObject());
+ return emittedMessagesBySender.get(origSender);
+ }
+
+ /**
+ * Returns the hyper period of all tasks in the system, i.e. the hyper-period of all independent
+ * {@link DefaultTaskGraph}s.
+ */
+ public Double getHyperPeriod() {
+ return hyperPeriod;
+ }
+
+ /** Returns whether the given {@link Component} is a deployable {@link Component}. */
+ public boolean isDeployableComponent(Component component) {
+ return deployableComponentObjects.contains(component);
+ }
+
+ /** Returns the input output behavior of the given platform connector. */
+ public ConnectionType getConnectionType(Class<? extends IConnector> connector) {
+ return connectionTypeLUT.get(connector);
+ }
+
+ // ===============================================================
+ // To be removed / generalized
+ // ===============================================================
+
+ /**
+ * <p>
+ * Determines the effective target {@link IConnector}s of a given "source" {@link IConnector}.
+ * Elements/{@link IConnector}s that are irrelevant to communication within the platform are not
+ * added to the target list. Instead, the connectors that are accessible by the source
+ * {@link IConnector} are traversed until relevant targets are identified, like
+ * {@link ExecutionUnit}s selected for the deployment.
+ * </p>
+ * <p>
+ * <b>NOTE:</b> This method may return targets that are not directly involved in the
+ * communication between {@link ExecutionUnit}s. However, 'hull' elements (or similar elements)
+ * that may "disturb" the communication between {@link ExecutionUnit}s will not appear.
+ * </p>
+ * <p>
+ * <b>Implementation Note:</b> The <i>valid</i> targets are determined via path walk following
+ * all connections from the source {@link IConnector} until <i>valid</i> targets are found.
+ * </p>
+ *
+ * @throws Exception
+ * if the references between the {@link IModelElement}s are incorrectly specified.
+ */
+ protected Collection<IConnector> getEffectiveConnectionTargets(IConnector sourceConnector,
+ Collection<ExecutionUnit> af3DeploymentTargets) throws Exception {
+ Collection<IConnector> targetConnectors = new HashSet<IConnector>();
+ if(sourceConnector == null) {
+ return targetConnectors;
+ }
+
+ LinkedList<IConnector> possibleTargetConnectors = new LinkedList<IConnector>();
+ Collection<IConnector> visitedTargetConnectors = new HashSet<IConnector>();
+
+ possibleTargetConnectors.add(sourceConnector);
+ while(!possibleTargetConnectors.isEmpty()) {
+ IConnector nextTargetConnector = possibleTargetConnectors.poll();
+
+ // This section handles the traversal between the elements of the same platform
+ // architecture.
+ targetConnectors.addAll(
+ seekIntraPlatformTargetConnectors(sourceConnector, possibleTargetConnectors,
+ visitedTargetConnectors, nextTargetConnector, af3DeploymentTargets));
+
+ visitedTargetConnectors.add(nextTargetConnector);
+ }
+
+ return targetConnectors;
+ }
+
+ /**
+ * Identifies those {@link IConnector}s that are actual target {@link IConnector}s of data sent
+ * out by the given {@code sourceConnector}. This methos is needed as in a
+ * {@link PlatformArchitecture}, there exist {@link IConnector}s which are attached to container
+ * elements that are not backed by physical interface ports (These are represented by the
+ * contained elements).
+ *
+ * @param sourceConnector
+ * Source {@link IConnector} for which the target {@link IConnector}s need to be
+ * identified.
+ * @param possibleTargetConnectors
+ * List to which those {@link IConnector}s are added that are directly connected to
+ * the {@code sourceConnector} but are no "communication targets" as described above
+ * an need further traversal.
+ * @param visitedTargetConnectors
+ * Set of already traversed connectors (to avoid loops).
+ * @param nextTargetConnector
+ * Current {@link IConnector} whose target {@link IConnector}s need to be searched.
+ * @param deploymentTargets
+ * Set of execution units present on the target platform.
+ * @return Collection of {@link IConnector}s that are actual target {@link IConnector}s of the
+ * {@code sourceConnector}.
+ */
+ @Deprecated
+ protected Collection<IConnector> seekIntraPlatformTargetConnectors(IConnector sourceConnector,
+ LinkedList<IConnector> possibleTargetConnectors,
+ Collection<IConnector> visitedTargetConnectors, IConnector nextTargetConnector,
+ Collection<ExecutionUnit> deploymentTargets) {
+ Collection<IConnector> targetConnectors = new ArrayList<IConnector>();
+
+ Collection<IConnection> attachedConnections = new ArrayList<IConnection>();
+ attachedConnections.addAll(nextTargetConnector.getOutgoing());
+ attachedConnections.addAll(nextTargetConnector.getIncoming());
+
+ for(IConnection connToTarget : attachedConnections) {
+ IConnector connectorTgt = null;
+ IConnector connectorSrc = null;
+ if(connToTarget.getTarget().getOwner() != nextTargetConnector.getOwner()) {
+ connectorTgt = connToTarget.getTarget();
+ connectorSrc = connToTarget.getSource();
+ }
+ if(connToTarget.getSource().getOwner() != nextTargetConnector.getOwner()) {
+ connectorTgt = connToTarget.getSource();
+ connectorSrc = connToTarget.getTarget();
+ }
+ if(connectorTgt == null || connectorSrc == null) {
+ throw new RuntimeException(
+ "Error: \"floating\" connection found during transformation for the DSE.");
+ }
+
+ IHierarchicElement tgtElement = connectorTgt.getOwner();
+ // Do not traverse back (to same connector) & not to the same IHierarchicElement.
+ if(!visitedTargetConnectors.contains(connectorTgt) &&
+ tgtElement != sourceConnector.getOwner()) {
+ if(tgtElement instanceof IPlatformArchitectureElement && isValidConnectionTarget(
+ (IPlatformArchitectureElement)tgtElement, deploymentTargets)) {
+ targetConnectors.add(connectorTgt);
+ } else if(tgtElement == connectorSrc.getOwner().getContainer() &&
+ !(nextTargetConnector instanceof IPlatformExport)) {
+ // Treatment of hull ports: Do not walk a path that would just traverse a 'hull'
+ // port. Hence, just consider the ports to the "outside" (upper level).
+ for(IConnection currConn : connectorTgt.getOutgoing()) {
+ IConnector currTgtConnector = currConn.getTarget();
+ if(currTgtConnector.getOwner().getContainer() != tgtElement) {
+ if(tgtElement instanceof IPlatformArchitectureElement &&
+ isValidConnectionTarget(
+ (IPlatformArchitectureElement)currTgtConnector
+ .getOwner(),
+ deploymentTargets)) {
+ targetConnectors.add(currTgtConnector);
+ } else {
+ possibleTargetConnectors.add(currTgtConnector);
+ }
+ }
+ }
+ for(IConnection currConn : connectorTgt.getIncoming()) {
+ IConnector currTgtConnector = currConn.getSource();
+ if(currTgtConnector.getOwner().getContainer() != tgtElement) {
+ if(tgtElement instanceof IPlatformArchitectureElement &&
+ isValidConnectionTarget(
+ (IPlatformArchitectureElement)currTgtConnector
+ .getOwner(),
+ deploymentTargets)) {
+ targetConnectors.add(currTgtConnector);
+ } else {
+ possibleTargetConnectors.add(currTgtConnector);
+ }
+ }
+ }
+
+ visitedTargetConnectors.add(connectorTgt);
+ } else {
+ possibleTargetConnectors.add(connectorTgt);
+ }
+ }
+ }
+
+ return targetConnectors;
+ }
+
+ /**
+ * Determines those {@link IConnector}s (in a different {@link PlatformArchitecture} than the
+ * {@code sourceConnector}) that establish a link between between two elements of different
+ * {@link PlatformArchitecture}s and which are connected by a {@link ResourceLink}.
+ * This method is agnostic of the "direction" of the {@link ResourceLink}, i.e. it does not
+ * matter whether the {@code sourceConnector} is attached to an
+ * {@link IPlatformArchitectureElement} to which the {@link ResourceLink} is annotated or is
+ * referenced by virtual link.
+ * <p>
+ * <b>NOTE:</b> The current implementation assumes that there exist only n:1 links between
+ * {@link IModelElement}s that establish a "communication path" between different platforms
+ * (virtual -> physical).
+ *
+ * @param sourceConnector
+ * {@link IConnector} for which the target {@link IConnector}s in another platform
+ * have to be identified.
+ * @param invElementReferences
+ * Map representing all 1:1 inverse {@link ResourceLink}s.
+ * @param possibleTargetConnectors
+ * List of {@link IConnector}s to which those {@link IConnector}s are added that are
+ * located in referenced {@link PlatformArchitecture} but need to be traversed
+ * further such that valid "communication targets" are identified.
+ * @param deploymentTargets
+ * Set of execution units present on the target platform.
+ * @return List of {@link IConnector}s that a message actually traverses when being sent by the
+ * {@code sourceConnector}.
+ * @throws Exception
+ * if the references between the {@link IModelElement}s are incorrectly specified.
+ */
+ // TODO: Throw appropriate Exceptions on failure, i.e. wrong types of referenced elements etc.
+ protected Collection<IConnector> seekInterPlatformConnectors(IConnector sourceConnector,
+ Map<IModelElement, IModelElement> invElementReferences,
+ LinkedList<IConnector> possibleTargetConnectors,
+ Collection<ExecutionUnit> deploymentTargets) throws Exception {
+ Collection<IConnector> identifiedTargets = new ArrayList<IConnector>();
+
+ if(connectsSwHwPlatform(sourceConnector)) {
+ // Special treatment for the connection between the virtual
+ // platform and the physical platform.
+ IPlatformArchitectureElement referencingElement =
+ (IPlatformArchitectureElement)sourceConnector.getOwner();
+ EList<IPlatformArchitectureElement> referencedElements =
+ PlatformArchitectureUtils.getReferencedElementsWithType(referencingElement,
+ IPlatformArchitectureElement.class);
+ if(referencedElements.size() == 0) {
+ throw new Exception(
+ "No Network Interface is referenced in the ResourceLink annotation of " +
+ referencingElement.getName() +
+ ". Please specify at least one reference.");
+ }
+
+ for(IPlatformArchitectureElement currRefElem : referencedElements) {
+ if(sourceConnector.getOwner() instanceof IPlatformArchitectureElement &&
+ isValidConnectionTarget(
+ (IPlatformArchitectureElement)sourceConnector.getOwner(),
+ deploymentTargets)) {
+ identifiedTargets.add(pickFirstInstanceOf(IPlatformExport.class,
+ currRefElem.getConnectors()));
+ } else {
+ possibleTargetConnectors.addAll(currRefElem.getPlatformConnectorUnits());
+ }
+ }
+ } else if(invElementReferences.get(sourceConnector.getOwner()) != null) {
+ // Special treatment for the connection between the physical platform
+ // and the virtual platform.
+ IModelElement referencedElement = invElementReferences.get(sourceConnector.getOwner());
+ assert (referencedElement instanceof IPlatformArchitectureElement) : "A non-platform model element has been referenced.";
+ IPlatformArchitectureElement referencedPlatformElement =
+ (IPlatformArchitectureElement)referencedElement;
+ IPlatformExport driverExport = pickFirstInstanceOf(IPlatformExport.class,
+ referencedPlatformElement.getConnectors());
+
+ if(driverExport.getOwner() instanceof IPlatformArchitectureElement &&
+ isValidConnectionTarget((IPlatformArchitectureElement)driverExport.getOwner(),
+ deploymentTargets)) {
+ identifiedTargets.add(driverExport);
+ } else {
+ // TODO: dead code path? Is not called for any recent model.
+ possibleTargetConnectors
+ .addAll(referencedPlatformElement.getPlatformConnectorUnits());
+ }
+ }
+
+ return identifiedTargets;
+ }
+
+ /**
+ * Determines whether the given connector (or its containing element) is used to establish a
+ * connection between separate {@link PlatformArchitecture}s. This method is capable of
+ * identifying connections between different {@link PlatformArchitecture} even if the links are
+ * defined only for the elements of {@link PlatformArchitecture}. This feature requires a map
+ * that tracks the link between the referenced elements and the elements containing the link.
+ *
+ * @param connector
+ * {@link IConnection} to be examined for its role of connecting different
+ * {@link PlatformArchitecture}s.
+ * @param invNetDriverRef
+ * Map tracking the inverse link of inter-{@link PlatformArchitecture} links.
+ * @return Flag, if the given connector (or its containing {@link IModelElement}) connects model
+ * elements form different {@link PlatformArchitecture}s.
+ */
+ @Deprecated
+ protected boolean connectsSwHwPlatform(IConnector connector,
+ Map<IModelElement, IModelElement> invNetDriverRef) {
+ if(!connectsSwHwPlatform(connector)) {
+ if(connector != null) {
+ IHierarchicElement parent = connector.getOwner();
+ // Second: physical counter part of inter-platform connection.
+ // if(platformInterconnectTypes != null &&
+ // platformInterconnectTypes.getSecond().isAssignableFrom(parent.getClass()) &&
+ // invNetDriverRef.get(parent) != null) {
+ // return true;
+ // }
+ }
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Determines whether the given connector is used to establish a connection between separate
+ * {@link PlatformArchitecture}s.
+ * <p>
+ * <b>NOTE:</b> This method only works correctly if the given {@link IConnector} is attached to
+ * a {@link IModelElement} that has an explicit reference to an {@link IModelElement} of another
+ * {@link PlatformArchitecture}. Otherwise, use {#link connectsSwHwPlatform(IConnector,
+ * Map<NetworkInterface, OnChipNetworkDriver>)}.
+ */
+ protected boolean connectsSwHwPlatform(IConnector connector) {
+ // if(connector instanceof IPlatformExport && platformInterconnectTypes.getFirst()
+ // .isAssignableFrom(connector.getOwner().getClass())) {
+ // return true;
+ // }
+ return false;
+ }
+
+ /**
+ * Returns whether the given {@link IHierarchicElement} is a valid connection end-point. These
+ * end-points are either {@link ExecutionUnit}s selected as deployment targets for
+ * {@link Component}s or {@link IPlatformCommunicationResource}s whose internal structure is not
+ * modeled.
+ */
+ protected boolean isValidConnectionTarget(IPlatformArchitectureElement element,
+ Collection<ExecutionUnit> deploymentTargets) {
+ if(element instanceof IPlatformResource && deploymentTargets.contains(element)) {
+ return true;
+ } else if(element instanceof IPlatformCommunicationResource &&
+ element.getContainedElements().isEmpty()) {
+ return true;
+ }
+ return false;
+ }
+
+ /** Returns the fault containment region specified for the target platform. */
+ public Class<? extends IPlatformResource> getFaultContainmentRegion() {
+ return faultContainmentRegion;
+ }
+
+ /** Returns deploymentTargetConnectors. */
+ public Collection<IResourceConnectionAdapter> getDeploymentTargetConnectors() {
+ return deploymentTargetConnectors;
+ }
+
+ /** Sets deploymentTargetConnectors. */
+ public void setDeploymentTargetConnectors(
+ Collection<IResourceConnectionAdapter> deploymentTargetConnectors) {
+ this.deploymentTargetConnectors = deploymentTargetConnectors;
+ }
+}
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/SystemModelAdapter.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/SystemModelAdapter.java
index 6fa37728..ddffc256 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/SystemModelAdapter.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/SystemModelAdapter.java
@@ -18,7 +18,6 @@ package org.fortiss.af3.exploration.alg.dse.sysmodel.arch;
import static org.fortiss.af3.exploration.util.ExplorationUtils.isDebugVerboseEnabled;
import static org.fortiss.af3.schedule.utils.MathUtils.lcmDoubleCollection;
import static org.fortiss.af3.task.util.TaskAllocationUtils.getAllocatedComponentsTo;
-import static org.fortiss.tooling.kernel.utils.EcoreUtils.pickFirstInstanceOf;
import java.util.ArrayList;
import java.util.Collection;
@@ -32,12 +31,9 @@ import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
-import org.conqat.lib.commons.collections.Pair;
-import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.fortiss.af3.component.model.Component;
import org.fortiss.af3.component.model.ComponentArchitecture;
-import org.fortiss.af3.component.model.Port;
import org.fortiss.af3.exploration.alg.dse.backend.opt4j.encoding.platform.PlatformCommunicationGraphEncoding;
import org.fortiss.af3.exploration.alg.dse.backend.opt4j.encoding.taskgraph.AbstractTaskGraphEncoding;
import org.fortiss.af3.exploration.alg.dse.backend.opt4j.encoding.taskmapping.abstractmapping.AbstractTaskMappingEncoding;
@@ -50,15 +46,12 @@ import org.fortiss.af3.exploration.alg.exception.InvalidTimingModelException;
import org.fortiss.af3.exploration.alg.guava.MutableSubClassToInstanceMap;
import org.fortiss.af3.exploration.alg.guava.SubClassToInstanceMap;
import org.fortiss.af3.exploration.alg.service.IExplorationEncoding;
-import org.fortiss.af3.exploration.backend.IDseInputContainer.SignalType;
import org.fortiss.af3.platform.model.ExecutionUnit;
import org.fortiss.af3.platform.model.IPlatformArchitectureElement;
import org.fortiss.af3.platform.model.IPlatformCommunicationResource;
import org.fortiss.af3.platform.model.IPlatformExport;
import org.fortiss.af3.platform.model.IPlatformResource;
import org.fortiss.af3.platform.model.PlatformArchitecture;
-import org.fortiss.af3.platform.model.annotation.ResourceLink;
-import org.fortiss.af3.platform.utils.PlatformArchitectureUtils;
import org.fortiss.af3.task.model.Task;
import org.fortiss.af3.task.model.TaskArchitecture;
import org.fortiss.tooling.base.model.element.IConnection;
@@ -102,12 +95,6 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
/** Collection of deployable components from the base model. */
protected Collection<C> deployableComponentObjects;
- /**
- * Maps the {@link Port}s of the deployable {@link Component}s to their temporal
- * {@link SignalType} (aperiodic, sporadic, etc.).
- */
- protected Map<Port, SignalType> portSignalTypes;
-
/**
* Look up table to determine the input/output directions of {@link IConnector} types of the
* target {@link PlatformArchitecture}.
@@ -168,7 +155,7 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
protected Collection<IResourceAdapter<?>> deploymentTargetResources;
/** Contains the connections between the {@link IResourceAdapter}s of the platform. */
- private Collection<IResourceConnectionAdapter> deploymentTargetConnectors;
+ protected Collection<IResourceConnectionAdapter> platformConnections;
/**
* Collection of the safety functions adapters that represent the safety functions from the
@@ -219,12 +206,6 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
*/
protected Map<IResourceAdapter<?>, IResourceAdapter<?>> virtualResourceToHardwareResourceMap;
- /**
- * Identifies the {@link IModelElement} types which establish a connection between two
- * {@link PlatformArchitecture}s via an {@link ResourceLink}.
- */
- protected Pair<Class<? extends IModelElement>, Class<? extends IModelElement>> platformInterconnectTypes;
-
/** Defines the fault containment region defined for the target {@link PlatformArchitecture}. */
protected Class<? extends IPlatformResource> faultContainmentRegion;
@@ -422,14 +403,11 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
@SuppressWarnings("unchecked")
private <T extends TaskGraph> Map<ITaskAdapter<C>, T>
registerTaskGraphsForComponents(Collection<T> graphs) {
- Map<ITaskAdapter<C>, T> componentToGraphMap =
- new HashMap<ITaskAdapter<C>, T>();
+ Map<ITaskAdapter<C>, T> componentToGraphMap = new HashMap<ITaskAdapter<C>, T>();
for(T taskGraph : graphs) {
- for(ITaskAdapter<?> deployableComponent : taskGraph.getGraph()
- .vertexSet()) {
- componentToGraphMap.put((ITaskAdapter<C>)deployableComponent,
- taskGraph);
+ for(ITaskAdapter<?> deployableComponent : taskGraph.getGraph().vertexSet()) {
+ componentToGraphMap.put((ITaskAdapter<C>)deployableComponent, taskGraph);
}
}
@@ -443,8 +421,7 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
* hyperperiod.
*/
private <T extends TaskGraph> void removeInvalidTaskGraphs(Collection<T> taskGraphs) {
- Set<ITaskAdapter<?>> tasksToBeRemoved =
- new HashSet<ITaskAdapter<?>>();
+ Set<ITaskAdapter<?>> tasksToBeRemoved = new HashSet<ITaskAdapter<?>>();
Collection<T> graphsToBeRemoved = new HashSet<T>();
// for(T currentGraph : taskGraphs) {
// if(currentGraph.getPeriod() <= 0) {
@@ -522,8 +499,7 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
for(ISignalAdapter<?> channelAdapter : messages) {
ITaskAdapter<?> sourceDeployableComponent = channelAdapter.getSource();
- Collection<ITaskAdapter<?>> targetDeployableComponents =
- channelAdapter.getTargets();
+ Collection<ITaskAdapter<?>> targetDeployableComponents = channelAdapter.getTargets();
if(sourceDeployableComponent != null && !(targetDeployableComponents.isEmpty())) {
taskGraph.addDataDependency(sourceDeployableComponent, targetDeployableComponents,
@@ -568,7 +544,7 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
// Successively connect the resources in the graph. The edges are given within the
// collection resource connectors are assumed to be fully connected.
- for(IResourceConnectionAdapter connection : getDeploymentTargetConnectors()) {
+ for(IResourceConnectionAdapter connection : platformConnections) {
// We add edges for each receiver in order to support broadcast connections
for(IResourceAdapter<?> currentReceiverResource : connection.getTargetResources()) {
// If the current resource is a child of a {@link TransmissionUnit} (like a NoC
@@ -603,8 +579,7 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
* {@link ISignalAdapter}s that are emitted by the given {@link ITaskAdapter}.
*/
protected void setupEmittedMessages() {
- emittedMessagesBySender =
- new HashMap<ITaskAdapter<C>, Collection<ISignalAdapter<S>>>();
+ emittedMessagesBySender = new HashMap<ITaskAdapter<C>, Collection<ISignalAdapter<S>>>();
for(ITaskAdapter<C> currentSender : deployableComponents) {
Collection<ISignalAdapter<S>> emittedMessages = new ArrayList<ISignalAdapter<S>>();
@@ -672,8 +647,7 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
* @return The asociated {@link ITaskAdapter}, or {@code null} if none can be
* identified.
*/
- public synchronized ITaskAdapter<C>
- getDeployableComponentOf(EObject originalEObject) {
+ public synchronized ITaskAdapter<C> getDeployableComponentOf(EObject originalEObject) {
// FIXME: HACK to work around the missing consideration of the Task Architecture ATM.
if(originalEObject instanceof Task) {
TaskArchitecture ta = (TaskArchitecture)((Task)originalEObject).getContainer();
@@ -819,8 +793,7 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
* Returns the {@link DefaultTaskGraph} in which a given deployable component (=task) is
* contained.
*/
- public DefaultTaskGraph<?>
- getAcyclicTaskGraph(ITaskAdapter<?> deployableComponent) {
+ public DefaultTaskGraph<?> getAcyclicTaskGraph(ITaskAdapter<?> deployableComponent) {
return componentInAcyclicGraph.get(deployableComponent);
}
@@ -829,15 +802,13 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
* {@link ITaskAdapter}. Returns an empty collection if the given
* {@link ITaskAdapter} does not emit anything.
*/
- public Collection<ISignalAdapter<S>>
- getEmmittedMessages(ITaskAdapter<?> sender) {
+ public Collection<ISignalAdapter<S>> getEmmittedMessages(ITaskAdapter<?> sender) {
// TODO: use another representation ro make an access via the reference obsolete
if(sender.isInstantiation()) {
sender = sender.getReplacedComponent();
}
// TODO: replace by map or similar.
- ITaskAdapter<?> origSender =
- getDeployableComponentOf((EObject)sender.getObject());
+ ITaskAdapter<?> origSender = getDeployableComponentOf((EObject)sender.getObject());
return emittedMessagesBySender.get(origSender);
}
@@ -854,14 +825,6 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
return deployableComponentObjects.contains(component);
}
- /**
- * Returns whether the given {@link Port} is attached to a deployable {@link Component}, i.e.
- * its temporal behavior must be defined.
- */
- public boolean isDeployablePort(Port port) {
- return portSignalTypes.get(port) != null;
- }
-
/** Returns the input output behavior of the given platform connector. */
public ConnectionType getConnectionType(Class<? extends IConnector> connector) {
return connectionTypeLUT.get(connector);
@@ -871,15 +834,6 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
// To be removed / generalized
// ===============================================================
- /**
- * Wrapper for {@link #getEffectiveConnectionTargets(IConnector, Map, Collection)} that disables
- * the traversal between the physical and the virtual platform.
- */
- protected Collection<IConnector> getEffectiveConnectionTargets(IConnector sourceConnector,
- Collection<ExecutionUnit> deploymentTargets) throws Exception {
- return getEffectiveConnectionTargets(sourceConnector, null, deploymentTargets);
- }
-
/**
* <p>
* Determines the effective target {@link IConnector}s of a given "source" {@link IConnector}.
@@ -902,7 +856,6 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
* if the references between the {@link IModelElement}s are incorrectly specified.
*/
protected Collection<IConnector> getEffectiveConnectionTargets(IConnector sourceConnector,
- Map<IModelElement, IModelElement> invElementReferences,
Collection<ExecutionUnit> af3DeploymentTargets) throws Exception {
Collection<IConnector> targetConnectors = new HashSet<IConnector>();
if(sourceConnector == null) {
@@ -922,13 +875,6 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
seekIntraPlatformTargetConnectors(sourceConnector, possibleTargetConnectors,
visitedTargetConnectors, nextTargetConnector, af3DeploymentTargets));
- // This section handles the traversal between a virtual and a hardware platform
- // architecture.
- if(invElementReferences != null) {
- targetConnectors.addAll(seekInterPlatformConnectors(nextTargetConnector,
- invElementReferences, possibleTargetConnectors, af3DeploymentTargets));
- }
-
visitedTargetConnectors.add(nextTargetConnector);
}
@@ -1034,141 +980,6 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
return targetConnectors;
}
- /**
- * Determines those {@link IConnector}s (in a different {@link PlatformArchitecture} than the
- * {@code sourceConnector}) that establish a link between between two elements of different
- * {@link PlatformArchitecture}s and which are connected by a {@link ResourceLink}.
- * This method is agnostic of the "direction" of the {@link ResourceLink}, i.e. it does not
- * matter whether the {@code sourceConnector} is attached to an
- * {@link IPlatformArchitectureElement} to which the {@link ResourceLink} is annotated or is
- * referenced by virtual link.
- * <p>
- * <b>NOTE:</b> The current implementation assumes that there exist only n:1 links between
- * {@link IModelElement}s that establish a "communication path" between different platforms
- * (virtual -> physical).
- *
- * @param sourceConnector
- * {@link IConnector} for which the target {@link IConnector}s in another platform
- * have to be identified.
- * @param invElementReferences
- * Map representing all 1:1 inverse {@link ResourceLink}s.
- * @param possibleTargetConnectors
- * List of {@link IConnector}s to which those {@link IConnector}s are added that are
- * located in referenced {@link PlatformArchitecture} but need to be traversed
- * further such that valid "communication targets" are identified.
- * @param deploymentTargets
- * Set of execution units present on the target platform.
- * @return List of {@link IConnector}s that a message actually traverses when being sent by the
- * {@code sourceConnector}.
- * @throws Exception
- * if the references between the {@link IModelElement}s are incorrectly specified.
- */
- // TODO: Throw appropriate Exceptions on failure, i.e. wrong types of referenced elements etc.
- protected Collection<IConnector> seekInterPlatformConnectors(IConnector sourceConnector,
- Map<IModelElement, IModelElement> invElementReferences,
- LinkedList<IConnector> possibleTargetConnectors,
- Collection<ExecutionUnit> deploymentTargets) throws Exception {
- Collection<IConnector> identifiedTargets = new ArrayList<IConnector>();
-
- if(connectsSwHwPlatform(sourceConnector)) {
- // Special treatment for the connection between the virtual
- // platform and the physical platform.
- IPlatformArchitectureElement referencingElement =
- (IPlatformArchitectureElement)sourceConnector.getOwner();
- EList<IPlatformArchitectureElement> referencedElements =
- PlatformArchitectureUtils.getReferencedElementsWithType(referencingElement,
- IPlatformArchitectureElement.class);
- if(referencedElements.size() == 0) {
- throw new Exception(
- "No Network Interface is referenced in the ResourceLink annotation of " +
- referencingElement.getName() +
- ". Please specify at least one reference.");
- }
-
- for(IPlatformArchitectureElement currRefElem : referencedElements) {
- if(sourceConnector.getOwner() instanceof IPlatformArchitectureElement &&
- isValidConnectionTarget(
- (IPlatformArchitectureElement)sourceConnector.getOwner(),
- deploymentTargets)) {
- identifiedTargets.add(pickFirstInstanceOf(IPlatformExport.class,
- currRefElem.getConnectors()));
- } else {
- possibleTargetConnectors.addAll(currRefElem.getPlatformConnectorUnits());
- }
- }
- } else if(invElementReferences.get(sourceConnector.getOwner()) != null) {
- // Special treatment for the connection between the physical platform
- // and the virtual platform.
- IModelElement referencedElement = invElementReferences.get(sourceConnector.getOwner());
- assert (referencedElement instanceof IPlatformArchitectureElement) : "A non-platform model element has been referenced.";
- IPlatformArchitectureElement referencedPlatformElement =
- (IPlatformArchitectureElement)referencedElement;
- IPlatformExport driverExport = pickFirstInstanceOf(IPlatformExport.class,
- referencedPlatformElement.getConnectors());
-
- if(driverExport.getOwner() instanceof IPlatformArchitectureElement &&
- isValidConnectionTarget((IPlatformArchitectureElement)driverExport.getOwner(),
- deploymentTargets)) {
- identifiedTargets.add(driverExport);
- } else {
- // TODO: dead code path? Is not called for any recent model.
- possibleTargetConnectors
- .addAll(referencedPlatformElement.getPlatformConnectorUnits());
- }
- }
-
- return identifiedTargets;
- }
-
- /**
- * Determines whether the given connector (or its containing element) is used to establish a
- * connection between separate {@link PlatformArchitecture}s. This method is capable of
- * identifying connections between different {@link PlatformArchitecture} even if the links are
- * defined only for the elements of {@link PlatformArchitecture}. This feature requires a map
- * that tracks the link between the referenced elements and the elements containing the link.
- *
- * @param connector
- * {@link IConnection} to be examined for its role of connecting different
- * {@link PlatformArchitecture}s.
- * @param invNetDriverRef
- * Map tracking the inverse link of inter-{@link PlatformArchitecture} links.
- * @return Flag, if the given connector (or its containing {@link IModelElement}) connects model
- * elements form different {@link PlatformArchitecture}s.
- */
- protected boolean connectsSwHwPlatform(IConnector connector,
- Map<IModelElement, IModelElement> invNetDriverRef) {
- if(!connectsSwHwPlatform(connector)) {
- if(connector != null) {
- IHierarchicElement parent = connector.getOwner();
- // Second: physical counter part of inter-platform connection.
- if(platformInterconnectTypes != null &&
- platformInterconnectTypes.getSecond().isAssignableFrom(parent.getClass()) &&
- invNetDriverRef.get(parent) != null) {
- return true;
- }
- }
- return false;
- }
- return true;
- }
-
- /**
- * Determines whether the given connector is used to establish a connection between separate
- * {@link PlatformArchitecture}s.
- * <p>
- * <b>NOTE:</b> This method only works correctly if the given {@link IConnector} is attached to
- * a {@link IModelElement} that has an explicit reference to an {@link IModelElement} of another
- * {@link PlatformArchitecture}. Otherwise, use {#link connectsSwHwPlatform(IConnector,
- * Map<NetworkInterface, OnChipNetworkDriver>)}.
- */
- protected boolean connectsSwHwPlatform(IConnector connector) {
- if(connector instanceof IPlatformExport && platformInterconnectTypes.getFirst()
- .isAssignableFrom(connector.getOwner().getClass())) {
- return true;
- }
- return false;
- }
-
/**
* Returns whether the given {@link IHierarchicElement} is a valid connection end-point. These
* end-points are either {@link ExecutionUnit}s selected as deployment targets for
@@ -1190,15 +1001,4 @@ public class SystemModelAdapter<C, E, S, G, TR, M> {
public Class<? extends IPlatformResource> getFaultContainmentRegion() {
return faultContainmentRegion;
}
-
- /** Returns deploymentTargetConnectors. */
- public Collection<IResourceConnectionAdapter> getDeploymentTargetConnectors() {
- return deploymentTargetConnectors;
- }
-
- /** Sets deploymentTargetConnectors. */
- public void setDeploymentTargetConnectors(
- Collection<IResourceConnectionAdapter> deploymentTargetConnectors) {
- this.deploymentTargetConnectors = deploymentTargetConnectors;
- }
}
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/.ratings b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/.ratings
index 59ff42a7..6a822c2c 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/.ratings
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/.ratings
@@ -7,7 +7,7 @@ AF3PlatformArchitectureAdapter.java 1d4acb95db3042cdbbc43484687e935124df2114 RED
AF3RequestAdapter.java 8b551cf83401d93705d0527184a961ea8244daa3 RED
AF3ResourceAdapter.java f20b7da41445acadc3d3cc5b662a993ecbaed47a RED
AF3ResourceConnectionAdapter.java b0804eb7d4a2b36065d45bfd90ad548ca7e6c0f8 RED
-AF3SignalAdapter.java cd04646323507aff4f3085a9275baf8a72888d18 RED
-AF3SystemModelAdapter.java f42cc9d650d51283a537d28da05ec85762608931 RED
+AF3SignalAdapter.java c636c07318ba0f166b35cbf3d45f3b5ec2868e0e RED
+AF3SystemModelAdapter.java af16ad00e14b64075a14d1c51c1723f4606c482c RED
AF3TaskAdapter.java a696f76d2ef31f3ae15f013067be9f667f7e6a0d RED
AF3TransmissionUnitAdapter.java 9221b239d1d54cc0b2f01b3c385faa660ed1d3e0 RED
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SignalAdapter.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SignalAdapter.java
index 5bc26e19..6b0d549b 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SignalAdapter.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SignalAdapter.java
@@ -21,33 +21,37 @@ import java.util.Iterator;
import org.fortiss.af3.component.model.Channel;
import org.fortiss.af3.component.model.InputPort;
import org.fortiss.af3.component.model.OutputPort;
-import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ITaskAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ISignalAdapter;
+import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ITaskAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ITransmissionUnitAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.comm.Message;
import org.fortiss.af3.exploration.backend.IDseInputContainer.SignalType;
+import org.fortiss.af3.task.model.TaskInputPort;
+import org.fortiss.af3.task.model.TaskOutputPort;
/**
* Adapter between the AF3 {@link Channel} and the DSE.
*
* @author barner
*/
-public class AF3SignalAdapter extends AF3RequestAdapter<OutputPort>
- implements ISignalAdapter<OutputPort> {
+public class AF3SignalAdapter implements ISignalAdapter<TaskOutputPort> {
/** Conversion constant for the message size. */
private static final long MBYTES_TO_BYTES = 1000 * 1000;
/** Message's source component */
- ITaskAdapter<?> source;
+ private ITaskAdapter<?> source;
+
+ /** Message's source component */
+ private TaskOutputPort sourcePort;
/** Message's target component adapter */
- Collection<ITaskAdapter<?>> targets;
+ private Collection<ITaskAdapter<?>> targets;
/** Message's target AF3 ports. */
- Collection<InputPort> targetPorts;
+ private Collection<TaskInputPort> targetPorts;
/** Message size annotation */
- long messageSize;
+ private long messageSize;
/**
* Contains the {#link SignalType} of this {@link ISignalAdapter}. Defaults to {#link
@@ -60,20 +64,20 @@ public class AF3SignalAdapter extends AF3RequestAdapter<OutputPort>
*
* @throws Exception
*/
- public AF3SignalAdapter(OutputPort senderPort, ITaskAdapter<?> source,
- Collection<InputPort> targetPorts, Collection<ITaskAdapter<?>> targets,
- Long messageSize) throws Exception {
- super(senderPort);
-
+ public AF3SignalAdapter(TaskOutputPort senderPort, ITaskAdapter<?> source,
+ Collection<TaskInputPort> targetPorts, Collection<ITaskAdapter<?>> targets)
+ throws Exception {
+ this.sourcePort = senderPort;
this.source = source;
this.targets = targets;
this.targetPorts = targetPorts;
- if(messageSize != null) {
- this.messageSize = messageSize;
- } else {
- throw new Exception("Port " + senderPort + " does not have a message size annotation.");
- }
+ // TODO: reinclude the message size, i.e. data size of the signal
+ // if(messageSize != null) {
+ // this.messageSize = messageSize;
+ // } else {
+ // throw new Exception("Port " + senderPort + " does not have a message size annotation.");
+ // }
signalType = SignalType.PERIODIC;
}
@@ -103,7 +107,7 @@ public class AF3SignalAdapter extends AF3RequestAdapter<OutputPort>
* Returns the AF3 {@link OutputPort} that is responsible for emitting the {@link Message} (if
* required).
*/
- public OutputPort getSenderPort() {
+ public TaskOutputPort getSenderPort() {
// Known by construction.
return getObject();
}
@@ -111,7 +115,7 @@ public class AF3SignalAdapter extends AF3RequestAdapter<OutputPort>
/**
* Returns the AF3 {@link InputPort} that is that receives the {@link Message} (if required).
*/
- public Collection<InputPort> getTargetPorts() {
+ public Collection<TaskInputPort> getTargetPorts() {
return targetPorts;
}
@@ -131,8 +135,8 @@ public class AF3SignalAdapter extends AF3RequestAdapter<OutputPort>
@Override
public String getName() {
String targetNameList = "";
- for(Iterator<ITaskAdapter<?>> targetIterator =
- targets.iterator(); targetIterator.hasNext();) {
+ for(Iterator<ITaskAdapter<?>> targetIterator = targets.iterator(); targetIterator
+ .hasNext();) {
targetNameList += targetIterator.next().getName();
if(targetIterator.hasNext()) {
targetNameList += ", ";
@@ -153,4 +157,10 @@ public class AF3SignalAdapter extends AF3RequestAdapter<OutputPort>
public SignalType getSignalType() {
return signalType;
}
+
+ /** {@inheritDoc} */
+ @Override
+ public TaskOutputPort getObject() {
+ return sourcePort;
+ }
}
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SystemModelAdapter.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SystemModelAdapter.java
index 30501e4e..da6f0b86 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SystemModelAdapter.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/dse/sysmodel/arch/af3/AF3SystemModelAdapter.java
@@ -17,19 +17,12 @@ package org.fortiss.af3.exploration.alg.dse.sysmodel.arch.af3;
import static org.fortiss.af3.deployment.utils.DeploymentParameterUtils.getDeploymentsWithParametersOf;
import static org.fortiss.af3.exploration.alg.util.AF3Utils.getConnectionTypeDirection;
-import static org.fortiss.af3.exploration.alg.util.AF3Utils.getInverseIntraPlatformReferences;
-import static org.fortiss.af3.exploration.alg.util.AF3Utils.isAnyChildDeploymentTarget;
-import static org.fortiss.af3.exploration.alg.util.AF3Utils.isComponentOrPortsDeployable;
import static org.fortiss.af3.exploration.alg.util.ExplorationAlgUtils.findTargetPorts;
-import static org.fortiss.af3.exploration.alg.util.ExplorationAlgUtils.getDeployableOutputPorts;
-import static org.fortiss.af3.platform.utils.PlatformArchitectureUtils.getPhysicalPlatformArchitecture;
-import static org.fortiss.af3.platform.utils.PlatformArchitectureUtils.getReferencedElementsWithType;
-import static org.fortiss.af3.schedule.utils.MathUtils.gcdDoubleCollection;
import static org.fortiss.tooling.base.ui.annotation.view.AnnotationViewPartBase.isUpdateEnabled;
import static org.fortiss.tooling.base.ui.annotation.view.AnnotationViewPartBase.setUpdateEnabled;
+import static org.fortiss.tooling.common.util.LambdaUtils.getFirst;
import static org.fortiss.tooling.kernel.utils.EcoreUtils.getChildrenWithType;
-import static org.fortiss.tooling.kernel.utils.EcoreUtils.pickFirstInstanceOf;
-import static org.fortiss.tooling.kernel.utils.EcoreUtils.pickInstanceOf;
+import static org.fortiss.tooling.kernel.utils.EcoreUtils.getFirstParentWithType;
import static org.fortiss.tooling.kernel.utils.KernelModelElementUtils.getParentElement;
import java.lang.reflect.Method;
@@ -45,14 +38,11 @@ import java.util.Map.Entry;
import java.util.Set;
import org.conqat.lib.commons.collections.Pair;
-import org.fortiss.af3.component.model.Channel;
import org.fortiss.af3.component.model.Component;
import org.fortiss.af3.component.model.ComponentArchitecture;
-import org.fortiss.af3.component.model.InputPort;
import org.fortiss.af3.component.model.OutputPort;
import org.fortiss.af3.component.model.Port;
import org.fortiss.af3.deployment.model.Deployment;
-import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ITaskAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IExecutionUnitAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IGatewayUnitAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IMemoryUnitAdapter;
@@ -60,24 +50,27 @@ import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IResourceAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IResourceConnectionAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IResourceConnectionAdapter.ConnectionType;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ISignalAdapter;
+import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ITaskAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.ITransmissionUnitAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.InternalComponentParameters;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.SystemModelAdapter;
-import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.SystemParameterContainer;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.af3.helper.AF3DeploymentParameterMapAdapter;
import org.fortiss.af3.exploration.alg.dse.sysmodel.arch.taskgraph.TaskGraph;
import org.fortiss.af3.exploration.alg.exception.InvalidPlatformModelException;
+import org.fortiss.af3.exploration.dsl_v2.model.expression.SuperSet;
+import org.fortiss.af3.platform.hierarchic.model.tile.Tile;
import org.fortiss.af3.platform.model.ExecutionUnit;
import org.fortiss.af3.platform.model.GatewayUnit;
-import org.fortiss.af3.platform.model.IPlatformArchitectureElement;
-import org.fortiss.af3.platform.model.IPlatformExport;
import org.fortiss.af3.platform.model.IPlatformResource;
import org.fortiss.af3.platform.model.MemoryUnit;
import org.fortiss.af3.platform.model.PlatformArchitecture;
import org.fortiss.af3.platform.model.TransmissionUnit;
+import org.fortiss.af3.task.model.Signal;
+import org.fortiss.af3.task.model.Task;
+import org.fortiss.af3.task.model.TaskInputPort;
+import org.fortiss.af3.task.model.TaskOutputPort;
import org.fortiss.tooling.base.model.element.IConnector;
import org.fortiss.tooling.base.model.element.IHierarchicElement;
-import org.fortiss.tooling.base.model.element.IModelElement;
import org.fortiss.tooling.kernel.model.IProjectRootElement;
import org.fortiss.tooling.kernel.utils.EcoreUtils;
@@ -90,10 +83,7 @@ import com.google.common.collect.Multimap;
* @author diewald
*/
public class AF3SystemModelAdapter extends
- SystemModelAdapter<Component, ExecutionUnit, OutputPort, GatewayUnit, TransmissionUnit, MemoryUnit> {
-
- /** References the AF3 {@link PlatformArchitecture} that is adapted. */
- private PlatformArchitecture hardwarePlatformArchitecture;
+ SystemModelAdapter<Component, ExecutionUnit, TaskOutputPort, GatewayUnit, TransmissionUnit, MemoryUnit> {
/**
* References the {@link AF3DeploymentParameterMapAdapter} providing access to the deployment
@@ -107,95 +97,59 @@ public class AF3SystemModelAdapter extends
*/
private Collection<ITaskAdapter<Component>> componentReplacementAdapters;
- // TODO (2x): package access rights are ok? If so, please add /* package */
- /** Contains informations whether the given AF3 model supports multicast channels. */
- boolean multicastSupport = false;
-
/** References the method which returns the multicast targets (if available). */
Method multicastGetTargets;
/** Cache the Annotation View's update status. */
private boolean annotationUpdateEnabled;
- /**
- * Constructor.
- *
- * @param componentArchitecture
- * main logical architecture to deploy.
- * @param platformArchitecture
- * main target platform.
- * @param systemParameters
- * required and optional parameters for the DSE.
- * @throws Exception
- * if the creation of the system model adapter fails due to missing inputs or
- * inconsistent specifications.
- */
- public AF3SystemModelAdapter(ComponentArchitecture componentArchitecture,
- PlatformArchitecture platformArchitecture, SystemParameterContainer systemParameters)
- throws Exception {
-
- checkMulticastSupport();
-
- this.logicalArchitecture = new AF3LogicalArchitectureAdapter(componentArchitecture);
- this.platformArchitecture = new AF3PlatformArchitectureAdapter(platformArchitecture);
- this.deployableComponentObjects = systemParameters.getDeployableComponents();
- this.connectionTypeLUT = systemParameters.getConnectionTypeLUT();
- this.portSignalTypes = systemParameters.getPortSignalTypes();
- this.platformInterconnectTypes = systemParameters.getPlatfromInterconnectTypes();
- this.faultContainmentRegion = systemParameters.getFaultContainmentRegion();
- putInputModel(ComponentArchitecture.class, componentArchitecture);
- putInputModel(PlatformArchitecture.class, platformArchitecture);
+ public static Map<Class<? extends IConnector>, ConnectionType> connectionTypeLUT =
+ Collections.unmodifiableMap(new HashMap<Class<? extends IConnector>, ConnectionType>() {
+ {
+ }
+ });
+
+ public AF3SystemModelAdapter(SuperSet<Component> components, SuperSet<ExecutionUnit> execUnits,
+ SuperSet<Signal> signals) throws Exception {
+ // FIXME: Porting Code.
+ ComponentArchitecture compArch = getFirstParentWithType(
+ getFirst(components.getEntries()).orElse(null), ComponentArchitecture.class);
+ this.logicalArchitecture = new AF3LogicalArchitectureAdapter(compArch);
+ PlatformArchitecture platArch = getFirstParentWithType(
+ getFirst(components.getEntries()).orElse(null), PlatformArchitecture.class);
+ this.platformArchitecture = new AF3PlatformArchitectureAdapter(platArch);
+ // End: Porting code.
+
+ this.deployableComponentObjects = components.getEntries();
+ this.faultContainmentRegion = Tile.class;
+ // TODO(#3254): Use SuperSets here for querying the required input types.
+ putInputModel(ComponentArchitecture.class, compArch);
+ putInputModel(PlatformArchitecture.class, platArch);
// Disable any annotation view update.
annotationUpdateEnabled = isUpdateEnabled();
setUpdateEnabled(false);
- // Determine the associated hardware platform given the platform architecture is a a model
- // of a virtual platform.
- hardwarePlatformArchitecture = getPhysicalPlatformArchitecture(platformArchitecture);
-
- this.deploymentTargets = createDeploymentTargets(systemParameters.getDeploymentTargets(),
- systemParameters.getResourceFailureProbabilities());
-
- memoryUnits = createMemoryUnits(platformArchitecture,
- systemParameters.getResourceFailureProbabilities());
- gatewayUnits = createGatewayUnits(platformArchitecture,
- systemParameters.getResourceFailureProbabilities(),
- systemParameters.getResourcePowerConsumption());
- transmissionUnits = createTransmissionUnits(platformArchitecture,
- systemParameters.getResourceFailureProbabilities(),
- systemParameters.getResourcePowerConsumption());
- if(platformArchitecture != hardwarePlatformArchitecture) {
- memoryUnits.addAll(createMemoryUnits(hardwarePlatformArchitecture,
- systemParameters.getResourceFailureProbabilities()));
- gatewayUnits.addAll(createGatewayUnits(hardwarePlatformArchitecture,
- systemParameters.getResourceFailureProbabilities(),
- systemParameters.getResourcePowerConsumption()));
- transmissionUnits.addAll(createTransmissionUnits(hardwarePlatformArchitecture,
- systemParameters.getResourceFailureProbabilities(),
- systemParameters.getResourcePowerConsumption()));
- }
+ this.deploymentTargets = createDeploymentTargets(execUnits.getEntries());
+ memoryUnits = createMemoryUnits(platArch);
+ gatewayUnits = createGatewayUnits(platArch);
+ transmissionUnits = createTransmissionUnits(platArch);
availableResources = createAvailableResources();
- parameterAdapter = createDeploymentParameterMap(componentArchitecture, platformArchitecture,
- systemParameters.getReplacementComponents());
- setDeploymentTargetConnectors(
- createDeploymentTargetConnectors(systemParameters.getDeploymentTargets()));
+ // TODO(#3264): Reintegrate the support for Component Design Libraries.
+ parameterAdapter = createDeploymentParameterMap(compArch, platArch, HashMultimap.create());
+ platformConnections = createPlatfromResourceConnections(execUnits.getEntries());
+ // TODO(#3264): Reintegrate the support for Component Design Libraries.
+ // Multimap<Component, ITaskAdapter<Component>> componentToReplacementAdapter =
+ // createComponentReplacementAdapters(systemParameters.getReplacementComponents());
Multimap<Component, ITaskAdapter<Component>> componentToReplacementAdapter =
- createComponentReplacementAdapters(systemParameters.getReplacementComponents());
- deployableComponents = createDeployableComponents(componentToReplacementAdapter,
- systemParameters.getComponentPeriodMap(),
- systemParameters.getComponentReplicationBounds());
+ HashMultimap.create();
+ deployableComponents = createDeployableComponents(componentToReplacementAdapter);
componentReplacementAdapters = componentToReplacementAdapter.values();
replicableComponents = new HashSet<>(deployableComponents);
realizableDeployableComponents = createRealizableDeployableComponents(deployableComponents);
- Collection<ISignalAdapter<OutputPort>> unsortedMessages =
- createSignalAdapters(systemParameters.getPortMessageSizes());
- messages = sortMessagesByExpectedOrder(unsortedMessages,
- systemParameters.getComponentPeriodMap());
-
- virtualResourceToHardwareResourceMap = createVirtualResourceToHardwareResourceMap();
+ messages = createSignalAdapters(signals);
setupScheduleableComponents();
setupTaskGraphs();
@@ -208,26 +162,14 @@ public class AF3SystemModelAdapter extends
setUpdateEnabled(annotationUpdateEnabled);
}
- /** Determines whether the current AF3 version supports multicast channels. */
- private void checkMulticastSupport() {
- Method[] methodsOfChannel = Channel.class.getMethods();
- for(Method currentChannelMethod : methodsOfChannel) {
- if(currentChannelMethod.getName().equals("getTargets")) {
- multicastSupport = true;
- multicastGetTargets = currentChannelMethod;
- }
- }
- }
-
/**
* Creates a collection of {@link ITaskAdapter}s that are available to
* instantiate other "abstract" {@link ITaskAdapter}s. Only those
* {@link ITaskAdapter}s which are referenced by {@link Component}s of the input
* {@link ComponentArchitecture} are included in the collection.
*/
- private Multimap<Component, ITaskAdapter<Component>>
- createComponentReplacementAdapters(Multimap<Component, Component> replacementComponents)
- throws Exception {
+ private Multimap<Component, ITaskAdapter<Component>> createComponentReplacementAdapters(
+ Multimap<Component, Component> replacementComponents) throws Exception {
Multimap<Component, ITaskAdapter<Component>> rval = HashMultimap.create();
Collection<Component> allReplacementComponents = replacementComponents.values();
Map<Component, InternalComponentParameters> internalParameterMap =
@@ -235,8 +177,8 @@ public class AF3SystemModelAdapter extends
for(Component curComponent : replacementComponents.keySet()) {
for(Component curReplacementComponent : replacementComponents.get(curComponent)) {
- rval.put(curComponent, new AF3TaskAdapter(curReplacementComponent,
- internalParameterMap));
+ rval.put(curComponent,
+ new AF3TaskAdapter(curReplacementComponent, internalParameterMap));
}
}
@@ -248,24 +190,20 @@ public class AF3SystemModelAdapter extends
*
* @throws Exception
*/
+ // TODO(#3262): Periods, Replication bounds.
private Collection<ITaskAdapter<Component>> createDeployableComponents(
- Multimap<Component, ITaskAdapter<Component>> componentReplacementAdapters,
- Map<Component, Double> componentPeriodMap,
- Map<Component, Pair<Integer, Integer>> componentReplicationBounds) throws Exception {
+ Multimap<Component, ITaskAdapter<Component>> componentReplacementAdapters)
+ throws Exception {
Collection<ITaskAdapter<Component>> rval = new HashSet<>();
Map<Component, InternalComponentParameters> internalParameterMap =
createInternalParameterMaps(deployableComponentObjects);
for(Component currentComponent : deployableComponentObjects) {
- Double period = componentPeriodMap.get(currentComponent);
- // TODO: The period was allowed to be null for enabling the VL routing?
- // if (period == null) {
- // throw new Exception("The Period for the deployable component " + currentComponent +
- // " has not been defined.");
- // }
- Pair<Integer, Integer> replicationBounds =
- componentReplicationBounds.get(currentComponent);
+ Double period = 10.0;
+ // No replication for the porting time.
+ Pair<Integer, Integer> replicationBounds = new Pair<>(1, 1);
+ // componentReplicationBounds.get(currentComponent);
if(replicationBounds == null || replicationBounds.getFirst() == null ||
replicationBounds.getSecond() == null) {
throw new Exception("The replication bounds for the deployable component " +
@@ -290,10 +228,8 @@ public class AF3SystemModelAdapter extends
* defined in the {@link ComponentArchitecture}.
*/
private Collection<ITaskAdapter<Component>> createRealizableDeployableComponents(
- Collection<ITaskAdapter<Component>> deployableComponents)
- throws Exception {
- Collection<ITaskAdapter<Component>> rval =
- new ArrayList<ITaskAdapter<Component>>();
+ Collection<ITaskAdapter<Component>> deployableComponents) throws Exception {
+ Collection<ITaskAdapter<Component>> rval = new ArrayList<ITaskAdapter<Component>>();
rval.addAll(componentReplacementAdapters);
@@ -302,6 +238,33 @@ public class AF3SystemModelAdapter extends
rval.add(deployableComponent);
}
}
+ return rval;
+ }
+
+ /**
+ * Creates the internal representation of signals exchanged between tasks.
+ *
+ * @throws Exception
+ */
+ private Collection<ISignalAdapter<TaskOutputPort>>
+ createSignalAdapters(SuperSet<Signal> signals) throws Exception {
+ // TODO: We could also use the signals directly, but that affects the rest of the DSE. Thus
+ // this change needs to be considered thoroughly and requires (maybe) large changes.
+ Collection<ISignalAdapter<TaskOutputPort>> rval = new ArrayList<>();
+ Multimap<TaskOutputPort, TaskInputPort> outputPorts = HashMultimap.create();
+
+ for(Signal sig : signals.getEntries()) {
+ outputPorts.put((TaskOutputPort)sig.getSource(), (TaskInputPort)sig.getTarget());
+ }
+ for(TaskOutputPort outPort : outputPorts.keys()) {
+ Collection<ITaskAdapter<?>> targetTasks = new HashSet<>();
+ for(TaskInputPort targetIn : outputPorts.get(outPort)) {
+ targetTasks.add(getTaskAdapter((Task)targetIn.getOwner()));
+ }
+ ITaskAdapter<?> targetTask = getTaskAdapter((Task)outPort.getOwner());
+ rval.add(new AF3SignalAdapter(outPort, targetTask, outputPorts.get(outPort),
+ targetTasks));
+ }
return rval;
}
@@ -371,7 +334,6 @@ public class AF3SystemModelAdapter extends
// components) is determined by the minimal period that is propagated to components that are
// not referenced by a periodic constraint.
propagatePeriodsToSuccessors(deployableComponents, possibleComponentPeriods);
- determineEffectivePeriodOfComponents(componentPeriodMap, possibleComponentPeriods);
// TODO: remove these methods. As agreed some time ago, propagation of periods to
// predecessor Components is only needed for under-specified systems, so remove this logic.
@@ -464,67 +426,46 @@ public class AF3SystemModelAdapter extends
// }
// }
- /**
- * Calculates the effective period of all successor components that are not referenced by a
- * periodic constraint from the set of plausible periods propagated from other components. This
- * effective period is calculated by finding the greatest common divisor of all possible periods
- * of a {@link Component}.
- *
- * @throws Exception
- * if the timing specification of any traversed element is inconsistent.
- */
- private void determineEffectivePeriodOfComponents(Map<Component, Double> componentPeriodMap,
- Map<Component, Collection<Double>> possibleComponentPeriods) throws Exception {
-
- for(Entry<Component, Collection<Double>> possibleComponentPeriod : possibleComponentPeriods
- .entrySet()) {
- if(isComponentOrPortsDeployable(possibleComponentPeriod.getKey(), this)) {
- componentPeriodMap.put(possibleComponentPeriod.getKey(),
- gcdDoubleCollection(possibleComponentPeriod.getValue(), GCD_PRECISION));
- }
- }
- }
-
/**
* Determines the allowed data exchange (channels) from an AF3 {@link ComponentArchitecture}.
*
* @throws Exception
*/
- private Collection<ISignalAdapter<OutputPort>>
- createSignalAdapters(Map<OutputPort, Long> messageSizes) throws Exception {
- Collection<ISignalAdapter<OutputPort>> rval = new ArrayList<ISignalAdapter<OutputPort>>();
-
- Collection<Component> af3DeployableComponents = new ArrayList<>();
- deployableComponents.forEach(d -> af3DeployableComponents.add(d.getObject()));
-
- for(OutputPort currentSenderPort : getDeployableOutputPorts(af3DeployableComponents)) {
- ITaskAdapter<?> currentSenderComponentAdapter =
- getDeployableComponentAdapter(currentSenderPort.getComponent());
- if(currentSenderComponentAdapter != null) {
- Collection<ITaskAdapter<?>> receiverComponentAdapters =
- new ArrayList<ITaskAdapter<?>>();
- Collection<Port> targetPorts =
- findTargetPorts(currentSenderPort, af3DeployableComponents);
- for(Port currentReceiverPort : targetPorts) {
- ITaskAdapter<?> receiverComponentAdapter =
- getDeployableComponentAdapter(currentReceiverPort.getComponent());
- receiverComponentAdapters.add(receiverComponentAdapter);
- }
- if(!receiverComponentAdapters.isEmpty()) {
- // Do not consider unconnected Ports
- Collection<InputPort> filteredRecvPorts =
- pickInstanceOf(InputPort.class, new ArrayList<>(targetPorts));
- AF3SignalAdapter sigAdp = new AF3SignalAdapter(currentSenderPort,
- currentSenderComponentAdapter, filteredRecvPorts,
- receiverComponentAdapters, messageSizes.get(currentSenderPort));
- sigAdp.setSignalType(portSignalTypes.get(currentSenderPort));
- rval.add(sigAdp);
- }
- }
- }
-
- return rval;
- }
+ // private Collection<ISignalAdapter<OutputPort>>
+ // createSignalAdapters(Map<OutputPort, Long> messageSizes) throws Exception {
+ // Collection<ISignalAdapter<OutputPort>> rval = new ArrayList<ISignalAdapter<OutputPort>>();
+ //
+ // Collection<Component> af3DeployableComponents = new ArrayList<>();
+ // deployableComponents.forEach(d -> af3DeployableComponents.add(d.getObject()));
+ //
+ // for(OutputPort currentSenderPort : getDeployableOutputPorts(af3DeployableComponents)) {
+ // ITaskAdapter<?> currentSenderComponentAdapter =
+ // getDeployableComponentAdapter(currentSenderPort.getComponent());
+ // if(currentSenderComponentAdapter != null) {
+ // Collection<ITaskAdapter<?>> receiverComponentAdapters =
+ // new ArrayList<ITaskAdapter<?>>();
+ // Collection<Port> targetPorts =
+ // findTargetPorts(currentSenderPort, af3DeployableComponents);
+ // for(Port currentReceiverPort : targetPorts) {
+ // ITaskAdapter<?> receiverComponentAdapter =
+ // getDeployableComponentAdapter(currentReceiverPort.getComponent());
+ // receiverComponentAdapters.add(receiverComponentAdapter);
+ // }
+ // if(!receiverComponentAdapters.isEmpty()) {
+ // // Do not consider unconnected Ports
+ // Collection<InputPort> filteredRecvPorts =
+ // pickInstanceOf(InputPort.class, new ArrayList<>(targetPorts));
+ // AF3SignalAdapter sigAdp = new AF3SignalAdapter(currentSenderPort,
+ // currentSenderComponentAdapter, filteredRecvPorts,
+ // receiverComponentAdapters, messageSizes.get(currentSenderPort));
+ // sigAdp.setSignalType(portSignalTypes.get(currentSenderPort));
+ // rval.add(sigAdp);
+ // }
+ // }
+ // }
+ //
+ // return rval;
+ // }
/**
* Pre-sort the {@link ISignalAdapter}s such that the {@link ITaskAdapter}s
@@ -538,24 +479,24 @@ public class AF3SystemModelAdapter extends
* inconsistent timing specification.
*/
// TODO: cleanup or get rid of this method.
- private Collection<ISignalAdapter<OutputPort>> sortMessagesByExpectedOrder(
- Collection<ISignalAdapter<OutputPort>> unsortedMessages,
- Map<Component, Double> componentPeriodMap) throws Exception {
- Collection<ISignalAdapter<OutputPort>> rval = new ArrayList<ISignalAdapter<OutputPort>>();
- for(ISignalAdapter<OutputPort> currentMessage : unsortedMessages) {
- Double periodValue = componentPeriodMap.get(currentMessage.getSource().getObject());
- if(periodValue != null && periodValue > 0) {
- rval.add(currentMessage);
- }
- }
- for(ISignalAdapter<OutputPort> currentMessage : unsortedMessages) {
- Double periodValue = componentPeriodMap.get(currentMessage.getSource().getObject());
- if(periodValue == null || periodValue <= 0) {
- rval.add(currentMessage);
- }
- }
- return rval;
- }
+ // private Collection<ISignalAdapter<OutputPort>> sortMessagesByExpectedOrder(
+ // Collection<ISignalAdapter<OutputPort>> unsortedMessages,
+ // Map<Component, Double> componentPeriodMap) throws Exception {
+ // Collection<ISignalAdapter<OutputPort>> rval = new ArrayList<ISignalAdapter<OutputPort>>();
+ // for(ISignalAdapter<OutputPort> currentMessage : unsortedMessages) {
+ // Double periodValue = componentPeriodMap.get(currentMessage.getSource().getObject());
+ // if(periodValue != null && periodValue > 0) {
+ // rval.add(currentMessage);
+ // }
+ // }
+ // for(ISignalAdapter<OutputPort> currentMessage : unsortedMessages) {
+ // Double periodValue = componentPeriodMap.get(currentMessage.getSource().getObject());
+ // if(periodValue == null || periodValue <= 0) {
+ // rval.add(currentMessage);
+ // }
+ // }
+ // return rval;
+ // }
/**
* Creates {@link IMemoryUnitAdapter}s from AF3-{@link MemoryUnit}s.
@@ -563,21 +504,24 @@ public class AF3SystemModelAdapter extends
* @throws Exception
*/
private Collection<IMemoryUnitAdapter<MemoryUnit>> createMemoryUnits(
- PlatformArchitecture platformArchitecture,
- Map<IPlatformArchitectureElement, Double> resourceFailureRates) throws Exception {
+ PlatformArchitecture platformArchitecture/*
+ * ,
+ * Map<IPlatformArchitectureElement, Double>
+ * resourceFailureRates
+ */) throws Exception {
Collection<IMemoryUnitAdapter<MemoryUnit>> rval =
new ArrayList<IMemoryUnitAdapter<MemoryUnit>>();
for(MemoryUnit currentMemoryUnit : getChildrenWithType(platformArchitecture,
MemoryUnit.class)) {
- Double failureRate = resourceFailureRates.get(currentMemoryUnit);
+ // Double failureRate = resourceFailureRates.get(currentMemoryUnit);
// if(failureRate == null) {
// throw new Exception("The failure probablity for the " +
// currentMemoryUnit.getClass().getSimpleName() + " " +
// currentMemoryUnit.getName() + " has not been defined.");
// }
- rval.add(new AF3MemoryUnitAdapter(currentMemoryUnit, failureRate));
+ rval.add(new AF3MemoryUnitAdapter(currentMemoryUnit, 0.8/* failureRate */));
}
return rval;
@@ -588,9 +532,14 @@ public class AF3SystemModelAdapter extends
*
* @throws Exception
*/
+ // TODO(#3262): Reintegrate failure rates.
private Collection<IExecutionUnitAdapter<ExecutionUnit>> createDeploymentTargets(
- Collection<ExecutionUnit> targetExecutionUnits,
- Map<IPlatformArchitectureElement, Double> resourceFailureProbabilies) throws Exception {
+ Collection<ExecutionUnit> targetExecutionUnits/**
+ * ,
+ * Map<IPlatformArchitectureElement,
+ * Double> resourceFailureProbabilies
+ */
+ ) throws Exception {
if(targetExecutionUnits.isEmpty()) {
throw new Exception(
"No deployment targets have been specified in the target platform architecture(s). Please check whether the correct platform architecture was selected and whether the desired Execution Units were selected as deployment targets (Platform Model --> Annotation View --> Deployment Target)");
@@ -600,35 +549,8 @@ public class AF3SystemModelAdapter extends
new ArrayList<IExecutionUnitAdapter<ExecutionUnit>>();
for(ExecutionUnit execUnit : targetExecutionUnits) {
- Double failureProb = resourceFailureProbabilies.get(execUnit);
- rval.add(new AF3ExecutionUnitAdapter(execUnit, failureProb));
- }
-
- return rval;
- }
-
- // TODO: AD: I assume this mapping can be removed soon. However, there must be a decision
- // whether all possible communication paths shall be stored or if the required paths shall be
- // calculated when needed, i.e. during scheduling.
- /**
- * Build mapping virtual resource -> hardware resource onto which virtual resource is
- * statically mapped, e.g., partition -> hardware execution unit / processor core.
- */
- private Map<IResourceAdapter<?>, IResourceAdapter<?>>
- createVirtualResourceToHardwareResourceMap() {
- Map<IResourceAdapter<?>, IResourceAdapter<?>> rval =
- new HashMap<IResourceAdapter<?>, IResourceAdapter<?>>();
-
- // TODO: Dummy 1:1 mapping, assuming a flat platform architecture consisting of processors
- // communication units. See {@link #createDeploymentTargets}.
- for(IExecutionUnitAdapter<?> deploymentTarget : getDeploymentTargets()) {
- rval.put(deploymentTarget, deploymentTarget);
- }
- for(ITransmissionUnitAdapter<?> transmissionUnit : getTransmissionUnits()) {
- rval.put(transmissionUnit, transmissionUnit);
- }
- for(IGatewayUnitAdapter<?> gatewayUnit : getGatewayUnits()) {
- rval.put(gatewayUnit, gatewayUnit);
+ // Double failureProb = resourceFailureProbabilies.get(execUnit);
+ rval.add(new AF3ExecutionUnitAdapter(execUnit, 0.8/* failureProb */));
}
return rval;
@@ -640,28 +562,16 @@ public class AF3SystemModelAdapter extends
*
* @throws Exception
*/
- private Collection<IGatewayUnitAdapter<GatewayUnit>> createGatewayUnits(
- PlatformArchitecture platformArchitecture,
- Map<IPlatformArchitectureElement, Double> resourceFailureRates,
- Map<IPlatformResource, Double> resourcePowerConsumption) throws Exception {
+ // TODO(#3262): Also power here...
+ private Collection<IGatewayUnitAdapter<GatewayUnit>>
+ createGatewayUnits(PlatformArchitecture platformArchitecture) throws Exception {
Collection<IGatewayUnitAdapter<GatewayUnit>> rval =
new ArrayList<IGatewayUnitAdapter<GatewayUnit>>();
for(GatewayUnit gatewayUnit : EcoreUtils.getChildrenWithType(platformArchitecture,
GatewayUnit.class)) {
- Double failureRate = resourceFailureRates.get(gatewayUnit);
- // if(failureRate == null) {
- // throw new Exception("The failure probablity for the " +
- // gatewayUnit.getClass().getSimpleName() + " " + gatewayUnit.getName() +
- // " has not been defined.");
- // }
- Double power = resourcePowerConsumption.get(gatewayUnit);
- // TODO: We do not have a power annotation for gateways yet.
- // if(power == null) {
- // throw new Exception("The failure probability for the " +
- // gatewayUnit.getClass().getSimpleName() + " " + gatewayUnit.getName() +
- // " has not been defined.");
- // }
+ Double failureRate = 0.8;// resourceFailureRates.get(gatewayUnit);
+ Double power = 1.0;// resourcePowerConsumption.get(gatewayUnit);
rval.add(new AF3GatewayAdapter(gatewayUnit, failureRate, power));
}
@@ -674,31 +584,16 @@ public class AF3SystemModelAdapter extends
*
* @throws Exception
*/
- private Collection<ITransmissionUnitAdapter<TransmissionUnit>> createTransmissionUnits(
- PlatformArchitecture platformArchitecture,
- Map<IPlatformArchitectureElement, Double> resourceFailureRates,
- Map<IPlatformResource, Double> resourcePowerConsumption) throws Exception {
+ // TODO(#3262): Also power, here.
+ private Collection<ITransmissionUnitAdapter<TransmissionUnit>>
+ createTransmissionUnits(PlatformArchitecture platformArchitecture) throws Exception {
Collection<ITransmissionUnitAdapter<TransmissionUnit>> rval =
new ArrayList<ITransmissionUnitAdapter<TransmissionUnit>>();
for(TransmissionUnit transmissionUnit : EcoreUtils.getChildrenWithType(platformArchitecture,
TransmissionUnit.class)) {
- Double failureRate = resourceFailureRates.get(transmissionUnit);
- // TODO: Virtual TransmissionUnits currently do not have ResourceLinks to their physical
- // counterparts.
- // if(!(transmissionUnit instanceof IVirtualizationPlatformArchitectureElement) &&
- // failureRate == null) {
- // throw new Exception("The failure probablity for the " +
- // transmissionUnit.getClass().getSimpleName() + " " +
- // transmissionUnit.getName() + " has not been defined.");
- // }
- Double power = resourcePowerConsumption.get(transmissionUnit);
- // if(!(transmissionUnit instanceof IVirtualizationPlatformArchitectureElement) &&
- // power == null) {
- // throw new Exception("The failure probablity for the " +
- // transmissionUnit.getClass().getSimpleName() + " " +
- // transmissionUnit.getName() + " has not been defined.");
- // }
+ Double failureRate = 0.8;// resourceFailureRates.get(transmissionUnit);
+ Double power = 1.0;// resourcePowerConsumption.get(transmissionUnit);
rval.add(new AF3TransmissionUnitAdapter(transmissionUnit, failureRate, power));
}
@@ -718,30 +613,10 @@ public class AF3SystemModelAdapter extends
*/
private Collection<IResourceAdapter<?>> createAvailableResources() {
Collection<IResourceAdapter<?>> rval = new ArrayList<IResourceAdapter<?>>();
-
- // TODO: Do we need to consider more than the deployment target execution units here?
- // Only consider ExecutionUnits whose container are not marked as deployment targets.
- // for(ExecutionUnit execUnit : getChildrenWithType(
- // (PlatformArchitecture)platformArchitecture.getObject(), ExecutionUnit.class)) {
- // if(!isAnyParentDeploymentTarget(execUnit, deploymentTargets)) {
- // rval.add(execUnit);
- // }
- // }
- // // Also for the hardware platform, if the primary platform is a virtual one.
- // if(hardwarePlatformArchitecture != null) {
- // for(ExecutionUnit execUnit : getChildrenWithType(hardwarePlatformArchitecture,
- // ExecutionUnit.class)) {
- // if(!isAnyParentDeploymentTarget(execUnit, deploymentTargets)) {
- // rval.add(execUnit);
- // }
- // }
- // }
-
rval.addAll(deploymentTargets);
rval.addAll(memoryUnits);
rval.addAll(gatewayUnits);
rval.addAll(transmissionUnits);
-
return rval;
}
@@ -752,14 +627,8 @@ public class AF3SystemModelAdapter extends
* @throws Exception
* if the end point of a connection cannot be determined.
*/
- private Collection<IResourceConnectionAdapter> createDeploymentTargetConnectors(
+ private Collection<IResourceConnectionAdapter> createPlatfromResourceConnections(
Collection<ExecutionUnit> af3DeploymentTargets) throws Exception {
-
- // Create a map that captures the inverse link of from one IModelElement to another
- // IModelelement.
- Map<IModelElement, IModelElement> invElementReferences = getInverseIntraPlatformReferences(
- (PlatformArchitecture)platformArchitecture.getObject(), platformInterconnectTypes);
-
// Initial traversal list of IConnectors attached to ExecutionUnits selected as deployment
// targets.
LinkedList<IConnector> deployableConnectors = new LinkedList<IConnector>();
@@ -783,8 +652,8 @@ public class AF3SystemModelAdapter extends
// Path walk to determine the *real* connection targets, i.e. ignore hull elements
// like Tiles whose contained Cores (or partitions) were selected as deployment
// targets.
- Collection<IConnector> targetConnectors = getEffectiveConnectionTargets(
- currentConnector, invElementReferences, af3DeploymentTargets);
+ Collection<IConnector> targetConnectors =
+ getEffectiveConnectionTargets(currentConnector, af3DeploymentTargets);
// Create an IResourceConnectionAdapter between the sourceElement of the traversal
// and the *real* targets.
@@ -803,8 +672,8 @@ public class AF3SystemModelAdapter extends
for(IConnector currentTargetConnector : targetConnectors) {
targetElements.add(currentTargetConnector.getOwner());
}
- determineNextConnectionTargets(invElementReferences, deployableConnectors,
- visitedConnectors, targetElements, af3DeploymentTargets);
+ determineNextConnectionTargets(deployableConnectors, visitedConnectors,
+ targetElements, af3DeploymentTargets);
}
}
@@ -813,78 +682,20 @@ public class AF3SystemModelAdapter extends
/**
* Collect the IConnectors attached to the target elements of the created
- * IResourceConnectionAdapter for further traversing the PlatformArchitecture. Connections
- * between IModelElements of different PlatformArchitectures which are realized via ResourceLink
- * specifications are automatically considered.
- *
- * @throws InvalidPlatformModelException
- * if the references from the referencing {@link IModelElement} to the target
- * {@link IModelElement} are incorrectly specified.
+ * IResourceConnectionAdapter for further traversing the PlatformArchitecture.
*/
// TODO: Refactor this method to use the static methods from the AF3Utils class instead.
- private void determineNextConnectionTargets(
- Map<IModelElement, IModelElement> invElementReferences,
- LinkedList<IConnector> deployableConnectors, Collection<IConnector> visitedConnectors,
- Collection<IHierarchicElement> targetElements,
- Collection<ExecutionUnit> af3DeploymentTargets) throws InvalidPlatformModelException {
+ private void determineNextConnectionTargets(LinkedList<IConnector> deployableConnectors,
+ Collection<IConnector> visitedConnectors, Collection<IHierarchicElement> targetElements,
+ Collection<ExecutionUnit> af3DeploymentTargets) {
for(IHierarchicElement targetElement : targetElements) {
if(targetElement instanceof IPlatformResource &&
!af3DeploymentTargets.contains(targetElement)) {
for(IConnector connectorAtTarget : targetElement.getConnectors()) {
// Do not traverse back again.
if(connectorAtTarget != targetElement) {
- if(!connectsSwHwPlatform(connectorAtTarget, invElementReferences)) {
- if(!visitedConnectors.contains(connectorAtTarget)) {
- deployableConnectors.add(connectorAtTarget);
- }
- } else if(connectsSwHwPlatform(connectorAtTarget)) {
- // Special treatment for the connection between the virtual
- // platform and the physical platform.
- GatewayUnit currentNetworkDriver =
- (GatewayUnit)connectorAtTarget.getOwner();
- List<GatewayUnit> referencedNetworkInterfaces =
- getReferencedElementsWithType(currentNetworkDriver,
- GatewayUnit.class);
-
- // TODO: consider moving this check to the input model validation.
- if(referencedNetworkInterfaces.size() == 0) {
- throw new InvalidPlatformModelException(currentNetworkDriver,
- "No Network Interface is referenced in the ResourceLink annotation. Please specify at least one reference.");
- }
-
- if(!visitedConnectors.contains(connectorAtTarget)) {
- for(GatewayUnit refNi : referencedNetworkInterfaces) {
- Collection<IHierarchicElement> targets =
- new ArrayList<IHierarchicElement>();
- targets.add(currentNetworkDriver);
- if(isAnyChildDeploymentTarget(
- (IPlatformResource)refNi.getContainer(),
- af3DeploymentTargets, ExecutionUnit.class)) {
- deployableConnectors.addAll(refNi.getConnectors());
- } else {
- deployableConnectors.addAll(pickInstanceOf(
- IPlatformExport.class, refNi.getConnectors()));
- }
- }
- }
- visitedConnectors.add(connectorAtTarget);
- } else if(invElementReferences.get(connectorAtTarget.getOwner()) != null) {
- // Special treatment for the connection between the physical platform
- // and the virtual platform.
- GatewayUnit currentNetworkDriver = (GatewayUnit)invElementReferences
- .get(connectorAtTarget.getOwner());
- IPlatformExport driverExport = pickFirstInstanceOf(
- IPlatformExport.class, currentNetworkDriver.getConnectors());
-
- if(!visitedConnectors.contains(driverExport)) {
- Collection<IHierarchicElement> targets =
- new ArrayList<IHierarchicElement>();
- targets.add(driverExport.getOwner());
- deployableConnectors
- .addAll(driverExport.getOwner().getConnectors());
-
- visitedConnectors.add(driverExport);
- }
+ if(!visitedConnectors.contains(connectorAtTarget)) {
+ deployableConnectors.add(connectorAtTarget);
}
}
}
@@ -950,15 +761,15 @@ public class AF3SystemModelAdapter extends
* AF3 {@link Component}. Returns null if no matching {@link ITaskAdapter} is
* found.
*/
- public ITaskAdapter<?> getDeployableComponentAdapter(Component af3Component) {
- if(af3Component == null) {
+ public ITaskAdapter<?> getTaskAdapter(Task af3Task) {
+ if(af3Task == null) {
throw new IllegalArgumentException(
"Cannot identify IDeployableComponentAdapters for 'null' Components");
}
ITaskAdapter<?> deployableComponentAdapter = null;
for(ITaskAdapter<Component> deployableComponent : deployableComponents) {
- if(deployableComponent.getObject() == af3Component) {
+ if(deployableComponent.getObject() == af3Task) {
deployableComponentAdapter = deployableComponent;
break;
}
@@ -1053,13 +864,12 @@ public class AF3SystemModelAdapter extends
}
/** Determine task graph for a given component */
- public TaskGraph getTaskGraph(Component component) {
+ public TaskGraph getTaskGraph(Task task) {
// TODO: AD: The cast to the AF3 systemmodeladapter breaks the abstration the goals. It
// would be rather required to define the source and sink components as
// IDeployableComponents in the ecore model. The transformation from AF3 components to the
// IDeployableCompontes should be done when the data from the GUI is written to the model.
- ITaskAdapter<?> deployableComponent =
- getDeployableComponentAdapter(component);
+ ITaskAdapter<?> deployableComponent = getTaskAdapter(task);
return getTaskGraph(deployableComponent);
}
}
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/.ratings b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/.ratings
index ec946803..aeb306a5 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/.ratings
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/.ratings
@@ -1 +1 @@
-DSEPortingUtils.java abdb9e06061ae3f6e22a6f1e00c0b8fe3c43153d RED
+DSEPortingUtils.java 1cff814a5f34ff225087df1c807c0257a3d36b15 RED
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/DSEPortingUtils.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/DSEPortingUtils.java
index b94ffa63..d528e942 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/DSEPortingUtils.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/port/DSEPortingUtils.java
@@ -71,6 +71,7 @@ public class DSEPortingUtils {
* {@link IConnector}.
*/
// TODO: UsePlatformPort?
+ @Deprecated
public static Map<Class<? extends IConnector>, ConnectionType> connectionTypeLUT =
Collections.unmodifiableMap(new HashMap<Class<? extends IConnector>, ConnectionType>() {
{
@@ -85,6 +86,7 @@ public class DSEPortingUtils {
* {@link IConnector} to be examined.
* @return The port type (default = bidirectional).
*/
+ @Deprecated
public static ConnectionType getPortDirection(IConnector sourceConnector) {
ConnectionType connectionTypeSource = connectionTypeLUT.get(sourceConnector.getClass());
return connectionTypeSource != null ? connectionTypeSource : BIDIRECTIONAL;
@@ -95,6 +97,7 @@ public class DSEPortingUtils {
* collection of {@code platformArchitecture}s.
*/
// TODO: Outdated Comment, the identification
+ @Deprecated
public static Collection<ExecutionUnit>
createDeploymentTargets(ExplorationSpecification expSpec) throws Exception {
Collection<ExecutionUnit> rval = new HashSet<>();
@@ -163,6 +166,7 @@ public class DSEPortingUtils {
* Creates a Map that relates all annotated {@link IPlatformArchitectureElement}s with their
* specified failure rate.
*/
+ @Deprecated
public static Map<IPlatformArchitectureElement, Double> createFailureRateMap(
Collection<PlatformArchitecture> platformArchitectures) throws Exception {
Map<IPlatformArchitectureElement, Double> failureRateMap = new HashMap<>();
@@ -189,6 +193,7 @@ public class DSEPortingUtils {
*/
// TODO: check, whether it make sense to move the failure rate annotation to the AF3 platform
// since it would allow a simple analysis of hierarchical platforms.
+ @Deprecated
public static Double getResourceFailureRate(IPlatformArchitectureElement resourceElement)
throws Exception {
@@ -249,6 +254,7 @@ public class DSEPortingUtils {
* Creates a map of all {@link IPlatformResource} which have an annotated power consumption
* value and their specified value.
*/
+ @Deprecated
public static Map<IPlatformResource, Double> createPowerConsumptionMap(
Collection<PlatformArchitecture> platformArchitectures) throws Exception {
Map<IPlatformResource, Double> powerConsumptionMap = new HashMap<>();
@@ -260,6 +266,7 @@ public class DSEPortingUtils {
// TODO: We need a way to define the energy consumed by transmission units like busses: stand-by
// + active. Currently, we hard-code the consumed energy while a transmission Unit is active
// while we assue that it does not consume energy in the idle state.
+ @Deprecated
public static Map<IPlatformResource, Double> getTransmissionUnitPowerConsumption(
Collection<PlatformArchitecture> platformArchitectures) {
Map<IPlatformResource, Double> powerConsumptionMap = new HashMap<>();
@@ -277,6 +284,7 @@ public class DSEPortingUtils {
* {@link Component} are not supported.
*/
// TODO: The period is hard-coded here. It must be taken from the yet-to-come timing model.
+ @Deprecated
public static Map<Component, Double>
createComponentPeriodMap(Collection<Component> deployableComponents) {
Map<Component, Double> componentPeriodMap = new HashMap<>();
@@ -291,6 +299,7 @@ public class DSEPortingUtils {
* selected as their diverse implementations by means of the {@link ComponentDiverseImplRef}
* annotation.
*/
+ @Deprecated
public static Multimap<Component, Component>
createComponentReplacementMap(Collection<Component> deployableComponent) {
Multimap<Component, Component> replacementComponentMap = HashMultimap.create();
@@ -310,6 +319,7 @@ public class DSEPortingUtils {
*/
// TODO: How to handle replication? Will be done on the Task level. Annotation can be registered
// in THIS exploration plugin.
+ @Deprecated
public static Map<Component, Pair<Integer, Integer>> createComponentReplicationMap(
Collection<Component> deployableComponents) throws Exception {
Map<Component, Pair<Integer, Integer>> replicationBoundMap = new HashMap<>();
@@ -334,6 +344,7 @@ public class DSEPortingUtils {
* Collection of {@link Component}s tthat shall be deployed.
* @return Map of the ports with a temporal trigger.
*/
+ @Deprecated
public static TemporalTriggers
getPortTimingProperties(DeployableComponents deployableComponents) {
TemporalTriggers portSignalTypes = new TemporalTriggers();
@@ -346,6 +357,7 @@ public class DSEPortingUtils {
}
/** Maps the {@link OutputPort}s of {@link Component}s to their respective bit size. */
+ @Deprecated
public static Map<OutputPort, Long>
createMessageSizeMap(Collection<Component> deployableComponents) throws Exception {
Map<OutputPort, Long> messageSizes = new HashMap<>();
@@ -374,6 +386,7 @@ public class DSEPortingUtils {
* Creates a container that contains all required and optional information to execute the
* MOEA-based DSE which are not AF3 standard parameters.
*/
+ @Deprecated
public static SystemParameterContainer createSystemParameterContainer(
PlatformArchitecture platformArchitecture, TaskArchitecture taskArchitecture,
ExplorationSpecification expSpec) throws Exception {
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/.ratings b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/.ratings
index 89958197..c1f40fb6 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/.ratings
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/.ratings
@@ -1,4 +1,4 @@
-AF3Utils.java 21464822e84d3084af72ad0248bac03033989041 RED
+AF3Utils.java 3d20c4fe4fdddb4598ffb4965e12a4c833d16b2d RED
DesignSpaceExplorationModelElementFactory.java 9dc330973f132c4b936e4dc7ee8407614faf2ff6 RED
ExplorationAlgDebugUtils.java 06116a61e99717a59b7b01e4e2865bf044a8a0e2 RED
ExplorationAlgUtils.java 2cf411c8d8404d7319d7bc836dd74b5927375711 RED
diff --git a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/AF3Utils.java b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/AF3Utils.java
index e1903a69..7845c416 100644
--- a/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/AF3Utils.java
+++ b/org.fortiss.af3.exploration.alg/trunk/src/org/fortiss/af3/exploration/alg/util/AF3Utils.java
@@ -15,7 +15,6 @@
+--------------------------------------------------------------------------*/
package org.fortiss.af3.exploration.alg.util;
-import static org.fortiss.af3.component.utils.ComponentArchitectureUtils.isAtomicComponent;
import static org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IResourceConnectionAdapter.ConnectionType.BIDIRECTIONAL;
import static org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IResourceConnectionAdapter.ConnectionType.INCOMING;
import static org.fortiss.af3.exploration.alg.dse.sysmodel.arch.IResourceConnectionAdapter.ConnectionType.OUTGOING;
@@ -64,7 +63,6 @@ import org.fortiss.af3.exploration.alg.exception.InvalidPlatformModelException;
import org.fortiss.af3.exploration.alg.exception.InvalidTimingModelException;
import org.fortiss.af3.exploration.alg.guava.TypedBiMap;
import org.fortiss.af3.exploration.moea.model.predefined.ComponentMultiAllocationConstraint;
-import org.fortiss.af3.platform.model.ExecutionUnit;
import org.fortiss.af3.platform.model.IPlatformPort;
import org.fortiss.af3.platform.model.IPlatformResource;
import org.fortiss.af3.platform.model.IVirtualizationPlatformArchitectureElement;
@@ -292,17 +290,16 @@ public class AF3Utils {
throws InvalidPlatformModelException {
// By the method signature, we know the instance type is a IConnector class.
@SuppressWarnings("unchecked") ConnectionType connectionTypeSource =
- systemModelAdapter.getConnectionType((Class<? extends IConnector>)sourceConnector
- .eClass().getInstanceClass());
+ systemModelAdapter.getConnectionType(
+ (Class<? extends IConnector>)sourceConnector.eClass().getInstanceClass());
@SuppressWarnings("unchecked") ConnectionType connectionTypeTarget =
- systemModelAdapter.getConnectionType((Class<? extends IConnector>)targetConnector
- .eClass().getInstanceClass());
+ systemModelAdapter.getConnectionType(
+ (Class<? extends IConnector>)targetConnector.eClass().getInstanceClass());
// assert (connectionTypeSource != null && connectionTypeTarget != null) :
// "Could not identify the type of one of the connection targets.";
if((connectionTypeSource == INCOMING && connectionTypeTarget == INCOMING) ||
(connectionTypeSource == OUTGOING && connectionTypeTarget == OUTGOING)) {
- throw new InvalidPlatformModelException(
- (PlatformConnectorUnit)sourceConnector,
+ throw new InvalidPlatformModelException((PlatformConnectorUnit)sourceConnector,
"A platform port or interface (see above) for incoming or outgoing traffic is connected to an port or interface of the same type. This is not allowed.");
}
@@ -336,8 +333,8 @@ public class AF3Utils {
SystemModelAdapter<?, ?, ?, ?, ?, ?> systemModelAdapter) {
// By the method signature, we know the instance type is a IConnector class.
@SuppressWarnings("unchecked") ConnectionType connectionTypeSource =
- systemModelAdapter.getConnectionType((Class<? extends IConnector>)sourceConnector
- .eClass().getInstanceClass());
+ systemModelAdapter.getConnectionType(
+ (Class<? extends IConnector>)sourceConnector.eClass().getInstanceClass());
return connectionTypeSource != null ? connectionTypeSource : BIDIRECTIONAL;
}
@@ -345,8 +342,8 @@ public class AF3Utils {
* Predicate whether the subject {@link PlatformConnectorUnit} is a connector of the given
* {@link IModelElementAdapter}.
*/
- public static boolean
- isConnectorOf(PlatformConnectorUnit pConn, IModelElementAdapter<?> element) {
+ public static boolean isConnectorOf(PlatformConnectorUnit pConn,
+ IModelElementAdapter<?> element) {
return pConn.getOwner() == element.getObject();
}
@@ -365,18 +362,16 @@ public class AF3Utils {
* {@link PlatformConnectorUnit} for the device-internal communication of the given
* {@link IModelElementAdapter}.
*/
- public static boolean
- isDeviceInternalPredecessor(PlatformConnectorUnit connCandidate,
- IModelElementAdapter<?> element,
- DirectedGraph<PlatformConnectorUnit, DefaultEdge> route) {
+ public static boolean isDeviceInternalPredecessor(PlatformConnectorUnit connCandidate,
+ IModelElementAdapter<?> element,
+ DirectedGraph<PlatformConnectorUnit, DefaultEdge> route) {
// The following rules apply for device internal communication:
// - Sender Port is on the same device OR
// - its reference port is one layer "below", e.g. Gateway -> Router AND
// - the sender connector must have been traversed (natural for path walking a multicast
// message.
- if(route.containsVertex(connCandidate) &&
- (isConnectorOf(connCandidate, element) || isContainedInResource(connCandidate,
- element))) {
+ if(route.containsVertex(connCandidate) && (isConnectorOf(connCandidate, element) ||
+ isContainedInResource(connCandidate, element))) {
return true;
}
return false;
@@ -434,9 +429,12 @@ public class AF3Utils {
* Checks whether any parent {@link IPlatformResource} of the given {@code element} is a
* deployment target defined by the set of deployment targets ({@code deploymentTargets}).
* If any parent element has been found that is a deployment target, {@code true} is returned.
- * The method considers parents in the following order: <li>Check the direct parent (container).
- * </li> <li>Check all referenced resources as defined in the {@link ResourceLink} annotation.</li>
- * <li>Go to the parent resource and run the same checks.</li> <li>Run the above checks for all
+ * The method considers parents in the following order:
+ * <li>Check the direct parent (container).
+ * </li>
+ * <li>Check all referenced resources as defined in the {@link ResourceLink} annotation.</li>
+ * <li>Go to the parent resource and run the same checks.</li>
+ * <li>Run the above checks for all
* references Resources as given by the {@link ResourceLink} annotations.</>
*
* @param element
@@ -484,8 +482,8 @@ public class AF3Utils {
public static <T extends IPlatformResource & IHierarchicElement> boolean
isAnyChildDeploymentTarget(IPlatformResource element, Collection<T> deploymentTargets,
Class<T> targetType) {
- return getChildrenWithType(element, targetType).stream().anyMatch(
- child -> deploymentTargets.contains(child));
+ return getChildrenWithType(element, targetType).stream()
+ .anyMatch(child -> deploymentTargets.contains(child));
}
/**
@@ -499,11 +497,9 @@ public class AF3Utils {
* thereby establish a "communication link" between both platforms.
* @return Map representing the "inverse" 1:1 references of {@link ResourceLink}s.
*/
- public static
- Map<IModelElement, IModelElement>
- getInverseIntraPlatformReferences(
- PlatformArchitecture referencingPlatformArchitecture,
- Pair<Class<? extends IModelElement>, Class<? extends IModelElement>> interPlatformConnectingElements) {
+ public static Map<IModelElement, IModelElement> getInverseIntraPlatformReferences(
+ PlatformArchitecture referencingPlatformArchitecture,
+ Pair<Class<? extends IModelElement>, Class<? extends IModelElement>> interPlatformConnectingElements) {
if(interPlatformConnectingElements == null) {
return Collections.emptyMap();
}
@@ -556,12 +552,12 @@ public class AF3Utils {
* @return Set of {@link ComponentMultiAllocationConstraint}s with the same references as the
* {@link ComponentAllocation}s.
*/
- public static Collection<ComponentMultiAllocationConstraint> createConstraintsFromDeployment(
- Deployment deployment) {
+ public static Collection<ComponentMultiAllocationConstraint>
+ createConstraintsFromDeployment(Deployment deployment) {
Collection<ComponentAllocation> allocatedComponents = deployment.getComponentAllocations();
Function<ComponentAllocation, ComponentMultiAllocationConstraint> mapper =
- ca -> createComponentMultiAllocationConstraint(ca.getComponent(), new BasicEList<>(
- Arrays.asList(ca.getExecutionUnit())));
+ ca -> createComponentMultiAllocationConstraint(ca.getComponent(),
+ new BasicEList<>(Arrays.asList(ca.getExecutionUnit())));
return allocatedComponents.stream().map(mapper)
.map(ComponentMultiAllocationConstraint.class::cast).collect(Collectors.toList());
}
@@ -579,10 +575,8 @@ public class AF3Utils {
* @return The {@link ComponentArchitecture} identified as the <i>Component Pool</i> or
* {@code null} if none is found.
*/
- public static
- ComponentArchitecture
- getFirstComponentPool(
- IMappingEncoding<ITaskAdapter<?>, IResourceAdapter<?>, IMappingEntry<ITaskAdapter<?>, IResourceAdapter<?>>> mapping) {
+ public static ComponentArchitecture getFirstComponentPool(
+ IMappingEncoding<ITaskAdapter<?>, IResourceAdapter<?>, IMappingEntry<ITaskAdapter<?>, IResourceAdapter<?>>> mapping) {
for(ITaskAdapter<?> deployableComponent : mapping.getRequesters()) {
if(deployableComponent.isInstantiation()) {
// TODO: Avoid casting: Parameterize the IModelElementAdapter to use EObject-derived
@@ -672,9 +666,8 @@ public class AF3Utils {
EList<Component> parentElements = getParentsWithType(startElement, Component.class);
for(Component parentComponent : parentElements) {
- AbstractTaskMappingEntry entry =
- (AbstractTaskMappingEntry)encEntryModelElemAssoc.inverse().get(parentComponent,
- AbstractTaskMappingEntry.class);
+ AbstractTaskMappingEntry entry = (AbstractTaskMappingEntry)encEntryModelElemAssoc
+ .inverse().get(parentComponent, AbstractTaskMappingEntry.class);
if(entry != null) {
return true;
}
@@ -682,36 +675,4 @@ public class AF3Utils {
return false;
}
-
- /**
- * Predicate if a the given {@link Component} is principally deployable, i.e. it is either
- * defined to be deployable (e.g., by a trigger) or an atomic {@link Component}.
- *
- * @param deployComponent
- * The {@link Component} to be checked whether it shall be deployed onto
- * {@link ExecutionUnit}s
- * @param systemModelAdapter
- * Abstraction of the input models.
- * @return boolean, if the given {@link Component} shall be considered deployable.
- * @throws Exception
- * if the timing specification of any traversed element is inconsistent.
- */
- public static boolean isComponentOrPortsDeployable(Component deployComponent,
- SystemModelAdapter<Component, ?, ?, ?, ?, ?> systemModelAdapter) throws Exception {
- for(Port port : deployComponent.getInputPorts()) {
- if(systemModelAdapter.isDeployablePort(port)) {
- return true;
- }
- }
- for(Port port : deployComponent.getOutputPorts()) {
- if(systemModelAdapter.isDeployablePort(port)) {
- return true;
- }
- }
- if(systemModelAdapter.isDeployableComponent(deployComponent) ||
- (!isAnyParentComponentDeployable(deployComponent, systemModelAdapter) && isAtomicComponent(deployComponent))) {
- return true;
- }
- return false;
- }
}
--
GitLab