/// <summary> /// Executes a for loop with 64-bit indexes and thread-local data in which iterations /// may run in parallel, loop options can be configured, and the state of the loop /// can be monitored and manipulated. /// </summary> public static SystemParallelLoopResult For <TLocal>(long fromInclusive, long toExclusive, SystemParallelOptions parallelOptions, Func <TLocal> localInit, Func <long, SystemParallelLoopState, TLocal, TLocal> body, Action <TLocal> localFinally) { ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For)); return(SystemParallel.For(fromInclusive, toExclusive, parallelOptions, localInit, body, localFinally)); }
public override bool Execute() { Log.LogTaskName("Codesign"); Log.LogTaskProperty("CodesignAllocate", CodesignAllocate); Log.LogTaskProperty("DisableTimestamp", DisableTimestamp); Log.LogTaskProperty("Entitlements", Entitlements); Log.LogTaskProperty("Keychain", Keychain); Log.LogTaskProperty("Resources", Resources); Log.LogTaskProperty("ResourceRules", ResourceRules); Log.LogTaskProperty("SigningKey", SigningKey); Log.LogTaskProperty("ExtraArgs", ExtraArgs); Log.LogTaskProperty("IsAppExtension", IsAppExtension); if (Resources.Length == 0) { return(true); } Parallel.ForEach(Resources, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(Environment.ProcessorCount / 2, 1) }, (item) => { Codesign(item); }); return(!Log.HasLoggedErrors); }
/// <summary> /// Executes a foreach operation with thread-local data on a <see cref="OrderablePartitioner{TSource}"/> /// in which iterations may run in parallel, loop options can be configured, and the state of the loop /// can be monitored and manipulated. /// </summary> public static SystemParallelLoopResult ForEach <TSource, TLocal>(OrderablePartitioner <TSource> source, Func <TLocal> localInit, Func <TSource, SystemParallelLoopState, long, TLocal, TLocal> body, Action <TLocal> localFinally) { ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach)); return(SystemParallel.ForEach(source, localInit, body, localFinally)); }
public override bool Execute() { if (!Directory.Exists(AppBundleDir)) { return(true); } var subdirs = new List <string> (); var dylibs = new List <string> (); foreach (var path in Directory.EnumerateFileSystemEntries(AppBundleDir)) { if (Directory.Exists(path)) { var name = Path.GetFileName(path); if (name != "PlugIns" && name != "Watch") { subdirs.Add(path); } } else { if (path.EndsWith(".metallib", StringComparison.Ordinal) || path.EndsWith(".dylib", StringComparison.Ordinal)) { if (NeedsCodesign(path)) { dylibs.Add(path); } } } } foreach (var subdir in subdirs) { foreach (var dylib in Directory.EnumerateFiles(subdir, "*.*", SearchOption.AllDirectories)) { if (dylib.EndsWith(".metallib", StringComparison.Ordinal) || dylib.EndsWith(".dylib", StringComparison.Ordinal)) { if (NeedsCodesign(dylib)) { dylibs.Add(dylib); } } } } if (dylibs.Count == 0) { return(true); } Parallel.ForEach(dylibs, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(Environment.ProcessorCount / 2, 1) }, (dylib) => { Codesign(dylib); }); return(!Log.HasLoggedErrors); }
public void ReorderTasks(int projectId, int storyId, List <Task> tasks) { Parallel.ForEach(tasks, t => { var request = BuildPutRequest(); request.Resource = string.Format(TaskEndpoint + "/{2}?task[position]={3}", t.ProjectId, t.StoryId, t.Id, t.Position); RestClient.ExecuteRequestWithChecks(request); }); }
/// <summary> /// Executes a for loop in which iterations may run in parallel. /// </summary> public static SystemParallelLoopResult For(int fromInclusive, int toExclusive, Action <int> body) { if (CoyoteRuntime.IsExecutionControlled) { return(For(fromInclusive, toExclusive, new SystemParallelOptions(), body)); } return(SystemParallel.For(fromInclusive, toExclusive, body)); }
/// <summary> /// Executes a foreach operation on a <see cref="System.Collections.IEnumerable"/> /// in which iterations may run in parallel. /// </summary> public static SystemParallelLoopResult ForEach <TSource>(IEnumerable <TSource> source, Action <TSource> body) { if (CoyoteRuntime.IsExecutionControlled) { return(ForEach(source, new SystemParallelOptions(), body)); } return(SystemParallel.ForEach(source, body)); }
public void Run(int matrixDimension, Action <int, int> loopAction) { Tpl.For(0, matrixDimension, (int i) => { Tpl.For(i + 1, matrixDimension, (int j) => { loopAction(i, j); }); }); }
public static void ComputeInParallel(IList <TData> baseData, Func <TData, TIntermediate> parallelWork, Action <TIntermediate> recombination, int numberOfPartitions) { var intermediateResults = new BlockingCollection <ProcessedPartition>(); ThreadParallel.Invoke(() => { try { var partitionSize = (int)Math.Ceiling(baseData.Count / (float)numberOfPartitions); ThreadParallel.ForEach(baseData.Select((d, i) => new TaggedBaseData(d, i)).GroupBy(d => d.TaskNumber / partitionSize), g => { intermediateResults.Add(new ProcessedPartition(g.Select(d => parallelWork(d.Data)), g.Key)); }); } finally { intermediateResults.CompleteAdding(); } }, () => { int expecting = 0; var backlog = new Dictionary <int, IEnumerable <TIntermediate> >(); foreach (var group in intermediateResults.GetConsumingEnumerable()) { if (group.TaskNumber != expecting) { // if we are not ready for this yet add it to the backlog backlog[group.TaskNumber] = group.ProcessedData; continue; } IEnumerable <TIntermediate> toProcess = group.ProcessedData; while (true) { foreach (var element in toProcess) { recombination(element); } expecting++; // now see if we can combine with the backlog if (!backlog.TryGetValue(expecting, out toProcess)) { // if we can't find the next task wait for another // task to finish break; } else { backlog.Remove(expecting); } } } }); }
public static void ComputeInParallel(IList <TData> baseData, Func <TData, int, TIntermediate> parallelWork, Action <TIntermediate, int> recombination) { var intermediateResults = new BlockingCollection <TaggedIntermediate>(); ThreadParallel.Invoke(() => { try { ThreadParallel.ForEach(baseData.Select((d, i) => new TaggedBaseData(d, i)), d => { intermediateResults.Add(new TaggedIntermediate(parallelWork(d.Data, d.TaskNumber), d.TaskNumber)); }); } finally { intermediateResults.CompleteAdding(); } }, () => { int expecting = 0; var backlog = new Dictionary <int, TIntermediate>(); foreach (var newData in intermediateResults.GetConsumingEnumerable()) { if (newData.TaskNumber != expecting) { // if we are not ready for this yet add it to the backlog backlog[newData.TaskNumber] = newData.ProcessedData; continue; } TIntermediate toProcess = newData.ProcessedData; while (true) { recombination(toProcess, expecting); expecting++; // now see if we can combine with the backlog if (!backlog.TryGetValue(expecting, out toProcess)) { // if we can't find the next task wait for another // task to finish break; } else { backlog.Remove(expecting); } } } }); }
public override bool Execute() { if (Resources.Length == 0) { return(true); } Parallel.ForEach(Resources, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(Environment.ProcessorCount / 2, 1) }, (item) => { Codesign(item); }); return(!Log.HasLoggedErrors); }
/// <summary> /// Executes a for loop in which iterations may run in parallel and loop options /// can be configured. /// </summary> public static SystemParallelLoopResult For(int fromInclusive, int toExclusive, SystemParallelOptions parallelOptions, Action <int> body) { if (CoyoteRuntime.IsExecutionControlled) { return(SystemParallel.For(fromInclusive, toExclusive, new SystemParallelOptions() { CancellationToken = parallelOptions.CancellationToken, MaxDegreeOfParallelism = MaxDegreeOfParallelism, TaskScheduler = CoyoteRuntime.Current.ControlledTaskScheduler }, body)); } return(SystemParallel.For(fromInclusive, toExclusive, parallelOptions, body)); }
/// <summary> /// Executes a foreach operation on a <see cref="System.Collections.IEnumerable"/> /// in which iterations may run in parallel and loop options can be configured. /// </summary> public static SystemParallelLoopResult ForEach <TSource>(IEnumerable <TSource> source, SystemParallelOptions parallelOptions, Action <TSource> body) { if (CoyoteRuntime.IsExecutionControlled) { return(SystemParallel.ForEach(source, new SystemParallelOptions() { CancellationToken = parallelOptions.CancellationToken, MaxDegreeOfParallelism = MaxDegreeOfParallelism, TaskScheduler = CoyoteRuntime.Current.ControlledTaskScheduler }, body)); } return(SystemParallel.ForEach(source, parallelOptions, body)); }
public override bool Execute() { Log.LogMessage(MessageImportance.Normal, $"Frameworks: {string.Join(", ", Frameworks.Select(c => c.ItemSpec))}"); // debug var dependencies = new SafeList <Dependency>(); void AddRange(IEnumerable <string> toAdd) { foreach (var dependency in toAdd) { if (dependencies.AddIfNotFound(c => c.Dylib == dependency, () => new Dependency(dependency))) { Log.LogMessage(MessageImportance.Normal, $"Swift Dependency Found: {dependency}"); } } } Parallel.ForEach(Frameworks.Select(c => c.ItemSpec), (lib) => { AddRange(ScanForDependenciesOnFrameworks(lib)); }); // we could precalculate this one and publish with a // know dependencies list for Swift dylibs // but that means updating the list everytime a new version // is released and supporting multiple versions. // Update: Windows version is doing it. while (dependencies.Any(c => c.Pending)) { var verifyList = from c in dependencies where c.Pending select c; Parallel.ForEach(verifyList.ToList(), (dependency) => { AddRange(ScanForDependenciesOnSwift(dependency.Dylib)); dependency.MarkAsScanned(); }); } SwiftDependencies = dependencies .Select(c => new TaskItem(c.Dylib)) .ToArray(); return(true); }
public override bool Execute() { var arcs = MtouchArch.Split(',').Select(c => c.Trim().ToLower()).ToList(); // lipo uses lower case var availableArchs = AvailableArchs(); Log.LogMessage(MessageImportance.Normal, $"Copying: {string.Join(", ", Resources.Select(c => c.ItemSpec))}"); Log.LogMessage(MessageImportance.Normal, $"Swift Arcs Needed: {MtouchArch}"); Log.LogMessage(MessageImportance.Normal, $"Swift Arcs Available: {string.Join(", ", availableArchs)}"); var args = GetLipoArgs(availableArchs); var xcodePath = GetRuntimePath(); Parallel.ForEach(Resources.Select(c => c.ItemSpec), (dylib) => { Log.LogMessage(MessageImportance.Normal, $"Copying: {dylib}"); RunLipo($"'{Path.Combine(xcodePath, dylib)}' {args} '{GetOutputPath(dylib)}'"); }); return(true); }
public override bool Execute() { if (Resources.Length == 0) { return(true); } var codesignedFiles = new List <ITaskItem> (); Parallel.ForEach(Resources, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(Environment.ProcessorCount / 2, 1) }, (item) => { Codesign(item); codesignedFiles.AddRange(GetCodesignedFiles(item)); }); CodesignedFiles = codesignedFiles.ToArray(); return(!Log.HasLoggedErrors); }
public List <string> GetDropItemByLevel(int level) { var itemLists = itemLevelDic.AsParallel().Where(pair => { return(pair.Key >= 0 && pair.Key <= level); }).OrderBy(pair => pair.Key); Parallel.ForEach(itemDataDict, pair => { }); int needItemCout = 3; List <string> retItemList = new List <string>(); foreach (var itemList in itemLists) { retItemList.AddRange(itemList.Value); if (retItemList.Count >= needItemCout) { break; } } return(retItemList); }
public override bool Execute() { var arcs = MtouchArch.Split(',').Select(c => c.Trim().ToLower()).ToList(); // lipo uses lower case var availableArchs = AvailableArchs(); Log.LogMessage(MessageImportance.Normal, $"Copying: {string.Join(", ", Resources.Select(c => c.ItemSpec))}"); Log.LogMessage(MessageImportance.Normal, $"Swift Arcs Needed: {MtouchArch}"); Log.LogMessage(MessageImportance.Normal, $"Swift Arcs Available: {string.Join(", ", availableArchs)}"); var archsToRemove = availableArchs.Except(arcs).Where(c => !string.IsNullOrWhiteSpace(c)).ToArray(); StringBuilder argsBuilder = new StringBuilder(); if (archsToRemove.Length == 0) { argsBuilder.Append(" -create -output"); } else { foreach (var arch in archsToRemove) { argsBuilder.Append($" -remove {arch}"); } argsBuilder.Append(" -output"); } var args = argsBuilder.ToString(); var xcodePath = GetRuntimePath(); Parallel.ForEach(Resources.Select(c => c.ItemSpec), (dylib) => { Log.LogMessage(MessageImportance.Normal, $"Copying: {dylib}"); RunLipo($"{Path.Combine(xcodePath, dylib)} {args} {GetOutputPath(dylib)}"); }); return(true); }
private bool IsWhiteRectangle(Bitmap image, IReadOnlyList <IntPoint> rectanglePoints) { BitmapData data = image.LockBits( new Rectangle(rectanglePoints[0].X, rectanglePoints[0].Y, rectanglePoints[1].X - rectanglePoints[0].X, rectanglePoints[3].Y - rectanglePoints[0].Y), ImageLockMode.ReadWrite, image.PixelFormat); var bytesPerPixel = Image.GetPixelFormatSize(image.PixelFormat) / 8; var isWhiteRectangle = true; unsafe { //Nr. de pixeli pe linie * bytesPerPixel int width = (data.Width) * bytesPerPixel; byte *firstPixel = (byte *)data.Scan0; Parallel.For(0, data.Height + 1, (y, state) => { byte *currentLine = firstPixel + y * data.Stride; for (int x = 0; x < width; x += bytesPerPixel) { currentLine[x] = 0; currentLine[x + 1] = 0; currentLine[x + 2] = 255; if (currentLine[x] != 255 && currentLine[x + 1] != 255 && currentLine[x + 2] != 255) { isWhiteRectangle = false; state.Break(); } } }); } image.UnlockBits(data); return(isWhiteRectangle); }
public override bool Execute() { Log.LogTaskName("CodesignNativeLibraries"); Log.LogTaskProperty("AppBundleDir", AppBundleDir); Log.LogTaskProperty("CodesignAllocate", CodesignAllocate); Log.LogTaskProperty("DisableTimestamp", DisableTimestamp); Log.LogTaskProperty("IntermediateOutputPath", IntermediateOutputPath); Log.LogTaskProperty("Keychain", Keychain); Log.LogTaskProperty("SigningKey", SigningKey); Log.LogTaskProperty("ExtraArgs", ExtraArgs); if (!Directory.Exists(AppBundleDir)) { return(true); } var subdirs = new List <string> (); var dylibs = new List <string> (); foreach (var path in Directory.EnumerateFileSystemEntries(AppBundleDir)) { if (Directory.Exists(path)) { var name = Path.GetFileName(path); if (name != "PlugIns" && name != "Watch") { subdirs.Add(path); } } else { if (path.EndsWith(".metallib", StringComparison.Ordinal) || path.EndsWith(".dylib", StringComparison.Ordinal)) { if (NeedsCodesign(path)) { dylibs.Add(path); } } } } foreach (var subdir in subdirs) { foreach (var dylib in Directory.EnumerateFiles(subdir, "*.*", SearchOption.AllDirectories)) { if (dylib.EndsWith(".metallib", StringComparison.Ordinal) || dylib.EndsWith(".dylib", StringComparison.Ordinal)) { if (NeedsCodesign(dylib)) { dylibs.Add(dylib); } } } } if (dylibs.Count == 0) { return(true); } Parallel.ForEach(dylibs, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(Environment.ProcessorCount / 2, 1) }, (dylib) => { Codesign(dylib); }); return(!Log.HasLoggedErrors); }
private void split(DecisionNode root, int[][] input, int[] output) { // 2. If all examples are for the same class, return the single-node // tree with the output label corresponding to this common class. double entropy = Statistics.Tools.Entropy(output, outputClasses); if (entropy == 0) { if (output.Length > 0) root.Output = output[0]; return; } // 3. If number of predicting attributes is empty, then return the single-node // tree with the output label corresponding to the most common value of // the target attributes in the examples. int predictors = attributes.Count(x => x == false); if (predictors <= attributes.Length - maxHeight) { root.Output = Statistics.Tools.Mode(output); return; } // 4. Otherwise, try to select the attribute which // best explains the data sample subset. double[] scores = new double[predictors]; double[] entropies = new double[predictors]; int[][][] partitions = new int[predictors][][]; // Retrieve candidate attribute indices int[] candidates = new int[predictors]; for (int i = 0, k = 0; i < attributes.Length; i++) if (!attributes[i]) candidates[k++] = i; // For each attribute in the data set #if SERIAL for (int i = 0; i < scores.Length; i++) #else Parallel.For(0, scores.Length, i => #endif { scores[i] = computeGainRatio(input, output, candidates[i], entropy, out partitions[i]); } #if !SERIAL ); #endif // Select the attribute with maximum gain ratio int maxGainIndex; scores.Max(out maxGainIndex); var maxGainPartition = partitions[maxGainIndex]; var maxGainEntropy = entropies[maxGainIndex]; var maxGainAttribute = candidates[maxGainIndex]; var maxGainRange = inputRanges[maxGainAttribute]; attributes[maxGainAttribute] = true; // Now, create next nodes and pass those partitions as their responsibilities. DecisionNode[] children = new DecisionNode[maxGainPartition.Length]; for (int i = 0; i < children.Length; i++) { children[i] = new DecisionNode(tree); children[i].Parent = root; children[i].Comparison = ComparisonKind.Equal; children[i].Value = i + maxGainRange.Min; int[][] inputSubset = input.Submatrix(maxGainPartition[i]); int[] outputSubset = output.Submatrix(maxGainPartition[i]); split(children[i], inputSubset, outputSubset); // recursion if (children[i].IsLeaf) { // If the resulting node is a leaf, and it has not // been assigned a value because there were no available // output samples in this category, we will be assigning // the most common label for the current node to it. if (!Rejection && !children[i].Output.HasValue) children[i].Output = Statistics.Tools.Mode(output); } } attributes[maxGainAttribute] = false; root.Branches.AttributeIndex = maxGainAttribute; root.Branches.AddRange(children); }
private void split(DecisionNode root, int[][] input, int[] output) { // 2. If all examples are for the same class, return the single-node // tree with the output label corresponding to this common class. double entropy = Statistics.Tools.Entropy(output, outputClasses); if (entropy == 0) { if (output.Length > 0) { root.Output = output[0]; } return; } // 3. If number of predicting attributes is empty, then return the single-node // tree with the output label corresponding to the most common value of // the target attributes in the examples. int predictors = attributes.Count(x => x == false); if (predictors == 0) { root.Output = Statistics.Tools.Mode(output); return; } // 4. Otherwise, try to select the attribute which // best explains the data sample subset. double[] scores = new double[predictors]; double[] entropies = new double[predictors]; int[][][] partitions = new int[predictors][][]; // Retrieve candidate attribute indices int[] candidates = new int[predictors]; for (int i = 0, k = 0; i < attributes.Length; i++) { if (!attributes[i]) { candidates[k++] = i; } } // For each attribute in the data set Parallel.For(0, scores.Length, i => { scores[i] = computeGainRatio(input, output, candidates[i], entropy, out partitions[i]); }); // Select the attribute with maximum gain ratio int maxGainIndex; scores.Max(out maxGainIndex); var maxGainPartition = partitions[maxGainIndex]; var maxGainEntropy = entropies[maxGainIndex]; var maxGainAttribute = candidates[maxGainIndex]; var maxGainRange = inputRanges[maxGainAttribute]; attributes[maxGainAttribute] = true; // Now, create next nodes and pass those partitions as their responsabilities. DecisionNode[] children = new DecisionNode[maxGainPartition.Length]; for (int i = 0; i < children.Length; i++) { children[i] = new DecisionNode(tree); children[i].Parent = root; children[i].Comparison = ComparisonKind.Equal; children[i].Value = i + maxGainRange.Min; int[][] inputSubset = input.Submatrix(maxGainPartition[i]); int[] outputSubset = output.Submatrix(maxGainPartition[i]); split(children[i], inputSubset, outputSubset); // recursion } attributes[maxGainAttribute] = false; root.Branches = new DecisionBranchNodeCollection(maxGainAttribute, children); }
/// <summary> /// Executes a foreach operation on a <see cref="System.Collections.IEnumerable"/> in which iterations /// may run in parallel, and the state of the loop can be monitored and manipulated. /// </summary> public static SystemParallelLoopResult ForEach <TSource>(IEnumerable <TSource> source, Action <TSource, SystemParallelLoopState> body) { ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach)); return(SystemParallel.ForEach(source, body)); }
/// <summary> /// Executes a foreach operation on a <see cref="OrderablePartitioner{TSource}"/> /// in which iterations may run in parallel, loop options can be configured, and /// the state of the loop can be monitored and manipulated. /// </summary> public static SystemParallelLoopResult ForEach <TSource>(OrderablePartitioner <TSource> source, SystemParallelOptions parallelOptions, Action <TSource, SystemParallelLoopState, long> body) { ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.ForEach)); return(SystemParallel.ForEach(source, parallelOptions, body)); }
private void WriteFilesAsync(List <FileToWrite> files) { var project = new ProjectFile(files, AddNewFilesToProject, Tfs); if (UseTfsToCheckoutFiles) { DisplayMessage("Creating Required Directories"); foreach (var dir in files.Select(f => f.Directory).Distinct()) { if (dir != null && !Directory.Exists(dir)) { Directory.CreateDirectory(dir); } } DisplayMessage("Getting Latest from TFS"); // Get Latest Version of all files foreach (var batch in files.Select(f => f.Path).Batch(50)) { Tfs.Get(true, batch.ToArray()); } if (Debugger.IsAttached) { DisplayMessage("Creating Temporary Files"); foreach (var file in files) { WriteFilesForTfs(project, file); } CheckoutChangedFiles(files); DisplayMessage("Updating Changed Files"); foreach (var file in files) { CopyChangedFiles(file); } } else { DisplayMessage("Creating Temporary Files"); Parallel.ForEach(files, f => WriteFilesForTfs(project, f)); CheckoutChangedFiles(files); DisplayMessage("Updating Changed Files"); Parallel.ForEach(files, CopyChangedFiles); } } else { if (Debugger.IsAttached) { foreach (var file in files) { WriteFileIfDifferent(project, file); } } else { Parallel.ForEach(files, f => WriteFileIfDifferent(project, f)); } } if (AddNewFilesToProject && !project.ProjectFound) { Log("Unable to find a Project file to add newly created files to. Either output the files into a directory that has a single project in it's path, or uncheck the \"Add New Files to Project\" Setting"); } if (project.ProjectUpdated) { WriteFileIfDifferent(new ProjectFile(null, false, null), new FileToWrite(project.ProjectPath, project.GetContents())); } }
/// <summary> /// Executes each of the provided actions, possibly in parallel, unless the operation is cancelled by the user. /// </summary> public static void Invoke(SystemParallelOptions parallelOptions, params Action[] actions) { ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.Invoke)); SystemParallel.Invoke(parallelOptions, actions); }
/// <summary> /// Executes a for loop in which iterations may run in parallel, loop options can /// be configured, and the state of the loop can be monitored and manipulated. /// </summary> public static SystemParallelLoopResult For(int fromInclusive, int toExclusive, SystemParallelOptions parallelOptions, Action <int, SystemParallelLoopState> body) { ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For)); return(SystemParallel.For(fromInclusive, toExclusive, parallelOptions, body)); }
private void split(DecisionNode root, double[][] input, int[] output, int height) { // 2. If all examples are for the same class, return the single-node // tree with the output label corresponding to this common class. double entropy = Statistics.Tools.Entropy(output, outputClasses); if (entropy == 0) { if (output.Length > 0) root.Output = output[0]; return; } // 3. If number of predicting attributes is empty, then return the single-node // tree with the output label corresponding to the most common value of // the target attributes in the examples. // how many variables have been used less than the limit int candidateCount = attributeUsageCount.Count(x => x < join); if (candidateCount == 0 || (maxHeight > 0 && height == maxHeight)) { root.Output = Statistics.Tools.Mode(output); return; } // 4. Otherwise, try to select the attribute which // best explains the data sample subset. double[] scores = new double[candidateCount]; double[] thresholds = new double[candidateCount]; int[][][] partitions = new int[candidateCount][][]; // Retrieve candidate attribute indices int[] candidates = new int[candidateCount]; for (int i = 0, k = 0; i < attributeUsageCount.Length; i++) { if (attributeUsageCount[i] < join) candidates[k++] = i; } // For each attribute in the data set #if SERIAL for (int i = 0; i < scores.Length; i++) #else Parallel.For(0, scores.Length, i => #endif { scores[i] = computeGainRatio(input, output, candidates[i], entropy, out partitions[i], out thresholds[i]); } #if !SERIAL ); #endif // Select the attribute with maximum gain ratio int maxGainIndex; scores.Max(out maxGainIndex); var maxGainPartition = partitions[maxGainIndex]; var maxGainAttribute = candidates[maxGainIndex]; var maxGainRange = inputRanges[maxGainAttribute]; var maxGainThreshold = thresholds[maxGainIndex]; // Mark this attribute as already used attributeUsageCount[maxGainAttribute]++; double[][] inputSubset; int[] outputSubset; // Now, create next nodes and pass those partitions as their responsibilities. if (tree.Attributes[maxGainAttribute].Nature == DecisionVariableKind.Discrete) { // This is a discrete nature attribute. We will branch at each // possible value for the discrete variable and call recursion. DecisionNode[] children = new DecisionNode[maxGainPartition.Length]; // Create a branch for each possible value for (int i = 0; i < children.Length; i++) { children[i] = new DecisionNode(tree) { Parent = root, Value = i + maxGainRange.Min, Comparison = ComparisonKind.Equal, }; inputSubset = input.Submatrix(maxGainPartition[i]); outputSubset = output.Submatrix(maxGainPartition[i]); split(children[i], inputSubset, outputSubset, height + 1); // recursion } root.Branches.AttributeIndex = maxGainAttribute; root.Branches.AddRange(children); } else if (maxGainPartition.Length > 1) { // This is a continuous nature attribute, and we achieved two partitions // using the partitioning scheme. We will branch on two possible settings: // either the value is greater than a currently detected optimal threshold // or it is less. DecisionNode[] children = { new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.LessThanOrEqual }, new DecisionNode(tree) { Parent = root, Value = maxGainThreshold, Comparison = ComparisonKind.GreaterThan } }; // Create a branch for lower values inputSubset = input.Submatrix(maxGainPartition[0]); outputSubset = output.Submatrix(maxGainPartition[0]); split(children[0], inputSubset, outputSubset, height + 1); // Create a branch for higher values inputSubset = input.Submatrix(maxGainPartition[1]); outputSubset = output.Submatrix(maxGainPartition[1]); split(children[1], inputSubset, outputSubset, height + 1); root.Branches.AttributeIndex = maxGainAttribute; root.Branches.AddRange(children); } else { // This is a continuous nature attribute, but all variables are equal // to a constant. If there is only a constant value as the predictor // and there are multiple output labels associated with this constant // value, there isn't much we can do. This node will be a leaf. // We will set the class label for this node as the // majority of the currently selected output classes. outputSubset = output.Submatrix(maxGainPartition[0]); root.Output = Statistics.Tools.Mode(outputSubset); } attributeUsageCount[maxGainAttribute]--; }
public override bool Execute() { if (Resources.Length == 0) { return(true); } var codesignedFiles = new List <ITaskItem> (); var resourcesToSign = Resources; // 1. Rewrite requests to sign executables inside frameworks to sign the framework itself // signing a framework and a file inside a framework is not *always* identical // on macOS apps {item.ItemSpec} can be a symlink to `Versions/Current/{item.ItemSpec}` // and `Current` also a symlink to `A`... and `_CodeSignature` will be found there // 2. Resolve symlinks in the input. // 3. Make sure we're working with full paths. // All this makes it easier to sort and split the input files into buckets that can be codesigned together, // while also not codesigning directories before files inside them. foreach (var res in resourcesToSign) { var path = res.ItemSpec; var parent = Path.GetDirectoryName(path); // so do not don't sign `A.framework/A`, sign `A.framework` which will always sign the *bundle* if (Path.GetExtension(parent) == ".framework" && Path.GetFileName(path) == Path.GetFileNameWithoutExtension(parent)) { path = parent; } path = PathUtils.ResolveSymbolicLinks(path); path = Path.GetFullPath(path); res.ItemSpec = path; } // first sort all the items by path length, longest path first. resourcesToSign = resourcesToSign.OrderBy(v => v.ItemSpec.Length).Reverse().ToArray(); // remove items that are up-to-date for (var i = 0; i < resourcesToSign.Length; i++) { var item = resourcesToSign [i]; if (!NeedsCodesign(resourcesToSign, i)) { resourcesToSign [i] = null; } } resourcesToSign = resourcesToSign.Where(v => v is not null).ToArray(); // Then we need to split the input into buckets, where everything in a bucket can be signed in parallel // (i.e. no item in a bucket depends on any other item in the bucket being signed first). // any such items must go into a different bucket. The bucket themselves are also sorted, where // we have to sign the first bucket first, and so on. // Since we've sorted by path length, we know that if we find a directory, we won't find any containing // files from that directory later. var buckets = new List <List <ITaskItem> > (); for (var i = 0; i < resourcesToSign.Length; i++) { var res = resourcesToSign [i]; // All files can go into the first bucket. if (File.Exists(res.ItemSpec)) { if (buckets.Count == 0) { buckets.Add(new List <ITaskItem> ()); } var bucket = buckets [0]; bucket.Add(res); continue; } if (Directory.Exists(res.ItemSpec)) { var dir = res.ItemSpec; // Add the directory separator, so we can do easy substring matches dir = EnsureEndsWithDirectorySeparator(dir); // This is a directory, which can contain other files or directories that must be signed first // If this item is a containing directory for any of the items in a bucket, then we need to // add this item to the next bucket. So we go through the buckets in reverse order. var added = false; for (var b = buckets.Count - 1; b >= 0; b--) { var bucket = buckets [b]; var anyContainingFile = bucket.Any(v => v.ItemSpec.StartsWith(dir, StringComparison.OrdinalIgnoreCase)); if (anyContainingFile) { if (b + 1 >= buckets.Count) { buckets.Add(new List <ITaskItem> ()); } buckets [b + 1].Add(res); added = true; break; } } if (!added) { // This directory doesn't contain any other signed files, so we can add it to the first bucket. if (buckets.Count == 0) { buckets.Add(new List <ITaskItem> ()); } var bucket = buckets [0]; bucket.Add(res); } continue; } Log.LogWarning("Unable to sign '{0}': file or directory not found.", res.ItemSpec); } #if false Log.LogWarning("Codesigning {0} buckets", buckets.Count); for (var b = 0; b < buckets.Count; b++) { var bucket = buckets [b]; Log.LogWarning($" Bucket #{b + 1} contains {bucket.Count} items:"); foreach (var item in bucket) { Log.LogWarning($" {item.ItemSpec}"); } } #endif for (var b = 0; b < buckets.Count; b++) { var bucket = buckets [b]; Parallel.ForEach(bucket, new ParallelOptions { MaxDegreeOfParallelism = Math.Max(Environment.ProcessorCount / 2, 1) }, (item) => { Codesign(item); var files = GetCodesignedFiles(item); lock (codesignedFiles) codesignedFiles.AddRange(files); }); } CodesignedFiles = codesignedFiles.ToArray(); return(!Log.HasLoggedErrors); }
/// <summary> /// Executes a for loop with 64-bit indexes in which iterations may run in parallel /// and the state of the loop can be monitored and manipulated. /// </summary> public static SystemParallelLoopResult For(long fromInclusive, long toExclusive, Action <long, SystemParallelLoopState> body) { ExceptionProvider.ThrowUncontrolledInvocationException(nameof(SystemParallel.For)); return(SystemParallel.For(fromInclusive, toExclusive, body)); }