/// <summary>
/// GetConfigurationObject
/// </summary>
/// <returns></returns>
private CConfiguration GetConfigurationObject()
{
CConfiguration config = CConfiguration.GetObject(Convert.ToInt32(textNoOfTaskSets.Text),
Convert.ToInt32(textNoOfTasks.Text),
Convert.ToDouble(textMinimumPeriod.Text),
Convert.ToDouble(textMaximumPeriod.Text),
Convert.ToDouble(textMinimumExecutionTime.Text),
Convert.ToDouble(textMaximumExecutionTime.Text),
Convert.ToDouble(textMinimumOffset.Text),
Convert.ToDouble(textMaximumOffset.Text));
if (CConfiguration.Message.Trim() != "")
{
MessageBox.Show(CConfiguration.Message);
config = null;
return(config);
}
config.bRunSimulation = checkRunSimulation.Checked;
config.bUniqueExecutionTimes = checkUniqueExecutionTime.Checked;
config.bUniquePeriods = checkUniquePeriod.Checked;
return(config);
}
/// <summary>
///
/// </summary>
/// <param name="oConfiguration"></param>
/// <returns></returns>
public List <CPeriodSet> GetPeriods(CConfiguration oConfiguration, IPrimeNumberGenerator primeGenerator)
{
List <List <double> > allCombinations;
List <CPeriodSet> allPeriodSets = new List <CPeriodSet>();
List <double> mainSet = generateMainSet(oConfiguration.MinPeriod, oConfiguration.MaxPeriod);
CCombinationGenerator comb = new CCombinationGenerator();
_Message = "";
allCombinations = comb.GenerateCombinations(mainSet, oConfiguration.NumberOfTasksPerSet);
//Convert allCombinations to allPeriodSets
CPeriodSet ps;
foreach (List <double> c in allCombinations)
{
ps = new CPeriodSet();
foreach (double d in c)
{
ps.Add(d);
}
allPeriodSets.Add(ps);
}
return(allPeriodSets);
}
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);
}
}
/// <summary>
///
/// </summary>
/// <param name="taskSetArray"></param>
/// <param name="FolderPath"></param>
/// <returns></returns>
public bool WriteFiles(List <CTaskSet> taskSetArray, string FolderPath, CConfiguration config)
{
int idx = 1;
string sFullFileName;
string sComment;
sComment = "Period Range : " + config.MinPeriod + " - " + config.MaxPeriod;
try
{
foreach (CTaskSet taskSet in taskSetArray)
{
taskSet.ChangePriorityOrderToRM();
sFullFileName = FolderPath + "\\" + idx++.ToString().Trim() + ".txt";
WriteToFile(sFullFileName, sComment, taskSet);
}
}
catch (Exception e)
{
_message = e.Message;
return(false);
}
return(true);
}
public bool WriteFile(CTaskExecutionTrace executionTrace,
string FolderPath, string TaskSetID, CConfiguration config)
{
int ii;
string sMain = "";
CTask task;
string sFullFileName = FolderPath + "\\" + TaskSetID + ".txt";
_message = "";
try
{
for (ii = 0; ii < executionTrace.Count; ii++)
{
task = executionTrace.Get(ii);
if (task != null)
{
sMain = sMain + ii.ToString() + "\t" + task.ID;
}
else //Write blank if no task ID
{
sMain = sMain + ii.ToString() + "\t" + " ";
}
sMain = sMain + "\r\n";
}
writeToFile(sFullFileName, sMain);
return(true);
}
catch (Exception e)
{
_message = e.Message;
return(false);
}
}
/// <summary>
/// save config to file
/// </summary>
public static void SaveConfigurationToFiles(CConfiguration Configuration)
{
foreach (CFile F in Configuration.Files)
{
Encoding enc = Encoding.GetEncoding(1251);
try
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(@F.Filename, false, enc))
{
foreach (CSection S in F.Sections)
{
file.WriteLine(S.SectionName);
foreach (CKeyValue KVD in S.KeyValue)
{
if (KVD.Description != null)
{
file.WriteLine(KVD.Description);
}
file.WriteLine(KVD.Key + "=" + KVD.Value);
}
}
}
}
catch (Exception e)
{
throw new Exception("write err: " + @F.Filename + "(" + e + ")");
}
}
}
/// <summary>
/// Generate all possible unique sets of iSizeOfSubet from elements inside mainSet
/// </summary>
/// <param name="listOfElement"></param>
/// <param name="iSizeOfCombinations"></param>
//private void GenerateCombinations(List<double> mainSet, int iSizeOfSubSet)
//{
// double multiple;
// List<double> tmp = new List<double>();
// //Start from min
// //Find first divisor for prime
// //Then find all divisors till max and add them to List
// multiple = min;
// while (multiple % prime != 0) { multiple++; }
// while (multiple <= max)
// {
// tmp.Add(multiple);
// multiple += prime;
// }
// return tmp;
//}
/// <summary>
/// Get Maximum Possible Unique Period Sets
/// </summary>
/// <param name="oConfiguration"></param>
/// <returns></returns>
public long GetMaximumUniquePeriodSets(CConfiguration oConfiguration)
{
int idxMaxGroups;
long noOfFactors;
long lMaxPeriodSets = 0;
CCombinationGenerator comb = new CCombinationGenerator();
int idx;
if (_primes == null)
{
GeneratePrimes(oConfiguration);
}
idxMaxGroups = GetMaximumGroups(oConfiguration.MinPeriod, oConfiguration.MaxPeriod,
oConfiguration.NumberOfTasksPerSet);
idxMaxGroups--; //idxMaxGroups = 2
//for(idx = 0;idx <= idxMaxGroups;idx++)
for (idx = idxMaxGroups; idx > 0; idx--)
{
noOfFactors = GetNumberOfFactors(_primes[idx - 1], oConfiguration.MinPeriod, oConfiguration.MaxPeriod);
lMaxPeriodSets = lMaxPeriodSets + (long)comb.GetNumberOfCombinations(noOfFactors,
oConfiguration.NumberOfTasksPerSet);
}
return(lMaxPeriodSets);
}
/// <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)
{
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);
}
}
/// <summary>
///
/// </summary>
/// <param name="oConfiguration"></param>
private void GeneratePrimes(CConfiguration oConfiguration)
{
double delta = oConfiguration.MaxPeriod - oConfiguration.MinPeriod + 1;
IPrimeNumberGenerator oPrime = new CSieveOfEratosthenes();
_primes = oPrime.GeneratePrimeNumbers(0, delta);//, oConfiguration.MaxPeriod);
}
private double GetMaximumPossibleSets(CConfiguration config)
{
double sum;
long delta;
long MxSize;
CCombinationGenerator comb = new CCombinationGenerator();
CSieveOfEratosthenes sieve = new CSieveOfEratosthenes();
delta = (long)(config.MaxPeriod - config.MinPeriod + 1);
List <double> primes = sieve.GeneratePrimeNumbers(0.0, config.MaxPeriod);
sum = 0;
foreach (double prime in primes)
{
if (prime <= delta / 2)
{
MxSize = (long)(delta / prime + 1);
sum += comb.GetNumberOfCombinations(MxSize, config.NumberOfTasksPerSet);
}
}
return(sum);
}
/// <summary>
///
/// </summary>
/// <param name="oConfiguration"></param>
/// <returns></returns>
public List <CPeriodSet> GetPeriods(CConfiguration oConfiguration,
IPrimeNumberGenerator primeGenerator)
{
int noOfPeriods = oConfiguration.NumberOfTaskSets;
Hashtable hshMain = new Hashtable();
long tmp;
List <CPeriodSet> allPeriodSets = new List <CPeriodSet>();
CPeriodSet ps;
_Message = "";
while (allPeriodSets.Count < oConfiguration.NumberOfTaskSets)
{
ps = new CPeriodSet();
while (ps.Count < oConfiguration.NumberOfTasksPerSet)
{
tmp = GetRandomPeriod((long)oConfiguration.MinPeriod, (long)oConfiguration.MaxPeriod);
while (ps.isPresent(tmp))
{
tmp = GetRandomPeriod((long)oConfiguration.MinPeriod, (long)oConfiguration.MaxPeriod);
}
ps.Add(tmp);
}
allPeriodSets.Add(ps);
}
return(allPeriodSets);
}
public CManager(CConfiguration configuration, CMarket market)
{
this._configuration = configuration;
this._market = market;
// il manager potrebbe cambiare il valore settato nella configurazione
_ticksPerHearthBeat = configuration.Tick;
}
public void Remove_Xml_And_Sample_Tables()
{
var rows = Helpers.RemoveSampleTables(_config);
Assert.AreEqual(-1, rows);
Helpers.RemoveXmlConfiguration();
_config = null;
}
public void Create_Xml_And_Sample_Tables()
{
_config = Helpers.CreateXmlConfiguration();
Assert.IsNotNull(_config);
var rows = Helpers.CreateSampleTables(_config);
Assert.AreEqual(18, rows);
}
private void CreateTaskSets()
{
bool bStatus;
allTaskSets = new List <CTaskSet>();
//Create Configuration
config = CConfiguration.GetObject(20, 3, 3, 40, 1, 7, 0, 0);
config.bUniqueExecutionTimes = true;
//Add Sched Tests
schedTests = new List <ISchedulabilityTest>();
ISchedulabilityTest sch1 = new CHyperbolicSchedulabilityTest();
ISchedulabilityTest sch2 = new CLiuLaylandSchedulabilityTest();
ISchedulabilityTest sch3 = new CUtilizationSchedulabilityTest();
schedTests.Add(sch1);
schedTests.Add(sch2);
schedTests.Add(sch3);
//Add Satisfiability Conditions
satConditions = new List <ISatisfiabilityCondition>();
ISatisfiabilityCondition sat1 = new CPFRPSatisfiabilityCondition();
satConditions.Add(sat1);
//Generate Period Sets and Execution Times
List <CPeriodSet> _periodSets = GetPeriods(config);
List <double> _executionTimes = GetExecutionTime(config);
//Generate Release Offsets
List <double> _releaseOffsets = GetReleaseOffsets(config);
//Create Callbacks
CCallBack cb = new CCallBack();
cb.funcReceivedTaskSet += CheckSchedulability;
//Call Task Set Generator
CTaskSetGenerator tsg = new CTaskSetGenerator();
tsg.GenerateTaskSets(_periodSets, _executionTimes, _releaseOffsets, config, cb);
//Write Task Set Files
CSimpleFileFormatter ff = new CSimpleFileFormatter();
bStatus = ff.WriteFiles(allTaskSets, Application.StartupPath + "\\Files", config);
if (bStatus)
{
MessageBox.Show("All Files Successively Written");
}
}
//Generate Periods
private List <CPeriodSet> GetPeriods(CConfiguration config)
{
List <CPeriodSet> allPeriods = new List <CPeriodSet>();
CPeriodSet ps = new CPeriodSet();
ps.Add(10);
ps.Add(12);
ps.Add(15);
allPeriods.Add(ps);
ps = new CPeriodSet();
ps.Add(18);
ps.Add(20);
ps.Add(21);
allPeriods.Add(ps);
ps = new CPeriodSet();
ps.Add(24);
ps.Add(27);
ps.Add(30);
allPeriods.Add(ps);
ps = new CPeriodSet();
ps.Add(31);
ps.Add(32);
ps.Add(33);
allPeriods.Add(ps);
ps = new CPeriodSet();
ps.Add(36);
ps.Add(29);
ps.Add(42);
allPeriods.Add(ps);
ps = new CPeriodSet();
ps.Add(45);
ps.Add(48);
ps.Add(51);
allPeriods.Add(ps);
ps = new CPeriodSet();
ps.Add(54);
ps.Add(57);
ps.Add(60);
allPeriods.Add(ps);
ps = new CPeriodSet();
ps.Add(63);
ps.Add(66);
ps.Add(69);
allPeriods.Add(ps);
return(allPeriods);
}
/// <summary>
/// rerurn files conf list
/// </summary>
public static List <string> GetConfigurationFilesList(CConfiguration Configuration)
{
List <string> files = new List <string>();
foreach (CFile f in Configuration.Files)
{
files.Add(f.Filename);
}
return(files);
}
/// <summary>
/// return config list
/// </summary>
public static List <CFile> GetConfigurationCFiles(CConfiguration Configuration)
{
List <CFile> Files = new List <CFile>();
foreach (CFile C in Configuration.Files)
{
Files.Add(LoadDataFrominiFile(@C.Filename));
}
return(Files);
}
private async Task <string> MakeProfileImageUrl(string profile_path)
{
CConfiguration config = await GetConfiguration();
string url = config.images.base_url;
url += config.images.profile_sizes[config.images.profile_sizes.Length - 1]; // last one is largest and original size
url += profile_path;
return(url);
}
public void Xml_Configuration_Saving_Test()
{
_config.Dataset.Last().name = "updated-source";
var result = XmlHelper <CConfiguration> .Save(Helpers.XmlFile, _config);
Assert.AreEqual(true, result);
_config = XmlHelper <CConfiguration> .Load(Helpers.XmlFile);
Assert.AreEqual("updated-source", _config.Dataset.Last().name);
}
/// <summary>
///
/// </summary>
/// <param name="oConfiguration"></param>
/// <returns></returns>
public long GetMaximumUniquePeriodSets(CConfiguration oConfiguration)
{
long lMaxPeriodSets;
CCombinationGenerator comb = new CCombinationGenerator();
lMaxPeriodSets = (long)comb.GetNumberOfCombinations(oConfiguration.NumberOfDiscretePeriods,
oConfiguration.NumberOfTasksPerSet);
return(lMaxPeriodSets);
}
/// <summary>
/// Populate business objects from the data reader
/// </summary>
/// <param name="dataReader">data reader</param>
/// <returns>list of CConfiguration</returns>
internal List <CConfiguration> PopulateObjectsFromReader(IDataReader dataReader)
{
List <CConfiguration> list = new List <CConfiguration>();
while (dataReader.Read())
{
CConfiguration businessObject = new CConfiguration();
PopulateBusinessObjectFromReader(businessObject, dataReader);
list.Add(businessObject);
}
return(list);
}
private bool CheckSchedulabililityTests(List <ISchedulabilityTest> schedTests,
CTaskSet taskSet, CConfiguration config)
{
foreach (ISchedulabilityTest test in schedTests)
{
if (!test.IsSatisfied(taskSet, config))
{
return(false);
}
}
return(true);
}
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 async Task <CConfiguration> GetConfiguration()
{
if (m_Configuration != null)
{
return(m_Configuration);
}
string config_search_line = api_base_url + "configuration?api_key=" + api_key;
m_Configuration = await GetFromJSON <CConfiguration>(config_search_line);
return(m_Configuration);
}
/// <summary>
/// Populate business object from data reader
/// </summary>
/// <param name="businessObject">business object</param>
/// <param name="dataReader">data reader</param>
internal void PopulateBusinessObjectFromReader(CConfiguration businessObject, IDataReader dataReader)
{
businessObject.Idconfiguration = (short)dataReader.GetInt16(dataReader.GetOrdinal(CConfiguration.CConfigurationFields.Idconfiguration.ToString()));
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CConfiguration.CConfigurationFields.Nom_configuration.ToString())))
{
businessObject.Nom_configuration = dataReader.GetString(dataReader.GetOrdinal(CConfiguration.CConfigurationFields.Nom_configuration.ToString()));
}
if (!dataReader.IsDBNull(dataReader.GetOrdinal(CConfiguration.CConfigurationFields.Value_configuration.ToString())))
{
businessObject.Value_configuration = dataReader.GetString(dataReader.GetOrdinal(CConfiguration.CConfigurationFields.Value_configuration.ToString()));
}
}
/// <summary>
/// clone config
/// </summary>
public static CConfiguration CopyConfiguration(string ConfigNewName, CConfiguration Configuration)
{
CConfiguration Config = new CConfiguration();
Config.ConfigurationName = ConfigNewName;
Config.RunExeName = Configuration.RunExeName;
Config.Files = new List <CFile>();
foreach (CFile F in Configuration.Files)
{
Config.Files.Add(F);
}
return(Config);
}
/// <summary>
/// Return Execution Times all equal to 0
/// </summary>
/// <param name="configuration"></param>
/// <returns></returns>
public List <double> GetReleaseOffsets(CConfiguration configuration)
{
int ii;
List <double> ro = new List <double>();
try
{
for (ii = 0; ii < configuration.NumberOfTasksPerSet; ii++)
{
ro.Add(0);
}
}
catch (Exception e)
{
_message = e.Message;
}
return(ro);
}
/// <summary>
/// Select by primary key
/// </summary>
/// <param name="keys">primary keys</param>
/// <returns>CConfiguration business object</returns>
public CConfiguration SelectByPrimaryKey(CConfigurationKeys keys)
{
NpgsqlCommand sqlCommand = new NpgsqlCommand();
sqlCommand.CommandText = "public.sp_configuration_SelectByPrimaryKey";
sqlCommand.CommandType = CommandType.StoredProcedure;
// Use connection object of base class
sqlCommand.Connection = MainConnection;
try
{
sqlCommand.Parameters.Add(new NpgsqlParameter("p_idconfiguration", NpgsqlDbType.Smallint, 2, "", ParameterDirection.Input, false, 0, 0, DataRowVersion.Proposed, keys.Idconfiguration));
MainConnection.Open();
NpgsqlDataReader dataReader = sqlCommand.ExecuteReader();
if (dataReader.Read())
{
CConfiguration businessObject = new CConfiguration();
PopulateBusinessObjectFromReader(businessObject, dataReader);
return(businessObject);
}
else
{
return(null);
}
}
catch (Exception ex)
{
throw new Exception("CConfiguration::SelectByPrimaryKey::Error occured.", ex);
}
finally
{
MainConnection.Close();
sqlCommand.Dispose();
}
}
