Initial GSoC Response Time Analysis Code
Signed-off-by: Junhyung Ki <kijoonh91@gmail.com>
diff --git a/eclipse-tools/responseTime-analyzer/README.md b/eclipse-tools/responseTime-analyzer/README.md
new file mode 100644
index 0000000..acbf2f7
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/README.md
@@ -0,0 +1,73 @@
+# GSOC_RTA
+
+2019 Google Summer of Code (CPU-GPU Response Time and Mapping Analysis)
+
+## [Table of Contents]
+### 1. Milestone with the goal of each phase
+### 2. Intention
+### 3. Contribution & benefits for the community
+### 4. Contents
+### 5. Diagram Example
+### 6. Validation
+
+# 1. Milestone with the goal of each phase
+- **Response Time Analysis_CPU Part (Part 1)**
+- E2E Latency (Part 2)
+- LET, EC, IC Communication Paradigms to the model (Part 3)
+
+# 2. Intention
+The current APP4MC library does provide several methods which are useful for deriving execution time for a task, a runnable or ticks (pure computation) through the Util package. But methods for response time are still not available. The reason is that response time analysis can be varied depending on the analyzed model so it is hard to be generalized. But since the trends are evolving from homogeneous to heterogeneous platform, the analysis methodology have become much more sophisticated so it is necessary to have CPU response time analysis which can be used for different mapping analysis with a different processing unit type (e.g., GPU).
+
+# 3. Contribution & benefits for the community
+In this project, [a standardized response time analysis methodology](https://www.semanticscholar.org/paper/Finding-Response-Times-in-a-Real-Time-System-Joseph-Pandya/574517d6e47cf9b368003a56088651a1941dcda1)(Mathai Joseph and Paritosh Pandya, 1986) which involves a complex algorithm is used. Not only this, but also a class, `CpuRTA` which is designed for Generic Algorithm Mapping is provided. Since a heterogeneous platfrom usually requires a different analysis methodology for a processing unit according to its type(e.g., CPU & GPU), a class that can be used with GA Mapping and has a built-in general analysis methodology would be very helpful and save a lot of time which otherwise would be spent for implementing the same algorithm for those tasks that are mapped to a particular type of processing units (e.g., CPU). Along with these, another class, `RuntimeUtilRTA` which supports `CpuRTA` class provides several ways to calculate execution time of a task is also provided. The execution time calculation methodology can be different depending on an execution case (e.g., Worst Case, Best Case, Average Case), a transmission type (e.g., Synchronous, Asynchronous) or a different mapping model. This class can be modified and reused for other analysis models if only a method which takes care of a Runnable execution time is adjusted.
+
+# 4. Contents
+Since the target of implementing heterogeneous platform is to achieve better performance and efficiency, just simply calculating response time is not enough. To realize the optimized response time analysis, different mapping analysis for the same given model according to Generic Algorithm should be taken into account. Generic Algorithm would map tasks to different processing units in the form of integer array so that the total sum of each task’s response time according to the each GA generation can be delivered and compared each other to come up with a better solution. For this reason, a public method which returns the total sum of each task’s response time and the relevant private methods that are used to support this method are needed. The corresponding methods are followed below.
+**Refer to javadoc below for more details.**
+* [CpuRTA](Add Ref here)
+* [TimeCompIA](Add Ref here)
+* [RuntimeUtilRTA](Add Ref here)
+* [RTApp](Add Ref here)
+
+<`CpuRTA.java`>
+**getCPUResponseTimeSum**
+Calculate the total sum of response times of the tasks of the given Amalthea model with a GA mapping model
+**getTaskCPURT**
+Calculate response time of the given task of the given Amalthea model with a GA mapping model
+**taskSorting**
+Sort out the given list of tasks (in order of shorter period first - Rate Monotonic Scheduling)
+**preciseTestCPURT** (Response Time analysis Equation Explanation)
+Calculate response time of the observed task according to the periodic tasks response time analysis algorithm.
+> Ri = Ci + Σj ∈ HP(i) [Ri/Tj]*Cj ([a standardized response time analysis methodology](https://www.semanticscholar.org/paper/Finding-Response-Times-in-a-Real-Time-System-Joseph-Pandya/574517d6e47cf9b368003a56088651a1941dcda1)(Mathai Joseph and Paritosh Pandya, 1986))
+
+<`RuntimeUtilRTA.java`>
+**getExecutionTimeforCPUTask**
+Calculate execution time of the given task under one of the several configurations.
+**doesThisTaskTriggerCPUTask**
+Find out whether the given triggering task(that has an InterProcessTrigger) triggers a GPU task which is newly mapped to CPU.
+**syncTypeOperation**
+Calculate execution time of the given runnableList in a synchronous manner.
+**asyncTypeOperation**
+Calculate execution time of the given runnableList in an asynchronous manner.
+**getExecutionTimeForRTARunnable**
+Calculate execution time of the given runnable.
+**getRunnableMemoryAccessTime**
+Calculate memory access time of the observed runnable.
+> (Explanation)
+> Read(Write)_Access_Time = Round_UP(Size_of_Read_Labels / 64.0 Bytes) * (Read_Latency / Frequency)
+
+**isTriggeringTask**
+Identify whether the given task has an InterProcessTrigger or not.
+
+<`RTApp.java`>
+User Interface Window
+[APP4RTA_1.0_Description](Add Ref here)
+
+# 5. Diagram Example
+
+
+* Sequence Diagram
+
+
+
+# 6. Validation
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.classpath b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.classpath
new file mode 100644
index 0000000..eca7bdb
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.project b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.project
new file mode 100644
index 0000000..dd2a679
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>gsoc_rta</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.settings/org.eclipse.jdt.core.prefs b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..3a21537
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/META-INF/MANIFEST.MF b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..26bdfad
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/META-INF/MANIFEST.MF
@@ -0,0 +1,11 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: APP4MC Amalthea Java Example
+Bundle-SymbolicName: gsoc_rta
+Bundle-Version: 0.9.3.qualifier
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-Vendor: Eclipse APP4MC
+Require-Bundle: org.eclipse.ui,
+ org.eclipse.core.runtime,
+ org.eclipse.app4mc.amalthea.model
+Automatic-Module-Name: app4mc.example.tool.java
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/build.properties b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/build.properties
new file mode 100644
index 0000000..abb7da6
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/build.properties
@@ -0,0 +1,4 @@
+source.. = src/
+bin.includes = META-INF/,\
+ .,\
+ model-input/
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/doc/APP4RTA_1.0_Description.pdf b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/doc/APP4RTA_1.0_Description.pdf
new file mode 100644
index 0000000..ad1c41c
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/doc/APP4RTA_1.0_Description.pdf
Binary files differ
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/doc/Class_Diagram.png b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/doc/Class_Diagram.png
new file mode 100644
index 0000000..96608a1
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/doc/Class_Diagram.png
Binary files differ
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/CpuRTA.java b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/CpuRTA.java
new file mode 100644
index 0000000..93b3745
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/CpuRTA.java
@@ -0,0 +1,489 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Dortmund University of Applied Sciences and Arts.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors: FH Dortmund - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.app4mc.gsoc_rta;
+
+import java.io.File;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+
+import org.eclipse.app4mc.amalthea.model.Amalthea;
+import org.eclipse.app4mc.amalthea.model.Preemption;
+import org.eclipse.app4mc.amalthea.model.ProcessingUnit;
+import org.eclipse.app4mc.amalthea.model.PuType;
+import org.eclipse.app4mc.amalthea.model.Task;
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TimeUnit;
+import org.eclipse.app4mc.amalthea.model.io.AmaltheaLoader;
+import org.eclipse.app4mc.amalthea.model.util.FactoryUtil;
+import org.eclipse.app4mc.amalthea.model.util.RuntimeUtil.TimeType;
+import org.eclipse.emf.common.util.EList;
+import imported.CommonUtils;
+
+/**
+ * Date: June 21-2019
+ * @author Junhyung Ki
+ * @version 1.0
+ * This class is to analyze Response Times of CPU(e.g., ARM, Denver cores) Tasks in a CPU-GPU Heterogeneous System
+ * The entire class is designed for Generic Algorithm Mapping to find the most optimized task mapping solution.
+ * Therefore, setting the integer array variable, 'tpuMapping' (which is considered as a mapping solution) along with
+ * others ( Amalthea Model, 'model' setting, Task Response Time HashMap, 'trt' setting (for GPU Tasks), Processing Unit List, 'pul' setting
+ * should be the first step before executing any response time method.
+ */
+public class CpuRTA {
+ public final File inputFile = new File("model-input/ChallengeModel_release.amxmi");
+
+ /* synchronous or asynchronous offloading */
+ public boolean synchronousOffloading = false;
+
+ /* feasibility boolean */
+ public boolean ignoreInfeasibility = false;
+
+ /* Arbitrary Integer Array (GA scenario) */
+ private final int[] defaultIAMapping = new int[] { 4, 1, 1, 3, 4, 0, 1, 3, 3, 0, 6, 2, 5, 6 };
+
+ /**
+ * Get Default IA Map
+ * @return
+ * this.defaultIAMapping
+ */
+ public int[] getDefaultIAMapping() {
+ return this.defaultIAMapping;
+ }
+
+ private Amalthea model;
+
+ /**
+ * Since this method is used by RTARuntimeUtil, the visibility should be 'protected'
+ *
+ * @return
+ * The Amalthea model object of the current CPURtaIA class
+ */
+ public Amalthea getModel() {
+ return this.model;
+ }
+
+ /**
+ * Set the Amalthea model object of the current CPURtaIA class as the given Amalthea model parameter.
+ *
+ * @param pAmalthea the parameter Amalthea model which would reinitialize the Amalthea model
+ */
+ public void setModel(final Amalthea pAmalthea) {
+ this.model = pAmalthea;
+
+ // TODO: gpuToCpuLabels, getGTCL, setGTCL, Cumulative Latency Time
+ //setGTCL(this.model);
+ }
+
+ private HashMap<Task, Time> trt = null;
+
+ /**
+ * Since this method is used by GAMapping, the visibility should be 'public'
+ *
+ * @return
+ * trt(task with response time) HashMap variable
+ */
+ public HashMap<Task, Time> getTRT() {
+ return this.trt;
+ }
+
+ /**
+ * Set the trt(task with response time) HashMap variable as the given trtp parameter variable.
+ * Which would contains GPU tasks' response times from the beginning
+ *
+ * @param trtp the HashMap variable parameter which would reinitialize the trt variable of the current CPURtaIA class.
+ */
+ public void setTRT(final HashMap<Task, Time> trtp) {
+ this.trt = trtp;
+ }
+
+ /**
+ * Get the default trt(task with response time) value in case of running CPURtaIA class itself.
+ *
+ * @param model the current class's Amalthea model which is used to get the trt value out of it
+ * @return
+ * the trt value which is derived out of the given parameter Amalthea model
+ */
+ public HashMap<Task, Time> getDefaultTRT(final Amalthea model) {
+ final HashMap<Task, Time> trt = new HashMap<Task, Time>();
+ final EList<Task> allTaskList = model.getSwModel().getTasks();
+ final long val = 2000000000;
+ for (final Task t : allTaskList) {
+ if (this.gpuTaskList.contains(t)) {
+ trt.put(t, FactoryUtil.createTime(BigInteger.valueOf(val), TimeUnit.PS));
+ }
+ else {
+ trt.put(t, FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS));
+ }
+ }
+ return trt;
+ }
+
+ private int[] tpuMapping = null;
+
+ /**
+ * Since this method is used by RTARuntimeUtil, the visibility should be 'protected'
+ *
+ * @return
+ * The tpuMapping integer array
+ */
+ public int[] getIA() {
+ return this.tpuMapping;
+ }
+
+ /**
+ * Set the tpuMapping integer array (which would be used to modify the current task mapping to different Processing Units)
+ * as the given tpumap parameter variable.
+ * (The integer array would be used to modify the current task mapping to different Processing Units)
+ *
+ * @param tpumap the parameter integer array which would reinitialize the tpuMapping array of the current CPURtaIA class.
+ */
+ public void setIA(final int[] tpumap) {
+ if (tpumap == null) {
+ this.tpuMapping = null;
+ }
+ else if (tpumap.length == this.model.getSwModel().getTasks().size()) {
+ this.tpuMapping = tpumap;
+ }
+ else {
+ System.out.println("integer array size MUST match the number of tasks");
+ }
+ }
+
+ private List<ProcessingUnit> pul = new ArrayList<>();
+
+ /**
+ * Get a list of ProcessingUnits
+ *
+ * @return
+ * this.pul
+ */
+ public List<ProcessingUnit> getPUl() {
+ return this.pul;
+ }
+
+ /**
+ * Set the pul, the list of Processing Units variable (which would be used to map tasks along with tpuMapping array)
+ * as the given pul parameter variable.
+ *
+ * @param pul the parameter pul list which would reinitialize the pul list variable of the current CPURtaIA class
+ */
+ public void setPUl(final List<ProcessingUnit> pul) {
+ this.pul = pul;
+ }
+
+ //TODO: Contention not considered
+ private List<Task> gpuTaskList = new ArrayList<Task>();
+
+ /**
+ * Since this method is used by RTARuntimeUtil, the visibility should be 'protected'
+ *
+ * @return
+ * gpuTaskList which contains tasks (which are originally designed for GPU) of the Amalthea model
+ */
+ protected List<Task> getGpuTaskList() {
+ return this.gpuTaskList;
+ }
+
+ private final List<Task> triggeringTaskList = new ArrayList<Task>();
+
+ /**
+ * Since this method is used by RTARuntimeUtil, the visibility should be 'protected'
+ *
+ * @return
+ * triggeringTaskList which contains tasks (which contain InterProcessTrigger) of the Amalthea model
+ */
+ protected List<Task> getTriggeringTaskList() {
+ return this.triggeringTaskList;
+ }
+
+ // TODO: Consider Offloading Runnable
+
+ // TODO: Cumulative Latency Time
+ public static void main(String[] args) {
+ final CpuRTA cpurta = new CpuRTA();
+ cpurta.setModel(AmaltheaLoader.loadFromFile(cpurta.inputFile));
+ cpurta.setTRT(cpurta.getDefaultTRT(cpurta.getModel()));
+ cpurta.setIA(cpurta.defaultIAMapping);
+ cpurta.setPUl(CommonUtils.getPUs(cpurta.getModel()));
+ cpurta.run();
+ }
+
+ /**
+ * Executable method
+ */
+ public void run() {
+ if (this.model == null) {
+ System.out.println("Error: No model loaded!");
+ return;
+ }
+ System.out.println("\n####################### The Test ########################\n");
+ System.out.println("RT Time Sum: " + getCPUResponseTimeSum(TimeType.WCET));
+ }
+
+ /**
+ * Calculate the total sum of response times of the tasks of the given Amalthea model with the mapping model (tpuMapping)
+ *
+ * @param executionCase BCET, ACET, WCET
+ * @return
+ * total sum of all tasks' response times of the given mapped model (tpuMapping)
+ */
+ public Time getCPUResponseTimeSum(final TimeType executionCase) {
+ if (this.model == null) {
+ System.out.println("Error: No Model Loaded!");
+ return null;
+ }
+ else if (this.trt == null) {
+ System.out.println("Error: No HashMap Loaded!");
+ return null;
+ }
+ else if (this.tpuMapping == null) {
+ System.out.println("Error: No IntegerArray Loaded!");
+ return null;
+ }
+ else if (this.pul == null) {
+ System.out.println("Error: No PUList Loaded!");
+ return null;
+ }
+
+ // TODO: Contention
+ Time time = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ for (int i = 0; i < this.tpuMapping.length; i++) {
+ final Time rt = getTaskCPURT(this.model.getSwModel().getTasks().get(i), executionCase);
+ if (rt.getValue().equals(BigInteger.valueOf(Long.MAX_VALUE))) {
+ // TODO: rt.getValue().equals(BigInteger.valueOf(Long.MAX_VALUE)) && !SharedConsts.ignoreInfeasibility
+ return rt;
+ }
+ time = time.add(rt);
+ if (!rt.getValue().equals(BigInteger.ZERO)) {
+ /* only put CPU tasks */
+ this.trt.put(this.model.getSwModel().getTasks().get(i), rt);
+ }
+ }
+ return time;
+ }
+
+ /**
+ * Calculate response time of the given task of the given Amalthea model with the mapping model (tpuMapping)
+ *
+ * @param task the observed task
+ * @param executionCase BCET, ACET, WCET
+ * @return
+ * response time of the observed task
+ */
+ private Time getTaskCPURT(final Task task, final TimeType executionCase) {
+ /* 1. validate thisTask is mapped to CPU */
+ final int tindex = this.model.getSwModel().getTasks().indexOf(task);
+ final int puindex = this.tpuMapping[tindex];
+ final ProcessingUnit pu = this.pul.get(puindex);
+ if (!pu.getDefinition().getPuType().equals(PuType.CPU)) {
+ System.out.println(task.getName() + " is not mapped to a CPU");
+ return FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ }
+ /* 2. get all tasks mapped to this CPU */
+ final List<Task> puTaskList = new ArrayList<Task>();
+ for (int i = 0; i < this.tpuMapping.length; i++) {
+ if (this.tpuMapping[i] == puindex) {
+ puTaskList.add(this.model.getSwModel().getTasks().get(i));
+ }
+ }
+ final List<Task> sortedTaskList = taskSorting(puTaskList);
+ return preciseTestCPURT(task, sortedTaskList, executionCase, pu);
+ }
+
+ /**
+ * Sort out the given list of tasks (in order of shorter period first - Rate Monotonic Scheduling)
+ *
+ * @param taskList list of tasks that is mapped to the same core
+ * @return
+ * the sorted list of tasks
+ */
+ private List<Task> taskSorting(final List<Task> taskList) {
+ /* Getting stimuliList out of the given taskList (because it is RMS) */
+ final List<Time> stimuliList = new ArrayList<>();
+ for (final Task t : taskList) {
+ stimuliList.add(CommonUtils.getStimInTime(t));
+ }
+
+ /* Sorting (Shortest Period(Time) first) */
+ Collections.sort(stimuliList, new TimeCompIA());
+ /*
+ * Sort tasks to the newTaskList in order of Period length (shortest first
+ * longest last)-(according to the stimuliList)
+ */
+ final List<Task> newTaskList = new ArrayList<>();
+ for (int i = 0; i < stimuliList.size(); i++) {
+ for (final Task t : taskList) {
+ if ((!newTaskList.contains(t)) && (stimuliList.get(i).compareTo(CommonUtils.getStimInTime(t)) == 0)) {
+ newTaskList.add(t);
+ }
+ }
+ }
+ return newTaskList;
+ }
+
+ /**
+ * Visibility - public (This method is for the UI version code (ui package > RTApp.java))
+ * Calculate response time of the observed task according to the periodic tasks response time analysis algorithm.
+ *
+ * @param task the observed task
+ * @param taskList list of tasks that is mapped to the same core
+ * @param executionCase BCET, ACET, WCET
+ * @param pu ProcessingUnit that would compute the given runnable (A57 or Denver)
+ * @return
+ * response time of the observed task
+ */
+ public Time preciseTestCPURT(final Task task, final List<Task> taskList, final TimeType executionCase, final ProcessingUnit pu) {
+ Time thisRT = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ Time period = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ if (taskList.size() == 0) {
+ System.out.println("!!! This taskList is empty so I am returning MAX !!!");
+ return FactoryUtil.createTime(BigInteger.valueOf(Long.MAX_VALUE), TimeUnit.PS);
+ }
+
+ /* to check if the given task is in the taskList */
+ int flag = 0;
+ int index = 0;
+ for (int i = 0; i < taskList.size(); i++) {
+ if (task.equals(taskList.get(i))) {
+ flag = 1;
+ index = i;
+ break;
+ }
+ }
+ if (flag == 0) {
+ System.out.println("!!! Nothing in the taskList matches the given Task !!! So I am returning 0s" + " --- thisTask: " + task.getName());
+ return FactoryUtil.createTime(BigInteger.valueOf(Long.MAX_VALUE), TimeUnit.PS);
+ }
+ final RuntimeUtilRTA rtaut = new RuntimeUtilRTA();
+ for (int i = 0; i < index + 1; i++) {
+ period = CommonUtils.getStimInTime(taskList.get(i));
+ if (index == 0) {
+ thisRT = rtaut.getExecutionTimeforCPUTask(taskList.get(i), pu, executionCase, this.trt, this);
+ if (thisRT.compareTo(period) <= 0) {
+ // TODO: cumulative if (thisRT.compareTo(FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS)) > 0)
+ return thisRT;
+ }
+ System.out.println("!!! This is non schedulable...!!! Because of the period " + period + " being less than the execution time of "
+ + thisRT + " for task " + task.getName());
+ return FactoryUtil.createTime(BigInteger.valueOf(Long.MAX_VALUE), TimeUnit.PS);
+ }
+ else if (i == index) {
+ /* In the case of a COOPERATIVE Preemption typed Task */
+ if (taskList.get(i).getPreemption().equals(Preemption.COOPERATIVE)) {
+ // TODO: Blocking
+ }
+ final Time thisExeTime = rtaut.getExecutionTimeforCPUTask(taskList.get(i), pu, executionCase, this.trt, this);
+ if (thisExeTime.compareTo(FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS)) == 0) {
+ return thisExeTime;
+ }
+ else if (thisExeTime.compareTo(period) > 0) {
+ System.out.println("!!! This is non schedulable...!!! Because of the period " + period + " being less than the execution time of "
+ + thisRT + " for task " + task.getName());
+ return FactoryUtil.createTime(BigInteger.valueOf(Long.MAX_VALUE), TimeUnit.PS);
+ }
+
+ Time culmulativeRT = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ /* 1. add all the execution time till the index */
+ for (int j = 0; j < i + 1; j++) {
+ final Time thisTime = rtaut.getExecutionTimeforCPUTask(taskList.get(j), pu, executionCase, this.trt, this);
+ culmulativeRT = culmulativeRT.add(thisTime);
+ }
+ if (culmulativeRT.compareTo(period) <= 0) {
+ while (true) {
+ Time excepThisExeTime = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ for (int k = 0; k < i; k++) {
+ Time localPeriod = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ localPeriod = CommonUtils.getStimInTime(taskList.get(k));
+ final Time preExeTime = rtaut.getExecutionTimeforCPUTask(taskList.get(k), pu, executionCase, this.trt, this);
+ final double ri_period = Math.ceil(culmulativeRT.divide(localPeriod));
+ excepThisExeTime = excepThisExeTime.add(preExeTime.multiply(ri_period));
+ }
+ Time culmulativeRT_x = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ culmulativeRT_x = thisExeTime.add(excepThisExeTime);
+ if (culmulativeRT_x.compareTo(period) <= 0) {
+ if (culmulativeRT_x.compareTo(culmulativeRT) == 0) {
+ thisRT = culmulativeRT_x;
+ // TODO: cumulative if (thisRT.compareTo(FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS)) > 0)
+ return thisRT;
+ }
+ culmulativeRT = culmulativeRT_x;
+ }
+ else {
+ System.out.println("!!! This is non schedulable...!!! Because of the period " + period
+ + " being less than the response time (culmulativeRT_x) of " + culmulativeRT_x + " for task " + task.getName());
+ if (this.ignoreInfeasibility) {
+ return culmulativeRT_x;
+ }
+ return FactoryUtil.createTime(BigInteger.valueOf(Long.MAX_VALUE), TimeUnit.PS);
+ }
+ }
+ }
+ System.out.println("!!! This is non schedulable...!!! Because of the period " + period + " being less than the response time of "
+ + culmulativeRT + " for task " + task.getName());
+ if (this.ignoreInfeasibility) {
+ return culmulativeRT;
+ }
+ return FactoryUtil.createTime(BigInteger.valueOf(Long.MAX_VALUE), TimeUnit.PS);
+ }
+ }
+ // TODO: cumulative if (thisRT.compareTo(FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS)) > 0)
+ return thisRT;
+ }
+
+ /**
+ * Visibility - public (This method is for the UI version code (ui package > RTApp.java))
+ * It returns HashMap<Integer, List<Task>> Type reference that contains an Integer(number of Processing Unit index) and the corresponding List of Tasks
+ * This is to visualize which task is mapped to which processing unit.
+ *
+ * @return
+ * HashMap<Integer, List<Task>> puListHashMap
+ */
+ public HashMap<Integer, List<Task>> be_getPUTaskListHashMap() {
+ HashMap<Integer, List<Task>> puListHashMap = new HashMap<>();
+ final EList<Task> allTaskList = this.model.getSwModel().getTasks();
+ for(int i = 0; i < this.pul.size(); i++) {
+ final List<Task> puTaskList = new ArrayList<Task>();
+ for(int j = 0; j < this.tpuMapping.length; j++) {
+ final int puIndex = this.tpuMapping[j];
+ if (i == puIndex) {
+ puTaskList.add(allTaskList.get(j));
+ }
+ }
+ puListHashMap.put(i, taskSorting(puTaskList));
+ }
+ return puListHashMap;
+ }
+}
+
+/**
+ * @Date: June 21-2019
+ * @author Junhyung Ki
+ * @version 1.0
+ * This inner class is used for the method "taskSorting" to help compare between two tasks' periods (which is longer)
+ * If the time of arg0 is shorter than that of arg1, it returns -1.
+ * If the time of arg0 is longer than that of arg1, it returns 1.
+ */
+class TimeCompIA implements Comparator<Time> {
+ @Override
+ public int compare(final Time arg0, final Time arg1) {
+ if (arg0.compareTo(arg1) < 0) {
+ return -1;
+ }
+ return 1;
+ }
+}
\ No newline at end of file
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/RuntimeUtilRTA.java b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/RuntimeUtilRTA.java
new file mode 100644
index 0000000..10cd251
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/RuntimeUtilRTA.java
@@ -0,0 +1,320 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Dortmund University of Applied Sciences and Arts.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors: FH Dortmund - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.app4mc.gsoc_rta;
+
+import java.math.BigInteger;
+import java.util.HashMap;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaServices;
+import org.eclipse.app4mc.amalthea.model.CallSequenceItem;
+import org.eclipse.app4mc.amalthea.model.InterProcessStimulus;
+import org.eclipse.app4mc.amalthea.model.InterProcessTrigger;
+import org.eclipse.app4mc.amalthea.model.LabelAccess;
+import org.eclipse.app4mc.amalthea.model.LabelAccessEnum;
+import org.eclipse.app4mc.amalthea.model.ProcessingUnit;
+import org.eclipse.app4mc.amalthea.model.Runnable;
+import org.eclipse.app4mc.amalthea.model.Task;
+import org.eclipse.app4mc.amalthea.model.Ticks;
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TimeUnit;
+import org.eclipse.app4mc.amalthea.model.util.FactoryUtil;
+import org.eclipse.app4mc.amalthea.model.util.RuntimeUtil;
+import org.eclipse.app4mc.amalthea.model.util.RuntimeUtil.TimeType;
+import org.eclipse.app4mc.amalthea.model.util.SoftwareUtil;
+import org.eclipse.emf.common.util.EList;
+
+import imported.CommonUtils;
+
+/**
+ * Date: June 21-2019
+ * @author Junhyung Ki
+ * @version 1.0
+ * This class is to support CpuRTA class. Response Time Analysis contains low level calculation
+ * such as deriving execution time of a Task or Runnable. Execution time calculation varies depending on the analyzed model.
+ * Therefore, it is necessary to separate from Response Time calculation to increase adaptability.
+ * Only 'getExecutionTimeforCPUTask' method is accessible for CpuRTA and the rest are sub-methods of it.
+ */
+public class RuntimeUtilRTA {
+ /**
+ * Calculate execution time of the given task under one of the several configurations.
+ * Since this method is used by CPURtaIA, the visibility should be 'protected'
+ * 1. triggering task in the synchronous mode
+ * 2. triggering task in the asynchronous mode
+ * 3. GPU task on CPU
+ * 4. task with only Ticks
+ *
+ * @param task the observed task
+ * @param pu ProcessingUnit that would compute the given runnable (A57 or Denver)
+ * @param executionCase BCET, ACET, WCET
+ * @param trt HashMap that would contain the corresponding GPU task's response time
+ * @param cpurta the instance of CPURtaIA class that calls this method
+ * (to access to the cumuAcTime Time variable that accumulate access latency)
+ * @return
+ * execution time of the observed task
+ */
+ protected Time getExecutionTimeforCPUTask(final Task task, final ProcessingUnit pu, final TimeType executionCase, final HashMap<Task, Time> trt, final CpuRTA cpurta) {
+ // TODO: Contention Parameter
+ /* set the default result time variable as 0s */
+ Time result = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ /* check if the current task is a triggering task.
+ * If so, check whether or not it triggers the target task which is newly mapped to CPU.
+ * In that case, returns 0 ps */
+ if (doesThisTaskTriggerCPUTask(task, cpurta)) {
+ return result;
+ }
+ // TODO: Contention
+ /* The list of runnables of the given task */
+ final List<Runnable> runnableList = SoftwareUtil.getRunnableList(task, null);
+ /* To identify the index of the triggerEvent */
+ final List<CallSequenceItem> callSequenceList = SoftwareUtil.collectEventsOfProcess(task, null);
+ int indexforTrigger = 0;
+ for (int i = 0; i < callSequenceList.size(); i++) {
+ if (callSequenceList.get(i) instanceof InterProcessTrigger) {
+ indexforTrigger = i;
+ }
+ }
+ /* To distinguish CPU Tasks between Sync & Async */
+ if (isTriggeringTask(task)) {
+ /* all should be synchronous (wait should not be ignored) - active wait */
+ if (cpurta.synchronousOffloading == true) {
+ result = syncTypeOperation(indexforTrigger, callSequenceList, runnableList, trt, pu, executionCase, cpurta);
+ /* if this task has the OffloadingAsync runnable, subtract the runnable part from the result */
+ // TODO: if (doesTaskHaveAsyncRunnable(task, cpurta))
+ }
+ /* all should be asynchronous (wait should be ignored) - passive wait */
+ else {
+ result = asyncTypeOperation(runnableList, pu, executionCase);
+ /* if this task is missing the OffloadingAsync runnable, add the runnable part to the result */
+ // TODO: if (!doesTaskHaveAsyncRunnable(task, cpurta))
+ }
+ }
+ else {
+ /* GPU Origin Task on CPU & No Triggering Behavior (No InterProcessTrigger) */
+ if (!(callSequenceList.get(indexforTrigger) instanceof InterProcessTrigger)) {
+ // TODO: GPU Origin task that is newly mapped to CPU
+ /* No Triggering Behavior (No InterProcessTrigger) */
+ for (final Runnable r : runnableList) {
+ result = result.add(getExecutionTimeForRTARunnable(r, pu, executionCase));
+ }
+ // TODO: result = result.add(contention);
+ return result;
+ }
+ }
+ // TODO: result = result.add(contention);
+ return result;
+ }
+
+ /**
+ * Find out whether the given triggering task(that has an InterProcessTrigger) triggers a GPU task which is newly mapped to CPU.
+ * If the ProcessingUnit index of the triggered task is bigger than the biggest CPU index, that means the triggered task is mapped to GPU
+ * which would return false.
+ *
+ * @param task the observed task
+ * @param cpurta the instance of CPURtaIA class that calls this method
+ * (to get the task List & the integer array to identify the ProcessingUnit index of the triggered task)
+ * @return
+ * boolean value (true: the observed task triggers a task that is mapped to CPU /
+ * false: the observed task triggers a task that is mapped to GPU)
+ */
+ private boolean doesThisTaskTriggerCPUTask(final Task task, final CpuRTA cpurta) {
+ if (cpurta.getTriggeringTaskList().contains(task)) {
+ final List<CallSequenceItem> callList = SoftwareUtil.collectEventsOfProcess(task, null);
+ final InterProcessStimulus ips = ((InterProcessTrigger) callList.stream().filter(s -> s instanceof InterProcessTrigger).iterator().next())
+ .getStimulus();
+ final EList<Task> allTaskList = cpurta.getModel().getSwModel().getTasks();
+ final int[] ia = cpurta.getIA();
+ final int cpuThreshold = CommonUtils.getNumberofCPUs(cpurta.getModel()) - 1;
+ for (int i = 0; i < ia.length; i++) {
+ if (ia[i] > cpuThreshold) {
+ final Task theTask = allTaskList.get(i);
+ if (theTask.getStimuli().get(0) instanceof InterProcessStimulus) {
+ final InterProcessStimulus thisIPS = (InterProcessStimulus) theTask.getStimuli().get(0);
+ if (ips.equals(thisIPS)) {
+ System.out.println("Confirmation: The triggered task mapped to (GPU)");
+ return false;
+ }
+ }
+ }
+ }
+ System.out.println("Confirmation: The triggered task mapped to (CPU)");
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Calculate execution time of the given runnableList in a synchronous manner.
+ * (execution time of pre-processing) + GPU task response time + (execution time of post-processing)
+ *
+ * @param indexforTrigger Integer variable that is used to get InterProcessTrigger to identify the triggered GPU task
+ * @param callSequenceList callSequenceList List variable that is used to get InterProcessTrigger to identify the triggered GPU task
+ * @param runnableList the observed runnable List to calculate execution time in the synchronous mode
+ * @param trt HashMap that would contain the corresponding GPU task's response time
+ * @param pu ProcessingUnit that would compute the given runnable (A57 or Denver)
+ * @param executionCase BCET, ACET, WCET
+ * @param cpurta the instance of CPURtaIA class that calls this method
+ * (to get the identified triggered GPU task in the model)
+ * (to access to the cumuAcTime Time variable that accumulate access latency)
+ * @return
+ * synchronous execution time of the observed set
+ */
+ private Time syncTypeOperation(final int indexforTrigger, final List<CallSequenceItem> callSequenceList, final List<Runnable> runnableList,
+ final HashMap<Task, Time> trt, final ProcessingUnit pu, final TimeType executionCase, final CpuRTA cpurta) {
+ System.out.println("TYPE: SYNC");
+ /* set the default result time variable as 0s */
+ Time result = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ /* Sum all the runnable ExecutionTime of the CPU Task */
+ for (final Runnable r : runnableList) {
+ result = result.add(getExecutionTimeForRTARunnable(r, pu, executionCase));
+ }
+ final InterProcessTrigger ipt = (InterProcessTrigger) callSequenceList.get(indexforTrigger);
+ final Task triggeredGPUTask = cpurta.getModel().getSwModel().getTasks().stream().filter(t -> t.getStimuli().get(0).equals(ipt.getStimulus())).iterator()
+ .next();
+ result = result.add(trt.get(triggeredGPUTask));
+ return result;
+ }
+
+ /**
+ * Calculate execution time of the given runnableList in an asynchronous manner.
+ * (execution time of pre-processing) + (execution time of post-processing)
+ *
+ * @param runnableList the observed runnable List to calculate execution time in the asynchronous mode
+ * @param pu ProcessingUnit that would compute the given runnable (A57 or Denver)
+ * @param executionCase BCET, ACET, WCET
+ * @return
+ * asynchronous execution time of the observed runnable List
+ */
+ private Time asyncTypeOperation(final List<Runnable> runnableList, final ProcessingUnit pu, final TimeType executionCase) {
+ System.out.println("TYPE: ASYNC");
+ /**
+ * <Asynchronous Task> et_t=sum_{runnable calls before GPU trigger
+ * event}et_r + et_{runnable calls after GPU trigger event};
+ */
+ /* set the default result time variable as 0s */
+ Time result = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ /* Sum all the runnable ExecutionTime */
+ for (final Runnable r : runnableList) {
+ /* In case of Pre_Detection_Post task, the AsyncOffloading runnable is already taken into account here. */
+ result = result.add(getExecutionTimeForRTARunnable(r, pu, executionCase));
+ }
+ return result;
+ }
+
+ // TODO: getExecutionTimeForGPUTaskOnCPU
+
+ // TODO: doesTaskHaveAsyncRunnable
+
+ /**
+ * Calculate execution time of the given runnable.
+ * The method consider Read / Compute(Ticks) / Write semantic.
+ *
+ * @param runnable the observed runnable
+ * @param pu ProcessingUnit that would compute the given runnable (A57 or Denver)
+ * @param executionCase BCET, ACET, WCET
+ * @return
+ * execution time of the observed runnable
+ */
+ private Time getExecutionTimeForRTARunnable(final Runnable runnable, final ProcessingUnit pu, final TimeType executionCase) {
+ Time result = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ final double freq = AmaltheaServices.convertToHertz(pu.getFrequencyDomain().getDefaultValue()).longValue();
+ double readLatency = 0;
+ double writeLatency = 0;
+ if (executionCase.equals(TimeType.WCET)) {
+ readLatency = pu.getAccessElements().get(0).getReadLatency().getUpperBound();
+ writeLatency = pu.getAccessElements().get(0).getWriteLatency().getUpperBound();
+ }
+ else if (executionCase.equals(TimeType.BCET)) {
+ readLatency = pu.getAccessElements().get(0).getReadLatency().getLowerBound();
+ writeLatency = pu.getAccessElements().get(0).getWriteLatency().getLowerBound();
+ }
+ else {
+ readLatency = pu.getAccessElements().get(0).getReadLatency().getAverage();
+ writeLatency = pu.getAccessElements().get(0).getWriteLatency().getAverage();
+ }
+ /* Read & Write Memory Access Time */
+ result = result.add(getRunnableMemoryAccessTime(runnable, freq, readLatency, writeLatency, executionCase));
+
+ /* Execution (Ticks): */
+ final List<Ticks> ticksList = SoftwareUtil.getTicks(runnable, null);
+ for (final Ticks t : ticksList) {
+ final Time tickExecution = RuntimeUtil.getExecutionTimeForTicks(t, pu, executionCase);
+ result = result.add(tickExecution); // Execution(Ticks) added
+ }
+ return result;
+ }
+
+ // TODO: getTaskMemoryAccessTime
+
+ /**
+ * Calculate memory access time of the observed runnable.
+ * The method follows Read / Compute(Ticks) / Write semantic.
+ * Read(Write)_Access_Time = Round_UP(Size_of_Read_Labels / 64.0 Bytes) * (Read_Latency / Frequency)
+ *
+ * @param runnable the observed runnable
+ * @param frequency frequency value of the Processing Unit
+ * @param readLatency readLatency value of the Processing Unit
+ * @param writeLatency writeLatency value of the Processing Unit
+ * @param executionCase BCET, ACET, WCET
+ * @return
+ * memory access time of the observed runnable
+ */
+ private Time getRunnableMemoryAccessTime (final Runnable runnable, final double frequency,
+ final double readLatency, final double writeLatency, final TimeType executionCase) {
+ Time result = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ final Time parameter = FactoryUtil.createTime(BigInteger.ONE, TimeUnit.S);
+ final List<LabelAccess> thisLAList = SoftwareUtil.getLabelAccessList(runnable, null);
+ final List<LabelAccess> readList = thisLAList.stream().filter(x -> (x.getAccess()).equals(LabelAccessEnum.READ)).collect(Collectors.toList());
+ final List<LabelAccess> writeList = thisLAList.stream().filter(x -> (x.getAccess()).equals(LabelAccessEnum.WRITE)).collect(Collectors.toList());
+ /* Read (LabelAccess): */
+ double readAccessParameter = 0;
+ double sizeofReadLabels = 0;
+ for (final LabelAccess rl : readList) {
+ sizeofReadLabels += rl.getData().getSize().getNumberBytes();
+ }
+ readAccessParameter = (Math.ceil(sizeofReadLabels / 64.0) * (readLatency / frequency));
+ final Time readAccess = parameter.multiply(readAccessParameter);
+ result = result.add(readAccess); // LabelAccess(Read) added
+
+ /* Write (LabelAccess): */
+ double writeAccessParameter = 0;
+ double sizeofWriteLabels = 0;
+ for (final LabelAccess wl : writeList) {
+ sizeofWriteLabels += wl.getData().getSize().getNumberBytes();
+ }
+ writeAccessParameter = (Math.ceil(sizeofWriteLabels / 64.0) * (writeLatency / frequency));
+ final Time writeAccess = parameter.multiply(writeAccessParameter);
+ result = result.add(writeAccess); // LabelAccess(Write) added
+ return result;
+ }
+
+ /**
+ * Identify whether the given task has an InterProcessTrigger or not.
+ *
+ * @param task the observed task
+ * @return
+ * boolean value of the result
+ */
+ private static boolean isTriggeringTask(final Task task) {
+ /* true: Triggering Task, false: Non-Triggering Task */
+ boolean result = false;
+ final List<CallSequenceItem> callList = SoftwareUtil.collectEventsOfProcess(task, null);
+ List<CallSequenceItem> iptList = callList.stream().filter(s -> s instanceof InterProcessTrigger).collect(Collectors.toList());
+ if (iptList.size() != 0) {
+ result = true;
+ }
+ return result;
+ }
+}
\ No newline at end of file
diff --git a/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/ui/RTApp_WATERS19.java b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/ui/RTApp_WATERS19.java
new file mode 100644
index 0000000..4d9b798
--- /dev/null
+++ b/eclipse-tools/responseTime-analyzer/plugins/org.eclipse.app4mc.gsoc_rta/src/org/eclipse/app4mc/gsoc_rta/ui/RTApp_WATERS19.java
@@ -0,0 +1,561 @@
+/*******************************************************************************
+ * Copyright (c) 2019 Dortmund University of Applied Sciences and Arts.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors: Junhyung Ki - initial API and implementation
+ *
+ *******************************************************************************/
+package org.eclipse.app4mc.gsoc_rta.ui;
+
+import imported.CommonUtils;
+import java.awt.Color;
+import java.awt.EventQueue;
+import java.awt.Font;
+import java.awt.List;
+import java.awt.TextArea;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import javax.swing.ButtonGroup;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JRadioButton;
+import javax.swing.JTextField;
+import org.eclipse.app4mc.amalthea.model.ProcessingUnit;
+import org.eclipse.app4mc.amalthea.model.PuType;
+import org.eclipse.app4mc.amalthea.model.Task;
+import org.eclipse.app4mc.amalthea.model.Time;
+import org.eclipse.app4mc.amalthea.model.TimeUnit;
+import org.eclipse.app4mc.amalthea.model.io.AmaltheaLoader;
+import org.eclipse.app4mc.amalthea.model.util.FactoryUtil;
+import org.eclipse.app4mc.amalthea.model.util.RuntimeUtil.TimeType;
+import org.eclipse.app4mc.gsoc_rta.CpuRTA;
+
+/**
+ * Date: Jun 20-2019
+ * @author Junhyung Ki
+ * @version 1.0
+ * The purpose of this class is to provide users a better visual and increase usability of Response Time Analysis.
+ */
+@SuppressWarnings("serial")
+public class RTApp_WATERS19 extends JFrame {
+ private HashMap<Integer, java.util.List<Task>> puTaskListHM;
+ private TimeType executionCase;
+ private JFrame frame;
+ private boolean iaEntered = false;
+
+ /**
+ * Launch the application.
+ */
+ public static void main(String[] args) {
+ EventQueue.invokeLater(new Runnable() {
+ public void run() {
+ final RTApp_WATERS19 window = new RTApp_WATERS19();
+ window.frame.setVisible(true);
+ window.frame.setTitle("APP4RTA");
+ }
+ });
+ }
+
+ /**
+ * Create the frame.
+ */
+ public RTApp_WATERS19() {
+ initialize();
+ }
+
+ private void initialize() {
+ final CpuRTA cpurta = new CpuRTA();
+ final ArrayList<JTextField> jTextFieldList = new ArrayList<JTextField>();
+ final ArrayList<List> tListList = new ArrayList<List>();
+ final ArrayList<List> rtListList = new ArrayList<List>();
+
+ frame = new JFrame();
+ frame.setBounds(100, 100, 864, 690);
+ frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ frame.getContentPane().setLayout(null);
+
+ JLabel lblEnterIa = new JLabel("Enter IA");
+ lblEnterIa.setBounds(32, 13, 56, 16);
+ frame.getContentPane().add(lblEnterIa);
+
+ JButton btnDefualtIa = new JButton("Defualt IA");
+ btnDefualtIa.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent arg0) {
+ cpurta.setModel(AmaltheaLoader.loadFromFile(cpurta.inputFile));
+ cpurta.setTRT(cpurta.getDefaultTRT(cpurta.getModel()));
+ cpurta.setIA(cpurta.getDefaultIAMapping());
+ cpurta.setPUl(CommonUtils.getPUs(cpurta.getModel()));
+ final int[] defaultIA = cpurta.getIA();
+ for (int i = 0; i < defaultIA.length; i++) {
+ jTextFieldList.get(i).setText(""+defaultIA[i]);
+ }
+ }
+ });
+ btnDefualtIa.setBounds(12, 28, 97, 25);
+ frame.getContentPane().add(btnDefualtIa);
+
+ JRadioButton rdbtnSynchronous = new JRadioButton("Synchronous");
+ rdbtnSynchronous.setBounds(157, 58, 107, 25);
+ frame.getContentPane().add(rdbtnSynchronous);
+
+ JRadioButton rdbtnAsynchronous = new JRadioButton("Asynchronous");
+ rdbtnAsynchronous.setBounds(157, 79, 107, 25);
+ frame.getContentPane().add(rdbtnAsynchronous);
+
+ ButtonGroup group_0 = new ButtonGroup();
+ group_0.add(rdbtnSynchronous);
+ group_0.add(rdbtnAsynchronous);
+
+ JRadioButton rdbtnWorstCase = new JRadioButton("Worst Case");
+ rdbtnWorstCase.setBounds(268, 58, 107, 25);
+ frame.getContentPane().add(rdbtnWorstCase);
+
+ JRadioButton rdbtnAverageCase = new JRadioButton("Average Case");
+ rdbtnAverageCase.setBounds(268, 79, 107, 25);
+ frame.getContentPane().add(rdbtnAverageCase);
+
+ JRadioButton rdbtnBestCase = new JRadioButton("Best Case");
+ rdbtnBestCase.setBounds(268, 100, 107, 25);
+ frame.getContentPane().add(rdbtnBestCase);
+
+ ButtonGroup group_1 = new ButtonGroup();
+ group_1.add(rdbtnWorstCase);
+ group_1.add(rdbtnAverageCase);
+ group_1.add(rdbtnBestCase);
+
+ JButton btnEnterIA = new JButton("Enter IA");
+ btnEnterIA.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ cpurta.setModel(AmaltheaLoader.loadFromFile(cpurta.inputFile));
+ cpurta.setTRT(cpurta.getDefaultTRT(cpurta.getModel()));
+ int[] tpumap = new int[cpurta.getModel().getSwModel().getTasks().size()];
+ for (int i = 0; i < jTextFieldList.size(); i++) {
+ if ((jTextFieldList.get(i)).getText().length() == 0) {
+ JOptionPane.showMessageDialog(frame, "ERROR: Fill the rest of the array!");
+ return ;
+ }
+ else if ((jTextFieldList.get(i)).getText().charAt(0) < 48 || (jTextFieldList.get(i)).getText().charAt(0) > 54) {
+ JOptionPane.showMessageDialog(frame, "ERROR: Wrong array value!");
+ return ;
+ }
+ // TODO: should be more generic
+ else if (i >= 0 && i <= 9 && Integer.parseInt(((jTextFieldList.get(i)).getText())) == 6) {
+ JOptionPane.showMessageDialog(frame, "ERROR: CPU Tasks should not be mapped to GPU!");
+ return ;
+ }
+ // TODO: should be more generic
+ else if (i == jTextFieldList.size()-1 && Integer.parseInt(((jTextFieldList.get(i)).getText())) != 6) {
+ JOptionPane.showMessageDialog(frame, "ERROR: 'Detection' task can not be mapped to CPU!");
+ return ;
+ }
+ tpumap[i] = Integer.parseInt(((jTextFieldList.get(i)).getText()));
+ }
+ cpurta.setIA(tpumap);
+ cpurta.setPUl(CommonUtils.getPUs(cpurta.getModel()));
+ puTaskListHM = cpurta.be_getPUTaskListHashMap();
+ for (int i = 0; i < puTaskListHM.size(); i++) {
+ if (tListList.get(i).getItemCount() == 0) {
+ for (int j = 0; j < puTaskListHM.get(i).size(); j++) {
+ tListList.get(i).add((puTaskListHM.get(i).get(j)).getName());
+ }
+ }
+ }
+ iaEntered = true;
+ }
+ });
+ btnEnterIA.setBounds(616, 28, 97, 25);
+ frame.getContentPane().add(btnEnterIA);
+
+ JLabel lblResponseTimeSum = new JLabel("Response Time Sum");
+ lblResponseTimeSum.setBounds(616, 359, 145, 16);
+ frame.getContentPane().add(lblResponseTimeSum);
+
+ TextArea rtSum = new TextArea();
+ rtSum.setBounds(616, 381, 218, 50);
+ frame.getContentPane().add(rtSum);
+
+ JButton btnCalculate = new JButton("Calculate");
+ btnCalculate.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent arg0) {
+ for (int i = 0; i < jTextFieldList.size(); i++) {
+ if ((jTextFieldList.get(i)).getText().length() == 0) {
+ JOptionPane.showMessageDialog(frame, "ERROR: Fill the array first!");
+ return ;
+ }
+ }
+ if (rdbtnSynchronous.isSelected()) {
+ cpurta.synchronousOffloading = true;
+ }
+ else if (rdbtnAsynchronous.isSelected()) {
+ cpurta.synchronousOffloading = false;
+ }
+ else {
+ JOptionPane.showMessageDialog(frame, "ERROR: You should choose an offloading mode! (Sync / Async)");
+ return ;
+ }
+ if (rdbtnWorstCase.isSelected()) {
+ executionCase = TimeType.WCET;
+ }
+ else if (rdbtnAverageCase.isSelected()) {
+ executionCase = TimeType.ACET;
+ }
+ else if (rdbtnBestCase.isSelected()) {
+ executionCase = TimeType.BCET;
+ }
+ else {
+ JOptionPane.showMessageDialog(frame, "ERROR: You should choose an execution case! (Worst Case / Average Case / Best Case)");
+ return ;
+ }
+ if (iaEntered == false) {
+ JOptionPane.showMessageDialog(frame, "ERROR: Click the 'Enter IA' button!");
+ return ;
+ }
+ boolean flag = false;
+ Time pRtSum = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ for (int i = 0; i < puTaskListHM.size(); i++) {
+ final ProcessingUnit pu = cpurta.getPUl().get(i);
+ final java.util.List<Task> thisPUTaskList = puTaskListHM.get(i);
+ Time thisRT = FactoryUtil.createTime(BigInteger.ZERO, TimeUnit.PS);
+ if (rtListList.get(i).getItemCount() == 0) {
+ if (pu.getDefinition().getPuType().equals(PuType.CPU)) {
+ for (Task t : thisPUTaskList) {
+ thisRT = cpurta.preciseTestCPURT(t, thisPUTaskList, executionCase, pu);
+ if (thisRT.getValue().equals(BigInteger.valueOf(Long.MAX_VALUE))) {
+ rtListList.get(i).add("Non Scheduleable! => MAX Value");
+ flag = true;
+ }
+ else {
+ rtListList.get(i).add(thisRT.toString());
+ }
+ pRtSum = pRtSum.add(thisRT);
+ }
+ }
+ else {
+ // TODO: TRT 0s!
+ for (Task t : thisPUTaskList) {
+ thisRT = cpurta.getTRT().get(t);
+ rtListList.get(i).add(thisRT.toString());
+ pRtSum = pRtSum.add(thisRT);
+ }
+ }
+ }
+ }
+ if (flag) {
+ rtSum.setText("Non Scheduleable!: " + pRtSum.toString());
+ }
+ else {
+ rtSum.setText(pRtSum.toString());
+ }
+ }
+ });
+ btnCalculate.setBounds(616, 58, 97, 25);
+ frame.getContentPane().add(btnCalculate);
+
+ JButton btnReset = new JButton("Reset");
+ btnReset.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ cpurta.setModel(null);
+ cpurta.setTRT(null);
+ cpurta.setIA(null);
+ cpurta.setPUl(null);
+ puTaskListHM = null;
+ for (int i = 0; i < jTextFieldList.size(); i++) {
+ jTextFieldList.get(i).setText("");
+ }
+ for (List tList : tListList) {
+ tList.removeAll();
+ }
+ for (List rtList : rtListList) {
+ rtList.removeAll();
+ }
+ rtSum.setText(null);
+ iaEntered = false;
+ }
+ });
+ btnReset.setBounds(616, 86, 97, 25);
+ frame.getContentPane().add(btnReset);
+
+ JLabel lblT0 = new JLabel("T0");
+ lblT0.setBounds(124, 13, 15, 16);
+ frame.getContentPane().add(lblT0);
+
+ JTextField txtInput0 = new JTextField();
+ txtInput0.setBounds(124, 29, 23, 22);
+ txtInput0.setColumns(10);
+ frame.getContentPane().add(txtInput0);
+ jTextFieldList.add(txtInput0);
+
+ JLabel lblT1 = new JLabel("T1");
+ lblT1.setBounds(159, 13, 15, 16);
+ frame.getContentPane().add(lblT1);
+
+ JTextField txtInput1 = new JTextField();
+ txtInput1.setColumns(10);
+ txtInput1.setBounds(159, 29, 23, 22);
+ frame.getContentPane().add(txtInput1);
+ jTextFieldList.add(txtInput1);
+
+ JLabel lblT2 = new JLabel("T2");
+ lblT2.setBounds(194, 13, 15, 16);
+ frame.getContentPane().add(lblT2);
+
+ JTextField txtInput2 = new JTextField();
+ txtInput2.setColumns(10);
+ txtInput2.setBounds(194, 29, 23, 22);
+ frame.getContentPane().add(txtInput2);
+ jTextFieldList.add(txtInput2);
+
+ JLabel lblT3 = new JLabel("T3");
+ lblT3.setBounds(229, 13, 15, 16);
+ frame.getContentPane().add(lblT3);
+
+ JTextField txtInput3 = new JTextField();
+ txtInput3.setColumns(10);
+ txtInput3.setBounds(229, 29, 23, 22);
+ frame.getContentPane().add(txtInput3);
+ jTextFieldList.add(txtInput3);
+
+ JLabel lblT4 = new JLabel("T4");
+ lblT4.setBounds(264, 13, 15, 16);
+ frame.getContentPane().add(lblT4);
+
+ JTextField txtInput4 = new JTextField();
+ txtInput4.setColumns(10);
+ txtInput4.setBounds(264, 29, 23, 22);
+ frame.getContentPane().add(txtInput4);
+ jTextFieldList.add(txtInput4);
+
+ JLabel lblT5 = new JLabel("T5");
+ lblT5.setBounds(299, 13, 15, 16);
+ frame.getContentPane().add(lblT5);
+
+ JTextField txtInput5 = new JTextField();
+ txtInput5.setColumns(10);
+ txtInput5.setBounds(299, 29, 23, 22);
+ frame.getContentPane().add(txtInput5);
+ jTextFieldList.add(txtInput5);
+
+ JLabel lblT6 = new JLabel("T6");
+ lblT6.setBounds(334, 13, 15, 16);
+ frame.getContentPane().add(lblT6);
+
+ JTextField txtInput6 = new JTextField();
+ txtInput6.setColumns(10);
+ txtInput6.setBounds(334, 29, 23, 22);
+ frame.getContentPane().add(txtInput6);
+ jTextFieldList.add(txtInput6);
+
+ JLabel lblT7 = new JLabel("T7");
+ lblT7.setBounds(369, 13, 15, 16);
+ frame.getContentPane().add(lblT7);
+
+ JTextField txtInput7 = new JTextField();
+ txtInput7.setColumns(10);
+ txtInput7.setBounds(369, 29, 23, 22);
+ frame.getContentPane().add(txtInput7);
+ jTextFieldList.add(txtInput7);
+
+ JLabel lblT8 = new JLabel("T8");
+ lblT8.setBounds(404, 13, 15, 16);
+ frame.getContentPane().add(lblT8);
+
+ JTextField txtInput8 = new JTextField();
+ txtInput8.setColumns(10);
+ txtInput8.setBounds(404, 29, 23, 22);
+ frame.getContentPane().add(txtInput8);
+ jTextFieldList.add(txtInput8);
+
+ JLabel lblT9 = new JLabel("T9");
+ lblT9.setBounds(439, 13, 15, 16);
+ frame.getContentPane().add(lblT9);
+
+ JTextField txtInput9 = new JTextField();
+ txtInput9.setColumns(10);
+ txtInput9.setBounds(439, 29, 23, 22);
+ frame.getContentPane().add(txtInput9);
+ jTextFieldList.add(txtInput9);
+
+ JLabel lblT10 = new JLabel("T10");
+ lblT10.setBounds(474, 13, 23, 16);
+ frame.getContentPane().add(lblT10);
+
+ JTextField txtInput10 = new JTextField();
+ txtInput10.setColumns(10);
+ txtInput10.setBounds(474, 29, 23, 22);
+ frame.getContentPane().add(txtInput10);
+ jTextFieldList.add(txtInput10);
+
+ JLabel lblT11 = new JLabel("T11");
+ lblT11.setBounds(509, 13, 23, 16);
+ frame.getContentPane().add(lblT11);
+
+ JTextField txtInput11 = new JTextField();
+ txtInput11.setColumns(10);
+ txtInput11.setBounds(509, 29, 23, 22);
+ frame.getContentPane().add(txtInput11);
+ jTextFieldList.add(txtInput11);
+
+ JLabel lblT12 = new JLabel("T12");
+ lblT12.setBounds(544, 13, 23, 16);
+ frame.getContentPane().add(lblT12);
+
+ JTextField txtInput12 = new JTextField();
+ txtInput12.setColumns(10);
+ txtInput12.setBounds(544, 29, 23, 22);
+ frame.getContentPane().add(txtInput12);
+ jTextFieldList.add(txtInput12);
+
+ JLabel lblT13 = new JLabel("T13");
+ lblT13.setBounds(579, 13, 23, 16);
+ frame.getContentPane().add(lblT13);
+
+ JTextField txtInput13 = new JTextField();
+ txtInput13.setColumns(10);
+ txtInput13.setBounds(579, 29, 23, 22);
+ frame.getContentPane().add(txtInput13);
+ jTextFieldList.add(txtInput13);
+
+ JLabel txtArm_0 = new JLabel("ARM0");
+ txtArm_0.setBounds(86, 154, 42, 22);
+ frame.getContentPane().add(txtArm_0);
+
+ List arm0_list = new List();
+ arm0_list.setBounds(10, 180, 87, 145);
+ frame.getContentPane().add(arm0_list);
+ tListList.add(arm0_list);
+
+ List arm0_rtList = new List();
+ arm0_rtList.setBounds(108, 180, 87, 145);
+ frame.getContentPane().add(arm0_rtList);
+ rtListList.add(arm0_rtList);
+
+ JLabel txtArm_1 = new JLabel("ARM1");
+ txtArm_1.setBounds(288, 154, 42, 22);
+ frame.getContentPane().add(txtArm_1);
+
+ List arm1_list = new List();
+ arm1_list.setBounds(212, 180, 87, 145);
+ frame.getContentPane().add(arm1_list);
+ tListList.add(arm1_list);
+
+ List arm1_rtList = new List();
+ arm1_rtList.setBounds(309, 180, 87, 145);
+ frame.getContentPane().add(arm1_rtList);
+ rtListList.add(arm1_rtList);
+
+ JLabel txtArm_2 = new JLabel("ARM2");
+ txtArm_2.setBounds(489, 154, 42, 22);
+ frame.getContentPane().add(txtArm_2);
+
+ List arm2_list = new List();
+ arm2_list.setBounds(414, 180, 87, 145);
+ frame.getContentPane().add(arm2_list);
+ tListList.add(arm2_list);
+
+ List arm2_rtList = new List();
+ arm2_rtList.setBounds(510, 180, 87, 145);
+ frame.getContentPane().add(arm2_rtList);
+ rtListList.add(arm2_rtList);
+
+ JLabel txtArm_3 = new JLabel("ARM3");
+ txtArm_3.setBounds(691, 154, 42, 22);
+ frame.getContentPane().add(txtArm_3);
+
+ List arm3_list = new List();
+ arm3_list.setBounds(616, 180, 87, 145);
+ frame.getContentPane().add(arm3_list);
+ tListList.add(arm3_list);
+
+ List arm3_rtList = new List();
+ arm3_rtList.setBounds(711, 180, 87, 145);
+ frame.getContentPane().add(arm3_rtList);
+ rtListList.add(arm3_rtList);
+
+ JLabel txtDenver_0 = new JLabel("Denver0");
+ txtDenver_0.setBounds(82, 335, 56, 22);
+ frame.getContentPane().add(txtDenver_0);
+
+ List denver0_list = new List();
+ denver0_list.setBounds(10, 359, 87, 145);
+ frame.getContentPane().add(denver0_list);
+ tListList.add(denver0_list);
+
+ List denver0_rtList = new List();
+ denver0_rtList.setBounds(108, 359, 87, 145);
+ frame.getContentPane().add(denver0_rtList);
+ rtListList.add(denver0_rtList);
+
+ JLabel txtDenver_1 = new JLabel("Denver1");
+ txtDenver_1.setBounds(284, 335, 56, 22);
+ frame.getContentPane().add(txtDenver_1);
+
+ List denver1_list = new List();
+ denver1_list.setBounds(212, 359, 87, 145);
+ frame.getContentPane().add(denver1_list);
+ tListList.add(denver1_list);
+
+ List denver1_rtList = new List();
+ denver1_rtList.setBounds(309, 359, 87, 145);
+ frame.getContentPane().add(denver1_rtList);
+ rtListList.add(denver1_rtList);
+
+ JLabel txtGpu = new JLabel("GPU");
+ txtGpu.setBounds(489, 335, 42, 22);
+ frame.getContentPane().add(txtGpu);
+
+ List gpu_list = new List();
+ gpu_list.setBounds(414, 359, 87, 145);
+ frame.getContentPane().add(gpu_list);
+ tListList.add(gpu_list);
+
+ List gpu_rtList = new List();
+ gpu_rtList.setBounds(510, 359, 87, 145);
+ frame.getContentPane().add(gpu_rtList);
+ rtListList.add(gpu_rtList);
+
+ JLabel lblArm = new JLabel("0: ARM0");
+ lblArm.setBounds(12, 62, 56, 16);
+ frame.getContentPane().add(lblArm);
+
+ JLabel lblArm_1 = new JLabel("1: ARM1");
+ lblArm_1.setBounds(12, 79, 56, 16);
+ frame.getContentPane().add(lblArm_1);
+
+ JLabel lblArm_2 = new JLabel("2: ARM2");
+ lblArm_2.setBounds(12, 98, 56, 16);
+ frame.getContentPane().add(lblArm_2);
+
+ JLabel lblArm_3 = new JLabel("3: ARM3");
+ lblArm_3.setBounds(12, 117, 56, 16);
+ frame.getContentPane().add(lblArm_3);
+
+ JLabel lblDenver = new JLabel("4: Denver0");
+ lblDenver.setBounds(77, 62, 72, 16);
+ frame.getContentPane().add(lblDenver);
+
+ JLabel lblDenver_1 = new JLabel("5: Denver1");
+ lblDenver_1.setBounds(77, 79, 72, 16);
+ frame.getContentPane().add(lblDenver_1);
+
+ JLabel lblGpu = new JLabel("6: GPU");
+ lblGpu.setBounds(77, 96, 56, 16);
+ frame.getContentPane().add(lblGpu);
+
+ JLabel lblApprta = new JLabel("APP4RTA");
+ lblApprta.setForeground(Color.BLUE);
+ lblApprta.setFont(new Font("Tahoma", Font.ITALIC, 20));
+ lblApprta.setBounds(747, 1, 87, 34);
+ frame.getContentPane().add(lblApprta);
+ }
+}
\ No newline at end of file
