/// <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(); } }