/// <summary> /// Replaces the names for parent, children, etc. with their actual objects of the variability model /// </summary> internal void init() { this.parent = vm.getBinaryOption(parentName); foreach (var name in this.children_names) { ConfigurationOption c = vm.getBinaryOption(name); if (c == null) { c = vm.getNumericOption(name); } if (c == null) { continue; } this.children.Add(c); } foreach (var imply_names in this.implied_Options_names) { List <ConfigurationOption> optionImplies = new List <ConfigurationOption>(); foreach (var optName in imply_names) { ConfigurationOption c = vm.getBinaryOption(optName); if (c == null) { c = vm.getNumericOption(optName); } if (c == null) { continue; } optionImplies.Add(c); } this.implied_Options.Add(optionImplies); } foreach (var exclud_names in this.excluded_Options_names) { List <ConfigurationOption> excImplies = new List <ConfigurationOption>(); foreach (var optName in exclud_names) { ConfigurationOption c = vm.getBinaryOption(optName); if (c == null) { c = vm.getNumericOption(optName); } if (c == null) { continue; } excImplies.Add(c); } this.excluded_Options.Add(excImplies); } }
/// <summary> /// Parses the binary options, represented as string, of a configuration. /// </summary> /// <param name="binaryString">The string representation of the selected binary configuration options.</param> /// <param name="binaryOptions">The data strcutre containing the parsed binary options and their values.</param> /// <param name="varModel">The variability model the configuration is defined for.</param> /// <returns>True if the configuration is valid.</returns> private static bool parseBinaryOptionString(string binaryString, out Dictionary <BinaryOption, BinaryOption.BinaryValue> binaryOptions, VariabilityModel varModel) { bool valid = true; Dictionary <BinaryOption, BinaryOption.BinaryValue> _binaryOptions = new Dictionary <BinaryOption, BinaryOption.BinaryValue>(); string[] binaryOptionNames = binaryString.Split(','); foreach (string binaryOptionName in binaryOptionNames) { string currOption = binaryOptionName.Trim(); if (currOption.Length > 0) { BinaryOption bOpt = null; bOpt = varModel.getBinaryOption(currOption); if (bOpt == null) { GlobalState.logError.logLine("No Binary option found with name: " + currOption); valid = false; break; } _binaryOptions.Add(bOpt, BinaryOption.BinaryValue.Selected); } } binaryOptions = _binaryOptions; return(valid); }
private bool tokenIsAFeatureOrNumber(string token, VariabilityModel varModel) { token = token.Trim(); double value = 0.0; if (Double.TryParse(token, out value)) { return(true); } if (varModel != null) { NumericOption numOption = varModel.getNumericOption(token); if (numOption != null) { if (!participatingNumOptions.Contains(numOption)) { this.participatingNumOptions.Add(numOption); } numberOfParticipatingFeatures++; return(true); } BinaryOption binOption = varModel.getBinaryOption(token); if (token.StartsWith("Enabled") || token.StartsWith("Disabled")) { binOption = getAbstractOption(token, varModel); } if (binOption != null) { if (!participatingBoolOptions.Contains(binOption)) { this.participatingBoolOptions.Add(binOption); } numberOfParticipatingFeatures++; return(true); } } else { if (token.Equals(this.numOption.Name)) { return(true); } } return(false); }
private static double getValueOfToken(Configuration config, string token, VariabilityModel fm) { token = token.Trim(); double value = 0.0; if (Double.TryParse(token, out value)) { return(value); } NumericOption numOpt = fm.getNumericOption(token); if (numOpt != null) { return(config.NumericOptions[numOpt]); } BinaryOption binOpt = fm.getBinaryOption(token); if (token.StartsWith("Enabled") || token.StartsWith("Disabled")) { binOpt = getAbstractOption(token, fm); } if (binOpt != null) { if (token.Equals("base") || token.Equals("root")) { return(1.0); } if (config.BinaryOptions.Keys.Contains(binOpt) && config.BinaryOptions[binOpt] == BinaryOption.BinaryValue.Selected) { return(1.0); } else { foreach (BinaryOption option in config.BinaryOptions.Keys) { // option has to be selected in the configuration if (option.Name == binOpt.Name && config.BinaryOptions[option] == BinaryOption.BinaryValue.Selected) { return(1.0); } } } } return(0.0); }
private static double getValueOfToken(Configuration config, string token, VariabilityModel fm) { token = token.Trim(); double value = 0.0; if (Double.TryParse(token, out value)) { return(value); } NumericOption numOpt = fm.getNumericOption(token); if (numOpt != null) { return(config.NumericOptions[numOpt]); } BinaryOption binOpt = fm.getBinaryOption(token); if (binOpt != null) { if (token.Equals("base")) { return(1.0); } if (config.BinaryOptions.Keys.Contains(binOpt) && config.BinaryOptions[binOpt] == BinaryOption.BinaryValue.Selected) { return(1.0); } else { foreach (BinaryOption option in config.BinaryOptions.Keys) { if (option.Name == binOpt.Name) { return(1.0); } } } } return(0.0); }
private static List <Configuration> readCSVBinaryOptFormat(string file, VariabilityModel model) { List <Configuration> result = new List <Configuration>(); StreamReader sr = new StreamReader(file); while (!sr.EndOfStream) { var line = sr.ReadLine().Split(';'); List <BinaryOption> temp = new List <BinaryOption>(); for (int i = 0; i < line.Length - 1; i++) { BinaryOption b = model.getBinaryOption(line[i]); temp.Add(b); } double value = Double.Parse(line[line.Length - 1].Replace(',', '.'), System.Globalization.CultureInfo.InvariantCulture); var c = new Configuration(temp); c.setMeasuredValue(GlobalState.currentNFP, value); result.Add(c); } sr.Close(); return(result); }
/// <summary> /// Creates a configuration based on a hash representation of that configuration. /// </summary> /// <param name="hashString">The String which from which we can infer the configuration</param> /// <param name="vm">The variability model that is required for identifying options in the hash string to instantiate actual configuration options.</param> /// <returns>A configuration that maps to the given hash string.</returns> internal static Configuration createFromHashString(string hashString, VariabilityModel vm) { Dictionary <NumericOption, double> numOptions = new Dictionary <NumericOption, double>(); List <BinaryOption> binaryFeatures = new List <BinaryOption>(); Configuration c; String[] optionList = hashString.Split(new String[] { "%;%" }, StringSplitOptions.RemoveEmptyEntries); foreach (String option in optionList) { if (Char.IsDigit(option[option.Length - 1]))//If last char is a digit, then it must be a numeric option { //Now remove the digit from the name int index = option.Length - 1; Char last = option[index]; while (Char.IsDigit(last) || last == ',' || last == '.' || last == '-') { index--; last = option[index]; } Double optionsValue = Math.Round(Double.Parse(option.Substring(index + 1).Replace(',', '.')), 1); NumericOption no = vm.getNumericOption(option.Substring(0, index + 1)); if (no == null) { continue; } numOptions.Add(no, optionsValue); } else { BinaryOption binOpt = vm.getBinaryOption(option); binaryFeatures.Add(binOpt); } } c = new Configuration(binaryFeatures, numOptions); return(c); }
private static List<Configuration> readCSVBinaryOptFormat(string file, VariabilityModel model) { List<Configuration> result = new List<Configuration>(); StreamReader sr = new StreamReader(file); while (!sr.EndOfStream) { var line = sr.ReadLine().Split(';'); List<BinaryOption> temp = new List<BinaryOption>(); for (int i = 0; i < line.Length - 1; i++) { BinaryOption b = model.getBinaryOption(line[i]); temp.Add(b); } double value = Double.Parse(line[line.Length - 1].Replace(',', '.')); var c = new Configuration(temp); c.setMeasuredValue(GlobalState.currentNFP, value); result.Add(c); } sr.Close(); return result; }
/// <summary> /// This method returns a list of all configurations stored in a given file. All options of the configurations have to be defined in the variability model. /// </summary> /// <param name="dat">Object representing the configuration file.</param> /// <param name="model">Variability model of the configurations.</param> /// <returns>Returns a list of configurations that were defined in the XML document. Can be an empty list.</returns> public static List<Configuration> readConfigurations(XmlDocument dat, VariabilityModel model) { XmlElement currentElemt = dat.DocumentElement; // Retrieve the decimal delimiter and the separator sign if included if (currentElemt.HasAttribute(decimalDelimiterTag) && currentElemt.HasAttribute(separatorTag)) { // I assume that the decimal delimiter as well as the separator are only one symbol ConfigurationReader.decimalDelimiter = currentElemt.GetAttribute(decimalDelimiterTag)[0]; ConfigurationReader.separator = currentElemt.GetAttribute(separatorTag)[0]; if (currentElemt.GetAttribute(decimalDelimiterTag).Length > 1 || currentElemt.GetAttribute(separatorTag).Length > 1) { GlobalState.logError.log("The decimal delimiter and the separator must consist of only one symbol."); } if (ConfigurationReader.decimalDelimiter == ConfigurationReader.separator) { GlobalState.logError.log("The decimal delimiter symbol and the separator symbol must be different."); } } else if (currentElemt.HasAttribute(decimalDelimiterTag)) { ConfigurationReader.decimalDelimiter = currentElemt.GetAttribute(decimalDelimiterTag)[0]; if (currentElemt.GetAttribute(decimalDelimiterTag).Length > 1) { GlobalState.logError.log("The decimal delimiter must consist of only one symbol."); } } else if (currentElemt.HasAttribute(separatorTag)) { ConfigurationReader.separator = currentElemt.GetAttribute(separatorTag)[0]; if (currentElemt.GetAttribute(separatorTag).Length > 1) { GlobalState.logError.log("The separator symbol must be different."); } } HashSet<Configuration> configurations = new HashSet<Configuration>(); int numberOfConfigs = currentElemt.ChildNodes.Count; int configsWithTooLargeDeviation = 0; foreach (XmlNode node in currentElemt.ChildNodes) { bool readMultipleMeasurements = false; if (node.Attributes.Count > 0 && node.Attributes[0].Value.ToLower() == "true") { readMultipleMeasurements = true; } Dictionary<NFProperty, double> propertiesForConfig = new Dictionary<NFProperty, double>(); ; bool alternativeFormat = false; string binaryString = ""; string numericString = ""; string configID = ""; Dictionary<NFProperty, double> measuredProperty = new Dictionary<NFProperty, double>(); Configuration c = null; bool hasSetConfig = false; foreach (XmlNode childNode in node.ChildNodes) { if (c == null && hasSetConfig) continue; switch (childNode.Attributes[0].Value) { // TODO we use this to support result files having the old structure case "Configuration": binaryString = childNode.InnerText; break; case "Variable Features": numericString = childNode.InnerText; break; case "BinaryOptions": binaryString = childNode.InnerText; break; case "NumericOptions": numericString = childNode.InnerText; break; case "ConfigID": if (readMultipleMeasurements) { configID = childNode.InnerText.Replace("_", "%;%"); } else configID = childNode.InnerText; if (configID.Contains("%;%seek") && configID.Contains("%;%seek0") == false) { hasSetConfig = true; c = null; break; } alternativeFormat = true; c = Configuration.createFromHashString(configID, GlobalState.varModel); hasSetConfig = true; break; case "CompilerOptions": //todo break; case "ConfigFileOptions": //todo break; case "ParameterOptions": //todo break; case "ProgramName": //todo break; case "StartupBegin": //todo break; case "StartupEnd": //todo break; default: NFProperty property = GlobalState.getOrCreateProperty(childNode.Attributes[0].Value); double measuredValue = 0; //-1 means that measurement failed... 3rd values strongly devigates in C.'s measurements, hence we use it only in case we have no other measurements if (readMultipleMeasurements) { //if (property.Name != "run-real") // continue; String[] m = childNode.InnerText.ToString().Split(separator); double val1 = 0; if (!Double.TryParse(m[0], out val1)) break; if (m.Length > 1) { List<double> values = new List<double>(); double avg = 0; foreach (var i in m) { double d = Convert.ToDouble(i.Replace(decimalDelimiter, '.')); if (d != -1) { values.Add(d); avg += d; } } if (values.Count == 0) { configsWithTooLargeDeviation++; c = null; break; } avg = avg / values.Count; /* foreach (var d in values) { if ((d / avg) * 100 > 10) { configsWithTooLargeDeviation++; c = null; break; } }*/ measuredValue = avg; /*double val2 = Convert.ToDouble(m[1]); if (val1 == -1) measuredValue = val2; else if (val1 == -1 && val2 == -1) measuredValue = Convert.ToDouble(m[2]); else if (val2 == -1) measuredValue = val1; else measuredValue = (val1 + val2) / 2;*/ } else measuredValue = val1; } else measuredValue = Convert.ToDouble(childNode.InnerText.ToString().Replace(decimalDelimiter, '.')); // Save the largest measured value. double currentMaxMeasuredValue; if (GlobalState.allMeasurements.maxMeasuredValue.TryGetValue(property, out currentMaxMeasuredValue)) { if (Math.Abs(measuredValue) > Math.Abs(currentMaxMeasuredValue)) { GlobalState.allMeasurements.maxMeasuredValue[property] = measuredValue; } } else { GlobalState.allMeasurements.maxMeasuredValue.Add(property, measuredValue); } // Add measured value to the configuration. if (alternativeFormat && c != null) { c.setMeasuredValue(property, measuredValue); } else { measuredProperty.Add(property, measuredValue); } break; } } if (alternativeFormat && c != null) { if (configurations.Contains(c)) { GlobalState.logError.logLine("Mutiple definition of one configuration in the configurations file: " + c.ToString()); } else { // if (GlobalState.currentNFP != null && c.nfpValues.Keys.Contains(GlobalState.currentNFP) && c.nfpValues[GlobalState.currentNFP] != -1) configurations.Add(c); } cont: { } continue; } Dictionary<BinaryOption, BinaryOption.BinaryValue> binaryOptions = new Dictionary<BinaryOption, BinaryOption.BinaryValue>(); string[] binaryOptionNames = binaryString.Split(','); foreach (string binaryOptionName in binaryOptionNames) { string currOption = binaryOptionName.Trim(); if (currOption.Length > 0) { BinaryOption bOpt = null; bOpt = model.getBinaryOption(currOption); if (bOpt == null) GlobalState.logError.logLine("No Binary option found with name: " + currOption); binaryOptions.Add(bOpt, BinaryOption.BinaryValue.Selected); } } // Add "root" binary option to the configuration if (!binaryOptions.ContainsKey(model.Root)) binaryOptions.Add(model.Root, BinaryOption.BinaryValue.Selected); Dictionary<NumericOption, double> numericOptions = new Dictionary<NumericOption, double>(); if (!string.IsNullOrEmpty(numericString)) { string[] numOptionArray = numericString.Trim().Split(','); foreach (string numOption in numOptionArray) { string[] numOptionsKeyValue; if (numOption.Contains(";")) numOptionsKeyValue = numOption.Split(';'); else numOptionsKeyValue = numOption.Split(' ');// added for rc-lookahead 40 numOptionsKeyValue[0] = numOptionsKeyValue[0].Trim(); if (numOptionsKeyValue[0].Length == 0) continue; NumericOption varFeat = model.getNumericOption(numOptionsKeyValue[0]); if (varFeat == null) GlobalState.logError.logLine("No numeric option found with name: " + numOptionsKeyValue[0]); double varFeatValue = Convert.ToDouble(numOptionsKeyValue[1]); numericOptions.Add(varFeat, varFeatValue); } } Configuration config = new Configuration(binaryOptions, numericOptions, measuredProperty); //if(configurations.Contains(config)) //{ // GlobalState.logError.log("Mutiple definition of one configuration in the configurations file: " + config.ToString()); //}else //{ configurations.Add(config); //} } GlobalState.logInfo.logLine("Configs with too large deviation: " + configsWithTooLargeDeviation); return configurations.ToList(); }
/// <summary> /// Generates a constraint system based on a variability model. The constraint system can be used to check for satisfiability of configurations as well as optimization. /// </summary> /// <param name="variables">Empty input, outputs a list of CSP terms that correspond to the configuration options of the variability model</param> /// <param name="optionToTerm">A map to get for a given configuration option the corresponding CSP term of the constraint system</param> /// <param name="termToOption">A map that gives for a given CSP term the corresponding configuration option of the variability model</param> /// <param name="vm">The variability model for which we generate a constraint system</param> /// <returns>The generated constraint system consisting of logical terms representing configuration options as well as their boolean constraints.</returns> internal static ConstraintSystem getConstraintSystem(out List<CspTerm> variables, out Dictionary<BinaryOption, CspTerm> optionToTerm, out Dictionary<CspTerm, BinaryOption> termToOption, VariabilityModel vm) { //Reusing seems to not work correctely. The problem: configurations are realized as additional constraints for the system. //however, when checking for the next config, the old config's constraints remain in the solver such that we have a wrong result. /* if (csystem != null && variables_global != null && optionToTerm_global != null && termToOption_global != null && vm != null) {//For optimization purpose if (vm.BinaryOptions.Count == vm_global.BinaryOptions.Count && vm.Name.Equals(vm_global.Name)) { variables = variables_global; optionToTerm = optionToTerm_global; termToOption = termToOption_global; return csystem; } }*/ ConstraintSystem S = ConstraintSystem.CreateSolver(); optionToTerm = new Dictionary<BinaryOption, CspTerm>(); termToOption = new Dictionary<CspTerm, BinaryOption>(); variables = new List<CspTerm>(); foreach (BinaryOption binOpt in vm.BinaryOptions) { CspDomain domain = S.DefaultBoolean; CspTerm temp = S.CreateVariable(domain, binOpt); optionToTerm.Add(binOpt, temp); termToOption.Add(temp, binOpt); variables.Add(temp); } List<List<ConfigurationOption>> alreadyHandledAlternativeOptions = new List<List<ConfigurationOption>>(); //Constraints of a single configuration option foreach (BinaryOption current in vm.BinaryOptions) { CspTerm cT = optionToTerm[current]; if (current.Parent == null || current.Parent == vm.Root) { if (current.Optional == false && current.Excluded_Options.Count == 0) S.AddConstraints(S.Implies(S.True, cT)); else S.AddConstraints(S.Implies(cT, optionToTerm[vm.Root])); } if (current.Parent != null && current.Parent != vm.Root) { CspTerm parent = optionToTerm[(BinaryOption)current.Parent]; S.AddConstraints(S.Implies(cT, parent)); if (current.Optional == false && current.Excluded_Options.Count == 0) S.AddConstraints(S.Implies(parent, cT));//mandatory child relationship } //Alternative or other exclusion constraints if (current.Excluded_Options.Count > 0) { List<ConfigurationOption> alternativeOptions = current.collectAlternativeOptions(); if (alternativeOptions.Count > 0) { //Check whether we handled this group of alternatives already foreach (var alternativeGroup in alreadyHandledAlternativeOptions) foreach (var alternative in alternativeGroup) if (current == alternative) goto handledAlternative; //It is not allowed that an alternative group has no parent element CspTerm parent = null; if (current.Parent == null) parent = S.True; else parent = optionToTerm[(BinaryOption)current.Parent]; CspTerm[] terms = new CspTerm[alternativeOptions.Count + 1]; terms[0] = cT; int i = 1; foreach (BinaryOption altEle in alternativeOptions) { CspTerm temp = optionToTerm[altEle]; terms[i] = temp; i++; } S.AddConstraints(S.Implies(parent, S.ExactlyMofN(1, terms))); alreadyHandledAlternativeOptions.Add(alternativeOptions); handledAlternative: { } } //Excluded option(s) as cross-tree constraint(s) List<List<ConfigurationOption>> nonAlternative = current.getNonAlternativeExlcudedOptions(); if(nonAlternative.Count > 0) { foreach(var excludedOption in nonAlternative){ CspTerm[] orTerm = new CspTerm[excludedOption.Count]; int i = 0; foreach (var opt in excludedOption) { CspTerm target = optionToTerm[(BinaryOption)opt]; orTerm[i] = target; i++; } S.AddConstraints(S.Implies(cT, S.Not(S.Or(orTerm)))); } } } //Handle implies if (current.Implied_Options.Count > 0) { foreach (List<ConfigurationOption> impliedOr in current.Implied_Options) { CspTerm[] orTerms = new CspTerm[impliedOr.Count]; //Possible error: if a binary option impies a numeric option for (int i = 0; i < impliedOr.Count; i++) orTerms[i] = optionToTerm[(BinaryOption)impliedOr.ElementAt(i)]; S.AddConstraints(S.Implies(optionToTerm[current], S.Or(orTerms))); } } } //Handle global cross-tree constraints involving multiple options at a time // the constraints should be in conjunctive normal form foreach (string constraint in vm.BooleanConstraints) { bool and = false; string[] terms; if (constraint.Contains("&")) { and = true; terms = constraint.Split('&'); } else terms = constraint.Split('|'); CspTerm[] cspTerms = new CspTerm[terms.Count()]; int i = 0; foreach (string t in terms) { string optName = t.Trim(); if (optName.StartsWith("-") || optName.StartsWith("!")) { optName = optName.Substring(1); BinaryOption binOpt = vm.getBinaryOption(optName); CspTerm cspElem = optionToTerm[binOpt]; CspTerm notCspElem = S.Not(cspElem); cspTerms[i] = notCspElem; } else { BinaryOption binOpt = vm.getBinaryOption(optName); CspTerm cspElem = optionToTerm[binOpt]; cspTerms[i] = cspElem; } i++; } if (and) S.AddConstraints(S.And(cspTerms)); else S.AddConstraints(S.Or(cspTerms)); } csystem = S; optionToTerm_global = optionToTerm; vm_global = vm; termToOption_global = termToOption; variables_global = variables; return S; }
/// <summary> /// Produce a reduced version of the variability model, containing only binary options /// and at least the considered options. Is a considered option, all parent option will be inlcuded. /// Constraints between options(alternative groups, implication etc), will be included if enough options /// are present to (e.g. both options for implications or at least 2 options in alternative groups). /// </summary> /// <param name="consideredOptions">The options that will be in the reduced model.</param> /// <returns>A reduced version of the model containing the considered options.</returns> public VariabilityModel reduce(List <BinaryOption> consideredOptions) { VariabilityModel reduced = new VariabilityModel(this.name); foreach (BinaryOption binOpt in consideredOptions) { BinaryOption child = new BinaryOption(reduced, binOpt.Name); replicateOption(binOpt, child); reduced.addConfigurationOption(child); BinaryOption parent = (BinaryOption)binOpt.Parent; bool parentExists = false; while ((parent != null && parent != this.root) && !parentExists) { BinaryOption newParent = reduced.getBinaryOption(parent.Name); if (newParent == null) { newParent = new BinaryOption(reduced, parent.Name); replicateOption(parent, newParent); reduced.addConfigurationOption(newParent); } else { parentExists = true; } child.Parent = newParent; child = newParent; parent = (BinaryOption)parent.Parent; } if (child.Parent == null) { child.Parent = reduced.root; } } foreach (BinaryOption opt in consideredOptions) { List <List <ConfigurationOption> > impliedOptionsRepl = new List <List <ConfigurationOption> >(); foreach (List <ConfigurationOption> implied in opt.Implied_Options) { List <ConfigurationOption> implRepl = new List <ConfigurationOption>(); foreach (ConfigurationOption impliedOption in implied) { if (reduced.getOption(impliedOption.Name) != null) { implRepl.Add(reduced.getOption(impliedOption.Name)); } } impliedOptionsRepl.Add(implRepl); } reduced.getBinaryOption(opt.Name).Implied_Options = impliedOptionsRepl; List <List <ConfigurationOption> > excludedOptionsRepl = new List <List <ConfigurationOption> >(); foreach (List <ConfigurationOption> excluded in opt.Excluded_Options) { List <ConfigurationOption> exclRepl = new List <ConfigurationOption>(); foreach (ConfigurationOption excludedOption in excluded) { if (reduced.getOption(excludedOption.Name) != null) { exclRepl.Add(reduced.getOption(excludedOption.Name)); } } excludedOptionsRepl.Add(exclRepl); } reduced.getBinaryOption(opt.Name).Excluded_Options = excludedOptionsRepl; } return(reduced); }
/// <summary> /// This method returns a list of all configurations stored in a given file. All options of the configurations have to be defined in the variability model. /// </summary> /// <param name="dat">Object representing the configuration file.</param> /// <param name="model">Variability model of the configurations.</param> /// <returns>Returns a list of configurations that were defined in the XML document. Can be an empty list.</returns> public static List <Configuration> readConfigurations(XmlDocument dat, VariabilityModel model) { XmlElement currentElemt = dat.DocumentElement; HashSet <Configuration> configurations = new HashSet <Configuration>(); int numberOfConfigs = currentElemt.ChildNodes.Count; int configsWithTooLargeDeviation = 0; foreach (XmlNode node in currentElemt.ChildNodes) { bool readMultipleMeasurements = false; if (node.Attributes.Count > 0 && node.Attributes[0].Value.ToLower() == "true") { readMultipleMeasurements = true; } Dictionary <NFProperty, double> propertiesForConfig = new Dictionary <NFProperty, double>();; bool alternativeFormat = false; string binaryString = ""; string numericString = ""; string configID = ""; Dictionary <NFProperty, double> measuredProperty = new Dictionary <NFProperty, double>(); Configuration c = null; bool hasSetConfig = false; foreach (XmlNode childNode in node.ChildNodes) { if (c == null && hasSetConfig) { continue; } switch (childNode.Attributes[0].Value) { // TODO we use this to support result files having the old structure case "Configuration": binaryString = childNode.InnerText; break; case "Variable Features": numericString = childNode.InnerText; break; case "BinaryOptions": binaryString = childNode.InnerText; break; case "NumericOptions": numericString = childNode.InnerText; break; case "ConfigID": if (readMultipleMeasurements) { configID = childNode.InnerText.Replace("_", "%;%"); } else { configID = childNode.InnerText; } if (configID.Contains("%;%seek") && configID.Contains("%;%seek0") == false) { hasSetConfig = true; c = null; break; } alternativeFormat = true; c = Configuration.createFromHashString(configID, GlobalState.varModel); hasSetConfig = true; break; case "CompilerOptions": //todo break; case "ConfigFileOptions": //todo break; case "ParameterOptions": //todo break; case "ProgramName": //todo break; case "StartupBegin": //todo break; case "StartupEnd": //todo break; default: NFProperty property = GlobalState.getOrCreateProperty(childNode.Attributes[0].Value); double measuredValue = 0; //-1 means that measurement failed... 3rd values strongly devigates in C.'s measurements, hence we use it only in case we have no other measurements if (readMultipleMeasurements) { if (property.Name != "run-real") { continue; } String[] m = childNode.InnerText.ToString().Split(','); double val1 = 0; if (!Double.TryParse(m[0], out val1)) { break; } if (m.Length > 1) { List <double> values = new List <double>(); double avg = 0; foreach (var i in m) { double d = Convert.ToDouble(i); if (d != -1) { values.Add(d); avg += d; } } if (values.Count == 0) { configsWithTooLargeDeviation++; c = null; break; } avg = avg / values.Count; /* foreach (var d in values) * { * if ((d / avg) * 100 > 10) * { * configsWithTooLargeDeviation++; * c = null; * break; * } * }*/ measuredValue = avg; /*double val2 = Convert.ToDouble(m[1]); * if (val1 == -1) * measuredValue = val2; * else if (val1 == -1 && val2 == -1) * measuredValue = Convert.ToDouble(m[2]); * else if (val2 == -1) * measuredValue = val1; * else * measuredValue = (val1 + val2) / 2;*/ } else { measuredValue = val1; } } else { measuredValue = Convert.ToDouble(childNode.InnerText.ToString().Replace(',', '.')); } if (alternativeFormat && c != null) { c.setMeasuredValue(property, measuredValue); } else { measuredProperty.Add(property, measuredValue); } break; } } if (alternativeFormat && c != null) { if (configurations.Contains(c)) { GlobalState.logError.log("Mutiple definition of one configuration in the configurations file: " + c.ToString()); } else { // if (GlobalState.currentNFP != null && c.nfpValues.Keys.Contains(GlobalState.currentNFP) && c.nfpValues[GlobalState.currentNFP] != -1) configurations.Add(c); } cont : { } continue; } Dictionary <BinaryOption, BinaryOption.BinaryValue> binaryOptions = new Dictionary <BinaryOption, BinaryOption.BinaryValue>(); string[] binaryOptionNames = binaryString.Split(','); foreach (string binaryOptionName in binaryOptionNames) { string currOption = binaryOptionName.Trim(); if (currOption.Length > 0) { BinaryOption bOpt = null; bOpt = model.getBinaryOption(currOption); if (bOpt == null) { GlobalState.logError.log("No Binary option found with name: " + currOption); } binaryOptions.Add(bOpt, BinaryOption.BinaryValue.Selected); } } // Add "root" binary option to the configuration if (!binaryOptions.ContainsKey(model.Root)) { binaryOptions.Add(model.Root, BinaryOption.BinaryValue.Selected); } Dictionary <NumericOption, double> numericOptions = new Dictionary <NumericOption, double>(); if (!string.IsNullOrEmpty(numericString)) { string[] numOptionArray = numericString.Trim().Split(','); foreach (string numOption in numOptionArray) { string[] numOptionsKeyValue; if (numOption.Contains(";")) { numOptionsKeyValue = numOption.Split(';'); } else { numOptionsKeyValue = numOption.Split(' ');// added for rc-lookahead 40 } numOptionsKeyValue[0] = numOptionsKeyValue[0].Trim(); if (numOptionsKeyValue[0].Length == 0) { continue; } NumericOption varFeat = model.getNumericOption(numOptionsKeyValue[0]); if (varFeat == null) { GlobalState.logError.log("No numeric option found with name: " + numOptionsKeyValue[0]); } double varFeatValue = Convert.ToDouble(numOptionsKeyValue[1]); numericOptions.Add(varFeat, varFeatValue); } } Configuration config = new Configuration(binaryOptions, numericOptions, measuredProperty); //if(configurations.Contains(config)) //{ // GlobalState.logError.log("Mutiple definition of one configuration in the configurations file: " + config.ToString()); //}else //{ configurations.Add(config); //} } GlobalState.logInfo.log("Configs with too large deviation: " + configsWithTooLargeDeviation); return(configurations.ToList()); }
private bool tokenIsAFeatureOrNumber(string token, VariabilityModel varModel) { token = token.Trim(); double value = 0.0; if (Double.TryParse(token, out value)) { return true; } if (varModel != null) { NumericOption numOption = varModel.getNumericOption(token); if (numOption != null) { if (!participatingNumOptions.Contains(numOption)) this.participatingNumOptions.Add(numOption); numberOfParticipatingFeatures++; return true; } BinaryOption binOption = varModel.getBinaryOption(token); if (binOption != null) { if (!participatingBoolOptions.Contains(binOption)) this.participatingBoolOptions.Add(binOption); numberOfParticipatingFeatures++; return true; } } else { if(token.Equals(this.numOption.Name)) return true; } return false; }
private static double getValueOfToken(Configuration config, string token, VariabilityModel fm) { token = token.Trim(); double value = 0.0; if (Double.TryParse(token, out value)) { return value; } NumericOption numOpt = fm.getNumericOption(token); if (numOpt != null) { return config.NumericOptions[numOpt]; } BinaryOption binOpt = fm.getBinaryOption(token); if (binOpt != null) { if(token.Equals("base")) return 1.0; if (config.BinaryOptions.Keys.Contains(binOpt) && config.BinaryOptions[binOpt] == BinaryOption.BinaryValue.Selected) return 1.0; else { foreach (BinaryOption option in config.BinaryOptions.Keys) { if (option.Name == binOpt.Name ) { return 1.0; } } } } return 0.0; }