Interactive simulator for LET systems
License: GNU General Public License v3.0
![dependabot[bot] avatar](https://avatars.githubusercontent.com/in/29110?v=4 "dependabot[bot]")
When dependency is named as a number i.e., "4", the UI breaks.
Instances, use store name as dictionary keyreceiveEvent: {task: "__system", port: "SystemOutput", taskInstance: 0, timestamp: 1}
sendEvent: {task: "task-c", port: "out", taskInstance: -1, timestamp: 0}
Don't save the dependency instance when receiveEvent.task == Model.SystemInterfaceName and sendEvent.taskInstance == -1
To replicate do the following steps:
Allow users to undo/redo changes to tasks and dependencies. Could use the command design pattern.
See StartTime: 2 and endTime: 2
SystemInputsStore and SystemOutputsStore to IndexedDBSystem Inputs and System OutputsExample of definitions of dependencies in a format the View expects:
Example of instances of dependencies in a format that the View expects:
LetSynchronise/sources/model/ls.model.dependencies.js
Lines 53 to 110 in 673ff08
Update task creation with WCET, ACET, BCET and probability distribution
Need to create exception when adding constraint so that System in and out can be added.
To reproduce add a new constraint with SystemInput and SystemOutput
Repeatedly reset and load the following system: Example.zip
Selector next to the scheduler button for best-case, worst-case, or random execution times.
See ls.view.schedule for an idea of how to create all task instances for a given makespan
LetSynchronise/sources/view/ls.view.schedule.js
Lines 182 to 217 in 8295d86
Current scheduler is defined in ls.model.schedule.js in method reinstantiateTasks.
createTaskInstance is called, do not create executionIntervalsexecutionIntervals in the scheduler plug-in according to the desired scheduling policymodel.task
refreshViews is invokedview.schedule
notifyChanges callback: Set the update button to warning colourregisterUpdateHandler to set the update button back to primary colourview.analysis
controller.task
The order of ports, task, and chains on the UI is unclear.
Maybe consider alphabetical or display an ID?
When a task is updated, one of its ports may be removed. If this happens, dependencies associated with the port should be deleted.
ls.model.task.createTask(...)
Proposal:
Allow users to load in their work from a file
Let scheduler plugin delete schedule instead of ls.controller.schedule.js?
Helper class that relates one type (instance) to another type (instance). For example, getting dependencyInstances of a dependency, getting taskInstances of a task, or get a dependency of a task.
When a task is deleted, communication dependencies involving its input/output ports should also be deleted
ls.model.analyse.js, line 183
In the example below, the last path starting at 10ms is incomplete and should be ignored.
Allow users to save/download their work as a file
executionTiming when instantiating task execution times in the function static async Algorithm(system, executionTiming).Need to handle the error gracefully.
Use these symbols in the names will cause make you no longer able to add new chains.
Helper Functions:
* Parents(DepndencyDag, Task):
Returns the immediate parents of a task in a task dependency directed acyclic graph.
* Schedule(Task, LET, Offset):
Returns a periodic static schedule for a task.
* E2ePaths(TaskCommunications, E2eConstraint):
Returns all end-to-end paths between the input and output.
* PathLatency(Path):
Returns the total execution and communication time of a path.
* AddMetric(Entity, MetricType):
Calculates a score for each entity based on a metric calculation and adds it
as an attribute to the entity.
A positive metric could calculate an entity's flexibility, while a negative
metric could calculate an entity's penalty or severity.
* MostCommonTasks(Paths):
Returns the tasks that appear most frequently in the given paths.
* MostSlack(Tasks, MetricType):
Returns the task with most slack based on a metric calculation. The metric
could be relative or absolute slack.
* GoTo(Step):
Execution of the algorithm goes to the start of mentioned step.
* CumulativeMinAge(TaskSet, TaskCommunications, Task, TaskInput):
Returns the minimum latency for an environmental input to arrive at a task.
* CumulativeMaxAge(TaskSet, TaskCommunications, Task, TaskInput):
Returns the maximum latency for an environmental input to arrive at a task.
Algorithm: LET Scheduling
-------------------------
Given:
* task \in TaskSet: All LET tasks in the system. Assume physical inputs/outputs are tasks.
* task = {period, wcet}: Period and estimated WCET.
* (task1, task2, signal) \in TaskCommunications: Tasks that communicate via a signal.
* (input, output, time) \in E2eConstraints: End-to-end timing constraints.
Return:
* Either, the original task set with a feasible LET schedule,
or nothing if some timing constraints cannot be satisfied.
// 1. Create initial schedule
// Assume that all backward dependencies have been broken.
// Tasks that only depend on physical inputs are scheduled to start at time zero,
// and immediately dependent tasks are scheduled to start immediately after.
dependencyDag = DependencyDag(TaskSet, TaskCommunications);
for each task in dependencyDag:
parents = Parents(dependencyDag, task);
maxOffset = max(for each parent in parents: parent.offset + parent.period);
task.schedule = Schedule(task, LET = PERIOD, maxOffset);
// 2. Rank all end-to-end paths specified in the system's end-to-end timing constraints
// There could be many paths between an input and its output.
// Split the ranking based on whether timing constraints are violated.
// Paths that exceed their timing constraint are ranked by a normalised metric.
PathsViolated = [ ]; // (Path, ActualLatency, MaxAllowedLatency, MetricScore)
PathsRelaxed = [ ];
for each constraint in E2eConstraints:
Paths = E2ePaths(TaskCommunications, constraint);
for each path in Paths:
pathLatency = PathLatency(path);
if (pathLatency > constraint.time):
append(PathsViolated, path, pathLatency, constraint.time);
else:
append(PathsRelaxed, path, pathLatency, constraint.time);
AddMetric(PathsViolated, NEGATIVE);
AddMetric(PathsRelaxed, POSITIVE);
// 3. Iteratively reduce the LET or period of tasks with the greatest amount of slack
// Could be effective to start with the most common task in PathsViolated.
// Fairness could be incorporated.
while PathsViolated is non-empty:
CriticalTasks = MostCommonTasks(PathsViolated);
criticalTask = MostSlack(CriticalTasks, ABSOLUTE);
criticalTask.let = criticalTask.wcet;
GoTo(Step 1);
// 4. Rank tasks with incoherent inputs
// Need to calculate the min and max ages of a task's inputs.
// An input's age can vary if task periods are not whole multiples of each other.
TasksInputIncoherent = [ ];
for each task in TaskSet:
inputsMinAge = infinity;
inputsMaxAge = 0;
for each input in task.inputs:
inputMinAge = CumulativeMinAge(TaskSet, TaskCommunications, task, input);
inputMaxAge = CumulativeMaxAge(TaskSet, TaskCommunications, task, input);
inputsMaxAge = max(inputsMaxAge, inputMaxAge);
inputsMinAge = min(inputsMinAge, inputMinAge);
ageMaxDifference = inputsMaxAge - inputsMinAge;
if (ageMaxDifference > tolerance):
append(TasksInputIncoherent, task, ageMaxDifference);
AddMetric(TasksInputIncoherent, NEGATIVE);
// 5. Terminate the algorithm if TasksInputIncoherent is empty
// Return the task set with its feasible schedules.
if TasksInputIncoherent is empty:
return TaskSet;
// 6. Correct the incoherencies
// Corrections should be made as early as possible in each path for greatest
// flexibility.
while TasksInputIncoherent is non-empty:
// TODO
// Add communication delays to early inputs, or increase periods of predecessor tasks
if changes were made:
GoTo(Step 1);
if all tasks in TasksInputIncoherent have been visited:
return Null;
- - - - - - - - - -
Alternate idea:
---------------
Resolve incoherent inputs based on common tasks in PathsViolated.
Identify frontiers in the task schedule that constrain path delays.
Should be
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
Django
The Web framework for perfectionists with deadlines.
Laravel
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft
Open source projects and samples from Microsoft.
Google
Google ❤️ Open Source for everyone.
Alibaba
Alibaba Open Source for everyone
D3
Data-Driven Documents codes.
Tencent
China tencent open source team.