/// <summary>
/// Returns true / false depending on the Schedulability Condition
/// </summary>
/// <param name="taskSet"></param>
/// <param name="configuration"></param>
/// <returns></returns>
public bool IsSatisfied(CTaskSet taskSet, CConfiguration configuration)
{
double LLB;
try
{
CTask[] allTasks = taskSet.GetAllTasksInPriorityOrder();
double U = taskSet.Utilization;
LLB = taskSet.Count * (Math.Pow(2.0, (1 / (double)taskSet.Count)) - 1);
if (U < LLB)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
_message = e.Message;
return(false);
}
}
public bool IsSatisfied(CTaskSet taskSet, CConfiguration configuration)
{
long slackTime;
try
{
CTask[] tasks = taskSet.GetAllTasksInPriorityOrder();
//Now check different in periods
foreach (CTask t in tasks)
{
slackTime = (long)t.Period - (long)t.ExecutionTime;
//Now make sure the processing time for every event in the set has a lesser slack time
foreach (CTask t1 in tasks)
{
if (t1.ID != t.ID)
{
if (t1.ExecutionTime > slackTime)
{
return(false);
}
}
}
}
return(true);
}
catch (Exception e)
{
_message = e.Message;
return(false);
}
}
private bool CheckSchedulability(CTaskSet taskSet)
{
try
{
AddRunTimeMessage("Schedulability Check", "Verifying Schedulability of Task Set : " + _taskCount.ToString());
//Add Sched and Satisfiability Tests
if (!CheckSchedulabililityTests(_schedTests, taskSet, _config))
{
return(false);
}
if (!CheckSatisfiabilityTests(_satConditions, taskSet, _config))
{
return(false);
}
//Add Task Set to Master List
_allTaskSets.Add(taskSet);
UpdateStatus("Generated task set : " + _taskCount++.ToString());
return(true);
}
catch (Exception e)
{
AddRunTimeMessage("Schedulability Check", "Error: + " + e.Message);
//Stop Execution
return(false);
}
}
public CTaskSet ParseTaskSet(string FileContents)
{
string[] mainArray;
string[] sa;
string s;
mainArray = FileContents.Split('\n');
CTaskSet ts = new CTaskSet();
foreach (string sTmp in mainArray)
{
s = sTmp.Replace('\r', ' ');
//Format of String : Event ID, priority, S, P, C
if (!s.StartsWith("//") && s.Trim() != "")
{
sa = s.Split(',');
CTask T = new CTask(sa[0],
Convert.ToInt32(sa[1]),
Convert.ToDouble(sa[3]),
Convert.ToDouble(sa[4]),
Convert.ToDouble(sa[2]),
0);
ts.Add(T); //4 has a higher priority than 1
}
}
return(ts);
}
public bool IsSatisfied(CTaskSet taskSet, CConfiguration configuration)
{
try
{
double dUtil = 1;
CTask[] taskArray = taskSet.GetAllTasksInPriorityOrder();
foreach (CTask t in taskArray)
{
dUtil = dUtil * (t.Utilization + 1.0);
}
if (dUtil <= 2)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
_message = e.Message;
return(false);
}
}
private bool CheckSatisfiabilityTests(List <ISatisfiabilityCondition> satConds,
CTaskSet taskSet, CConfiguration config)
{
foreach (ISatisfiabilityCondition cond in satConds)
{
if (!cond.IsSatisfied(taskSet, config))
{
return(false);
}
}
return(true);
}
private bool CheckSchedulabililityTests(List <ISchedulabilityTest> schedTests,
CTaskSet taskSet, CConfiguration config)
{
foreach (ISchedulabilityTest test in schedTests)
{
if (!test.IsSatisfied(taskSet, config))
{
return(false);
}
}
return(true);
}
/// <summary>
/// This Function is Called through deletegate in CCallBack;
/// </summary>
/// <param name="taskSet"></param>
/// <returns></returns>
private bool CheckSchedulability(CTaskSet taskSet)
{
if (!CheckSchedulabililityTests(schedTests, taskSet, config))
{
return(false);
}
if (!CheckSatisfiabilityTests(satConditions, taskSet, config))
{
return(false);
}
//Add Task Set to Master List
allTaskSets.Add(taskSet);
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="taskSet"></param>
/// <param name="maxTime"></param>
/// <returns></returns>
public bool SimulateExecution(CTaskSet taskSet, long maxTime)
{
_ExecutionTrace = new CTaskExecutionTrace();
_message = "";
SortedList allTasks = new SortedList();
//Reverse Priority Order in Task Set
taskSet.ReversePriorityOrder();
//Convert Task Set to SortedList
CTask [] array = taskSet.GetAllTasksInPriorityOrder();
if (maxTime <= 0)
{
_message = "Time ro run simulation is not correct";
return(false);
}
foreach (CTask t in array)
{
allTasks.Add(t.iPriority, t);
}
//Get Reverse Priority Tasks
//allTasksReverseOrder = ReversePriorities(allTasks);
try
{
if (findResponseTime(allTasks, 0, maxTime) < 0)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception e)
{
_message = e.Message;
return(false);
}
}
private bool CheckSchedulabililityTests(List <ISchedulabilityTest> schedTests,
CTaskSet taskSet, CConfiguration config)
{
foreach (ISchedulabilityTest test in schedTests)
{
try
{
if (!test.IsSatisfied(taskSet, config))
{
return(false);
}
}
catch (Exception e)
{
AddRunTimeMessage("Schedulability Tests", "Error in " + test.Description + ", Message: " + e.Message);
btnStop_Click(null, null);
}
}
return(true);
}
public bool IsSatisfied(CTaskSet taskSet, CConfiguration configuration)
{
try
{
double U = taskSet.Utilization;
if (U <= 1)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
_message = e.Message;
return(false);
}
}
/// <summary>
/// Write Files
/// </summary>
/// <param name="sFullFileName"></param>
/// <param name="taskSet"></param>
private void WriteToFile(string sFullFileName, string sComment, CTaskSet taskSet)
{
string sMain = "";
string sTmp = "";
CTask [] array = taskSet.GetAllTasksInPriorityOrder();
sMain = "//" + sComment + "\r\n";
sMain = sMain + "//Hyperperiod: " + taskSet.HyperPeriod + ", Utilization: " + taskSet.Utilization + "\r\n";
sMain = sMain + "//ID,Priority,Offset,Period, Execution Time" + "\r\n";
foreach (CTask t in array)
{
sTmp = t.ID + "," + t.iPriority.ToString() + ","
+ t.Offset.ToString() + "," + t.Period.ToString() + ","
+ t.ExecutionTime.ToString();
sMain = sMain + sTmp + "\r\n";
}
writeToFile(sFullFileName, sMain);
}
/// <summary>
/// Run simulation of the task set till the Hyper-period
/// </summary>
/// <param name="taskSet"></param>
/// <returns></returns>
public bool SimulateExecution(CTaskSet taskSet)
{
long maxTime = (long)taskSet.HyperPeriod;
return(SimulateExecution(taskSet, maxTime));
}
public void GenerateTaskSets(List <CPeriodSet> periodSets,
List <double> executionTimes,
List <double> releaseOffsets,
CConfiguration config,
CCallBack addTaskCallback)
{
CTaskSet ts;
CTask task;
int ii;
int executionTimeIdx = 0;
int releaseOffsetIdx = 0;
int count = 0;
_message = "";
if (periodSets.Count < config.NumberOfTaskSets)
{
_message = "Number of period sets is lower than number of required tasks. This task generator can only generate number of tasks same as period sets";
}
periodSets.Sort();
try
{
foreach (CPeriodSet ps in periodSets)
{
ts = new CTaskSet();
if (count == config.NumberOfTaskSets)
{
break;
}
for (ii = 0; ii < ps.Count; ii++)
{
task = new CTask("T" + ii.ToString(), ii, ps.Get(ii),
executionTimes[executionTimeIdx++],
releaseOffsets[releaseOffsetIdx], 0);
ts.Add(task);
if (executionTimeIdx >= executionTimes.Count)
{
executionTimeIdx = 0;
}
if (releaseOffsetIdx >= releaseOffsets.Count)
{
releaseOffsetIdx = 0;
}
}
//Task Set Created, Now Call Delegate
if (addTaskCallback.AddGeneratedTaskSet(ts))
{
count++;
}
}
}
catch (Exception e)
{
_message = "Error in Task Generation Routine : " + e.Message;
}
}
