| /** |
| * ******************************************************************************* |
| * Copyright (c) 2019 Robert Bosch GmbH and others. |
| * |
| * This program and the accompanying materials are made |
| * available under the terms of the Eclipse Public License 2.0 |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Robert Bosch GmbH - initial API and implementation |
| * ******************************************************************************* |
| */ |
| |
| package templates.m2m.sw.runnableItem |
| |
| import com.google.inject.Singleton |
| import com.inchron.realtime.root.model.Time |
| import com.inchron.realtime.root.model.TimeDistributionType |
| import com.inchron.realtime.root.model.TimeUnit |
| import org.eclipse.app4mc.amalthea.model.Amalthea |
| import org.eclipse.app4mc.amalthea.model.DiscreteValueBetaDistribution |
| import org.eclipse.app4mc.amalthea.model.DiscreteValueGaussDistribution |
| import org.eclipse.app4mc.amalthea.model.DiscreteValueHistogram |
| import org.eclipse.app4mc.amalthea.model.DiscreteValueUniformDistribution |
| import org.eclipse.app4mc.amalthea.model.Process |
| import org.eclipse.app4mc.amalthea.model.Ticks |
| import org.eclipse.app4mc.amalthea.model.util.DeploymentUtil |
| import org.eclipse.emf.ecore.util.EcoreUtil |
| import templates.AbstractAmaltheaInchronTransformer |
| import org.eclipse.app4mc.amalthea.model.ProcessingUnit |
| |
| @Singleton |
| class TicksTransformer extends AbstractAmaltheaInchronTransformer { |
| |
| def create inchronModelFactory.createResourceConsumption createResourceConsumption(Process amltTask, |
| Ticks amltTicks) { |
| it.name = "RC" |
| it.timeDistribution = createTicksDistribution(amltTask, amltTicks) |
| } |
| |
| def create inchronModelFactory.createTimeDistribution createTicksDistribution(Process amltTask, Ticks amltTicks) { |
| |
| var amltCores = DeploymentUtil.getAssignedCoreForProcess(amltTask, |
| EcoreUtil.getRootContainer(amltTask) as Amalthea); |
| |
| //get distribution (extended if provided by the model element) |
| var ProcessingUnit amltCore = null |
| |
| if(amltCores!==null && amltCores.size>0){ |
| amltCore=amltCores?.get(0) |
| } |
| |
| var amltDistribution = amltTicks?.extended.get(amltCore?.definition) |
| if (amltDistribution === null) { |
| amltDistribution = amltTicks.^default |
| } |
| |
| if(amltDistribution===null) |
| { |
| return |
| } |
| //transform basic elements |
| it.min = createTimeTicks( amltDistribution.lowerBound) |
| it.mean = createTimeTicks(amltDistribution.average) |
| it.max = createTimeTicks(amltDistribution.upperBound) |
| it.sigma = createTimeTicks(0) |
| it.type = TimeDistributionType.MAX |
| it.alpha = 0 |
| it.beta = 0 |
| |
| // more sophisticated distributions |
| if (amltDistribution instanceof DiscreteValueGaussDistribution) { |
| it.type = TimeDistributionType.NORMAL |
| it.sigma = createTimeTicks(amltDistribution.sd) |
| } else if (amltDistribution instanceof DiscreteValueUniformDistribution) { |
| it.type = TimeDistributionType.UNIFORM |
| } else if (amltDistribution instanceof DiscreteValueBetaDistribution) { |
| //TODO: implement beta distribution transformer |
| } else if (amltDistribution instanceof DiscreteValueHistogram) { |
| it.type = TimeDistributionType.DISCRETE |
| amltDistribution.entries.forEach [ amltEntry | { |
| val amltAvg = (amltEntry.upperBound + amltEntry.lowerBound) / 2; |
| val amltOccurrences = amltEntry.occurrences |
| var inchronDiscreteDistributionEntry = inchronModelFactory.createDiscreteDistributionEntry |
| inchronDiscreteDistributionEntry.count = amltOccurrences |
| inchronDiscreteDistributionEntry.execTime = createTimeTicks(amltAvg) |
| it.discreteDistribution.add(inchronDiscreteDistributionEntry) |
| }] |
| } |
| } |
| |
| |
| def Time createTimeTicks(Double value) { |
| var Time time = inchronModelFactory.createTime |
| time.value = Math.round(value) |
| time.unit = TimeUnit.T |
| return time |
| } |
| |
| def Time createTimeTicks(Long value) { |
| var Time time = inchronModelFactory.createTime |
| time.value = value |
| time.unit = TimeUnit.T |
| return time |
| } |
| |
| |
| def Time createTimeTicks(Integer value) { |
| var Time time = inchronModelFactory.createTime |
| time.value = value |
| time.unit = TimeUnit.T |
| return time |
| } |
| |
| } |