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(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.
getExecutionTimeForGPUTaskOnCPU
Calculate execution time of the given task which was originally designed for GPU but newly mapped to CPU by Generic Algorithm Mapping.
getExecutionTimeForRTARunnable
Calculate execution time of the given runnable.
getTaskMemoryAccessTime
Calculate memory access time of the observed task.
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)(‘responseTime-analyzer’>‘plugins’>‘doc’>‘APP4RTA_1.0_Description.pdf’)
GSOC 2020
First of all, you will need the pull the amalthea tools repo.
https://git.eclipse.org/c/app4mc/org.eclipse.app4mc.tools.git/
Check out the app4mc0.9.8/gsoc20npRTA.
This is the branch that contains the GSoC2020 implementation by the time the Project is submitted. It may be merged to master soon, too.
Under responseTime-analyzer > plugins > src >...> gsoc_rta folder You will find NPandPRta
class. This is the implementation source file. One can calculate task's response time in different environment using this.
Under responseTime-analyzer > plugins > src >...> gsoc_rta >‘test’ folder, there is NPandPNumerical
class. This is a numerical example on how functions/equations used in ‘NPandPRta’ work.
Under responseTime-analyzer > plugins > src >...> gsoc_rta folder Blocking
is also located here, using this will allow you to calculate local and global blocking time of task
The utlimate target is to implement response time analysis in a mixed environemnt, where task can be surrounded by different tasks with different preemptive type, from preemptive, cooperative to non-preemptive.
The implementation are located in NPandPRta
class. Which include several response time analysis methods.
Refer to each methods' javadoc for more info, mention here are the most important/useful functions, go to this readthedoc if you want a full documentation
NPandPRta.java
There is something need to be mentioned before you try, this class is created based on WATERS2019 model, the functions are tested using that model. But you should be able to ultilize this class without many problem as long as you provided 3 input parameters:
Also additionally there are 3 other parameters:
Below are the important functions that you will probably use most of the time. For the list of all function, refer to the javadoc, readthedoc or open the class, lots of comment are left there
getRTAinMixedPreemptiveEnvironment
Calculate response time of task in mixed environment. Drop the task, the integer mapping array, and the model (again this class is made mainly for WATERS2019 derived model, but it should work on other as well) and you get your response time. The developer also opt in an option where you can input your own preemptive type array. Where you can change task's preemptive type without changing it in the model.
setSchedubilityCheck
This function set a boolean variable where you can enable/disable schedubility check. Which means if you set to false. Every RTA functions will return the value without checking whether that response time bigger than task's period or not.
getResponseTimeViaLevelI
Calculate resposne time of task in preemptive environment via level-i busy window technique. Pretty vanilla/basic implementation.
getResponseTimeViaRecurrenceRelation
Calculate resposne time of task in preemptive environment via recurrence relation. Again very basic execution of how response time is calculated Should give the same result as response time level-i.
getPureExecutionTime
Using the well-known semantics, where task is run as follow: READ -> EXECUTION -> WRITE Calculate all of the element from each step, sum all of them and we have task's execution time.
Blocking.java
Blocking analysis, calculate blocking time of semaphore(critical section) when they are exist, or else calculate time other tasks have to wait due to global resource occupancy (task had to wait because other task is reading/writing label) ) Same as the NPandPRta.java
, this class also created based on WATER 2019 model.
Again this only listed important/useful function. For more info, please refer functions' javadoc and readthedoc
getGlobalBlockingTime
Calculate task's global blocking time ( time blocked by task from other cores) due to semaphore lock. If there is no semaphore, the function will calculate blocking time due to resource being read/write by other task.
The blocking policy is Priority Ceiling Protocol FYI
getLocalBlockingTime
Same with getGlobalBlockingTime, but this time we calculate blocking time due to local task (task within same core)
CpuRTA
RuntimeUtilRTA
NPandPRTA