public void ValidateSparseMatrixAsDenseAnsi() { SparseMatrix<string, string, double> sparseMatrixObj = GetSparseMatrix(); ParallelOptions parallelOptObj = new ParallelOptions(); DenseAnsi denseAnsiObj = sparseMatrixObj.AsDenseAnsi<double>(parallelOptObj); // Validate all properties of Ansi and SparseMatrix Assert.AreEqual(sparseMatrixObj.ColCount, denseAnsiObj.ColCount); Assert.AreEqual(sparseMatrixObj.ColKeys.Count, denseAnsiObj.ColKeys.Count); Assert.AreEqual(sparseMatrixObj.IndexOfColKey.Count, denseAnsiObj.IndexOfColKey.Count); Assert.AreEqual(sparseMatrixObj.IndexOfRowKey.Count, denseAnsiObj.IndexOfRowKey.Count); Assert.AreEqual("?", denseAnsiObj.MissingValue.ToString((IFormatProvider)null)); Assert.AreEqual(sparseMatrixObj.RowCount, denseAnsiObj.RowCount); Assert.AreEqual(sparseMatrixObj.RowKeys.Count, denseAnsiObj.RowKeys.Count); Assert.AreEqual(utilityObj.xmlUtil.GetTextValue( Constants.SimpleMatrixNodeName, Constants.DenseAnsiStringNode), denseAnsiObj.ToString2D().Replace("\r", "").Replace("\n", "").Replace("\t", "")); ApplicationLog.WriteLine( "SparseMatrix BVT : Validation of AsDenseAnsi() method successful"); }
static void Main(string[] args) { TaskScheduler.UnobservedTaskException += OnUnobservedTaskException; Console.WriteLine("Press enter to start"); Console.ReadLine(); // Batch the connections, once they're all active though it's fine int connectionBatchSize = 10; int connectionSleepInterval = 1000; int maxClients = 3000; var options = new ParallelOptions { MaxDegreeOfParallelism = connectionBatchSize }; for (int x = 0; x < maxClients; x += connectionBatchSize) { Parallel.For(0, connectionBatchSize, options, i => { StartClient(); }); System.Threading.Thread.Sleep(connectionSleepInterval); } Console.Read(); }
public void ValidateRowKeysPairAnsiGetInstanceFromPairAnsi() { ParallelOptions parOptObj = new ParallelOptions(); UOPair<char> uoPairObj = new UOPair<char>('?', '?'); DensePairAnsi dpaObj = DensePairAnsi.CreateEmptyInstance( new string[] { "R0", "R1", "R2" }, new string[] { "C0", "C1", "C2", "C3" }, uoPairObj); dpaObj.WriteDensePairAnsi(Constants.FastQTempTxtFileName, parOptObj); using (RowKeysPairAnsi rkaObj = RowKeysPairAnsi.GetInstanceFromPairAnsi( Constants.FastQTempTxtFileName, parOptObj)) { Assert.AreEqual(4, rkaObj.ColCount); Assert.AreEqual(3, rkaObj.RowCount); } if (File.Exists(Constants.FastQTempTxtFileName)) File.Delete(Constants.FastQTempTxtFileName); ApplicationLog.WriteLine( "RowKeysPairAnsi BVT : Validation of GetInstanceFromPairAnsi() method successful"); }
public void Read_Streams() { long values = 0; int streams = 0; var watch = Stopwatch.StartNew(); var opt = new ParallelOptions { MaxDegreeOfParallelism = 4 }; Parallel.ForEach(GetStreams(), opt, stream => //foreach (var stream in GetStreams()) { streams++; var repository = BuildRepository(stream); foreach (var value in repository.GetValues()) values++; var speed = values / watch.Elapsed.TotalSeconds; Console.WriteLine("Completed {0} number {1} : {2:0} total of {3} ", stream, streams, speed, values); } ); watch.Stop(); Console.WriteLine("read {0} values in {1} streams in {2}", values, streams, watch.Elapsed); }
public static BitmapSource GetColorBrushImage(Color color) { var stream = new MemoryStream(); Resource.EmptyBrush.Save(stream, ImageFormat.Png); stream.Seek(0, SeekOrigin.Begin); var bitmap = CreateBitmapImage(stream); int width = bitmap.PixelWidth; int height = bitmap.PixelHeight; var resultBitmap = new WriteableBitmap(width, height, 92, 92, PixelFormats.Bgra32, bitmap.Palette); var imageBytes = bitmap.GetBytes(); DisposeImage(bitmap); var po = new ParallelOptions {MaxDegreeOfParallelism = 4}; Parallel.For(0, width*height, po, i => { int index = i*4; if (imageBytes[index + 3] < 16) { imageBytes[index] = color.B; imageBytes[index + 1] = color.G; imageBytes[index + 2] = color.R; imageBytes[index + 3] = color.A; } }); resultBitmap.WritePixels(new Int32Rect(0, 0, width, height), imageBytes, 4*width, 0); if (resultBitmap.CanFreeze) { resultBitmap.Freeze(); } return resultBitmap; }
public void ImportAllStreams() { var ids = new List<int>(); using (var con = new System.Data.SqlClient.SqlConnection(_cs)) { con.Open(); ids = GetStreamIds(con).OrderBy(d => d).ToList(); } var po = new ParallelOptions { MaxDegreeOfParallelism = 4 }; //Parallel.ForEach(ids, po, id => //{ // var sw = Stopwatch.StartNew(); // TryImportStream(id); // sw.Stop(); // ImportedStreams++; // Console.WriteLine(" Done in {0}", sw.Elapsed); //}); foreach (var id in ids) { var sw = Stopwatch.StartNew(); TryImportStream(id); sw.Stop(); ImportedStreams++; Console.WriteLine(" Done in {0}", sw.Elapsed); } }
public void Build(MetricDB db, int k, Index ref_index) { this.DB = db; this.K = k; this.R = ref_index; int sigma = this.R.DB.Count; this.INVINDEX = new List<List<int>> (sigma); for (int i = 0; i < sigma; ++i) { this.INVINDEX.Add(new List<int>()); } var A = new int[this.DB.Count][]; int count = 0; var compute_one = new Action<int>(delegate(int objID) { var u = this.GetKnr(this.DB[objID], this.K); A[objID] = u; ++count; if (count % 1000 == 0) { Console.WriteLine ("==== {0}/{1} db: {2}, k: {3}", count, this.DB.Count, this.DB.Name, k); } }); ParallelOptions ops = new ParallelOptions(); ops.MaxDegreeOfParallelism = -1; Parallel.ForEach(new ListGen<int>((int i) => i, this.DB.Count), ops, compute_one); for (int objID = 0; objID < this.DB.Count; ++objID) { var u = A[objID]; for (int i = 0; i < this.K; ++i) { this.INVINDEX[u[i]].Add (objID); } } }
public List<BuildInfoDto> GetBuildInfoDtosPolling(String filterDate) { var buildInfoDtos = new List<BuildInfoDto>(); try { var sinceDateTime = DateTime.Now.Subtract(new TimeSpan(int.Parse(filterDate), 0, 0)); var tfsServer = _helperClass.GetTfsServer(); // Get the catalog of team project collections var teamProjectCollectionNodes = tfsServer.CatalogNode.QueryChildren( new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None); var parallelOptions = new ParallelOptions() {MaxDegreeOfParallelism = 1}; Parallel.ForEach(teamProjectCollectionNodes, parallelOptions, teamProjectCollectionNode => { var taskBuidInfos = GetBuildInfoDtosPerTeamProject(teamProjectCollectionNode, tfsServer, sinceDateTime); taskBuidInfos.ConfigureAwait(false); taskBuidInfos.Wait(); lock (buildInfoDtos) { buildInfoDtos.AddRange(taskBuidInfos.Result); } }); } catch (Exception e) { LogService.WriteError(e); throw; } return buildInfoDtos; }
public List<BuildInfoDto> GetBuildInfoDtos() { var buildInfoDtos = new ConcurrentBag<BuildInfoDto>(); try { var tfsServer = _helperClass.GetTfsServer(); // Get the catalog of team project collections var teamProjectCollectionNodes = tfsServer.CatalogNode.QueryChildren( new[] { CatalogResourceTypes.ProjectCollection }, false, CatalogQueryOptions.None); var parallelOptions = new ParallelOptions {MaxDegreeOfParallelism = 1}; Parallel.ForEach(teamProjectCollectionNodes, parallelOptions, teamProjectCollectionNode => { var task = GetBuildInfoDtosPerTeamProject(teamProjectCollectionNode, tfsServer, DateTime.MinValue); task.ConfigureAwait(false); task.Wait(); var buildInfos = task.Result; foreach (var buildInfoDto in buildInfos) { buildInfoDtos.Add(buildInfoDto); } }); } catch (Exception e) { LogService.WriteError(e); throw; } return buildInfoDtos.ToList(); }
public override async Task ExecuteAsync() { // Create 100 Data objects var data = Enumerable.Range(1, 100).Select(i => new Data { Number = i }); // Option 1a: use Upsert with an IDictionary<string, object> of documents in upsert var bulkData = data.ToDictionary(d => "dotnetDevguideExample-" + d.Number); // Note: There is no UpsertAsync overload that takes multiple values (yet) // which is why this example wraps the synchronized method in a new Task. // If your code is fully synchronous, you can simply call _bucket.Upsert(...) var bulkResult = await Task.Run(() => _bucket.Upsert(bulkData)); var successCount = bulkResult.Where(r => r.Value.Success).Count(); Console.WriteLine("Upserted {0} values", bulkResult.Count); // Option 1b: Specify ParallelOptions to customize how the client parallelizes the upserts var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = 32 }; var bulkResult2 = await Task.Run(() => _bucket.Upsert(bulkData, parallelOptions)); successCount = bulkResult2.Where(r => r.Value.Success).Count(); Console.WriteLine("Upserted {0} values", successCount); // Option 2: Spawn multiple Upsert tasks and wait on for all to complete var bulkTasks = bulkData.Select(d => _bucket.UpsertAsync(d.Key, d.Value)); var bulkResults = await Task.WhenAll(bulkTasks); successCount = bulkResults.Where(r => r.Success).Count(); Console.WriteLine("Upserted {0} values", successCount); }
bool RunParallelAotCompiler(List <string> nativeLibs) { try { ThreadingTasks.ParallelOptions options = new ThreadingTasks.ParallelOptions { CancellationToken = Token, TaskScheduler = ThreadingTasks.TaskScheduler.Default, }; ThreadingTasks.Parallel.ForEach(GetAotConfigs(), options, config => { if (!config.Valid) { Cancel(); return; } if (!RunAotCompiler(config.AssembliesPath, config.AotCompiler, config.AotOptions, config.AssemblyPath)) { LogCodedError("XA3001", "Could not AOT the assembly: {0}", Path.GetFileName(config.AssemblyPath)); Cancel(); return; } lock (nativeLibs) nativeLibs.Add(config.OutputFile); } ); } catch (OperationCanceledException) { return(false); } return(true); }
public void Test_Timed_Execution_Parallel_Client() { var options = new ParallelOptions { MaxDegreeOfParallelism = 4 }; var n = 1000;//set to a higher # if needed using (var cluster = new Cluster("couchbaseClients/couchbase")) { using (var bucket = cluster.OpenBucket()) { using (new OperationTimer()) { var temp = bucket; Parallel.For(0, n, options, i => { var key = string.Format("key{0}", i); var value = (int?) i; var result = temp.Upsert(key, value); Assert.IsTrue(result.Success); var result1 = temp.Get<int?>(key); Assert.IsTrue(result1.Success); Assert.AreEqual(i, result1.Value); }); } } } }
private void ParseEntries(IEnumerable<FileInfo> files, LogEntry lastEntry, out long count) { count = 0; // Only allow as many parallel threads as the size of the connection pool. var options = new ParallelOptions { MaxDegreeOfParallelism = this.db.MaxConcurrentConnections }; var subCounts = new Dictionary<string, long>(); Parallel.ForEach(files, options, (file) => { long subCount; // Read entries from file and apply transformations. var entries = this.ParseEntries(file, this.transformations).Where(AllowInsert(lastEntry)); // Write entries to the database. this.db.Write(entries, out subCount); subCounts.Add(file.FullName, subCount); }); // Set count to sum of all entry counts per file. count = subCounts.Values.Sum(); }
public void ValidateRowKeysAnsiGetInstanceFromDenseAnsi() { DenseMatrix<string, string, double> denseMatObj = GetDenseMatrix(); ParallelOptions parOptObj = new ParallelOptions(); denseMatObj.WriteDenseAnsi(Constants.FastQTempTxtFileName, parOptObj); using (RowKeysAnsi rkaObj = RowKeysAnsi.GetInstanceFromDenseAnsi(Constants.FastQTempTxtFileName, parOptObj)) { Assert.AreEqual(denseMatObj.ColCount, rkaObj.ColCount); Assert.AreEqual(denseMatObj.RowCount, rkaObj.RowCount); Assert.AreEqual(denseMatObj.RowKeys.Count, rkaObj.RowKeys.Count); Assert.AreEqual(denseMatObj.ColKeys.Count, rkaObj.ColKeys.Count); } if (File.Exists(Constants.FastQTempTxtFileName)) File.Delete(Constants.FastQTempTxtFileName); ApplicationLog.WriteLine( "RowKeysAnsi BVT : Validation of GetInstanceFromDenseAnsi() method successful"); }
/// <summary> /// Initialize the experiment with configuration file parameters. /// </summary> /// <param name="name">The name of the experiment</param> /// <param name="xmlConfig">The parent XML configuration element</param> public virtual void Initialize(string name, XmlElement xmlConfig) { // Set all properties Name = name; DefaultPopulationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize"); Description = XmlUtils.GetValueAsString(xmlConfig, "Description"); // Set all internal class variables _activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation"); ComplexityRegulationStrategy = XmlUtils.TryGetValueAsString(xmlConfig, "ComplexityRegulationStrategy"); Complexitythreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold"); ParallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig); // Set evolution/genome parameters NeatEvolutionAlgorithmParameters = new NeatEvolutionAlgorithmParameters { SpecieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount"), InterspeciesMatingProportion = XmlUtils.GetValueAsDouble(xmlConfig, "InterspeciesMatingProbability"), MinTimeAlive = XmlUtils.GetValueAsInt(xmlConfig, "MinTimeAlive") }; NeatGenomeParameters = ExperimentUtils.ReadNeatGenomeParameters(xmlConfig); // Set experiment-specific parameters MaxTimesteps = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxTimesteps"); MinSuccessDistance = XmlUtils.TryGetValueAsInt(xmlConfig, "MinSuccessDistance"); MaxDistanceToTarget = XmlUtils.TryGetValueAsInt(xmlConfig, "MaxDistanceToTarget"); MazeVariant = MazeVariantUtl.convertStringToMazeVariant(XmlUtils.TryGetValueAsString(xmlConfig, "MazeVariant")); }
/// <summary>Executes a for loop in which iterations may run in parallel.</summary> /// <param name="fromInclusive">The start index, inclusive.</param> /// <param name="toExclusive">The end index, exclusive.</param> /// <param name="options">A System.Threading.Tasks.ParallelOptions instance that configures the behavior of this operation.</param> /// <param name="body">The delegate that is invoked once per iteration.</param> public static void For(BigInteger fromInclusive, BigInteger toExclusive, ParallelOptions options, Action<BigInteger> body) { // Determine how many iterations to run... var range = toExclusive - fromInclusive; // ... and run them. if (range <= 0) { // If there's nothing to do, bail return; } // Fast path else if (range <= Int64.MaxValue) { // If the range is within the realm of Int64, we'll delegate to Parallel.For's Int64 overloads. // Iterate from 0 to range, and then call the user-provided body with the scaled-back value. Parallel.For(0, (long)range, options, i => body(i + fromInclusive)); } // Slower path else { // For a range larger than Int64.MaxValue, we'll rely on an enumerable of BigInteger. // We create a C# iterator that yields all of the BigInteger values in the requested range // and then ForEach over that range. Parallel.ForEach(Range(fromInclusive, toExclusive), options, body); } }
private static void DownloadInParallel(IEnumerable<Show> showsToDownload) { var po = new ParallelOptions {MaxDegreeOfParallelism = MaxSimultaneousDownloads}; Parallel.ForEach(showsToDownload, po, show => { try { using (var httpClient = new HttpClient()) { var downloadStream = httpClient.GetStreamAsync(show.Mp3Uri).Result; var file = new FileInfo(_saveDirectory + string.Format(@"\Hanselminutes_{0}.mp3", show.Id)); using (downloadStream) using (var fileStream = file.Create()) { Console.WriteLine(string.Format("Downloading show {0}", show.Id)); downloadStream.CopyTo(fileStream); } Console.WriteLine(string.Format("Show {0} downloaded to {1}", show.Id, file)); } } catch (Exception e) { Console.Error.WriteLine(e); } }); }
public static void ParallelRun(params IModelSimulation[] simulations) { var parallelOptions = new ParallelOptions() { MaxDegreeOfParallelism = -1 }; Parallel.ForEach(simulations, parallelOptions, s => s.Execute() ); }
public virtual void Build(MetricDB db, int num_pairs, int maxCandidates = -1) { this.DB = db; this.Fingerprints = new BinQ8HammingSpace (1); this.Sample = new SampleSpace("", this.DB, num_pairs * 2); this.MaxCandidates = maxCandidates; var n = this.DB.Count; var A = new byte[n][]; int pc = this.DB.Count / 100 + 1; int advance = 0; var create_one = new Action<int> (delegate(int i) { var fp = this.GetFP(this.DB[i]); A[i] = fp; if (advance % pc == 0) { Console.WriteLine ("DEBUG {0} ({1}/{2}), db: {3}, num_pairs: {4}, timestamp: {5}", this, advance, n, db.Name, num_pairs, DateTime.Now); } advance++; }); ParallelOptions ops = new ParallelOptions(); ops.MaxDegreeOfParallelism = -1; Parallel.For (0, n, create_one); foreach (var fp in A) { this.Fingerprints.Add( fp ); } var s = new Sequential (); s.Build (this.Fingerprints); this.InternalIndex = s; }
/// <summary> /// Execute Download Action /// </summary> /// <param name="files">files to download</param> /// <returns>lis of files downloaded</returns> public List<string> Run(List<string> files) { List<string> downloadedFiles = new List<string>(); bool runNonMultitrhead = true; if (d.MultiThreadOption != null) { if (d.MultiThreadOption.enableMultithread) { runNonMultitrhead = false; ParallelOptions options = new ParallelOptions(); if (d.MultiThreadOption.setThreadMaxNumbers) options.MaxDegreeOfParallelism = d.MultiThreadOption.ThreadNumbers; //Run links multithread System.Threading.Tasks.Parallel.For(0, files.Count, options, ii => { downloadedFiles.Add(downloadFile(files[ii])); }); } } if (runNonMultitrhead) { foreach (string file in files) downloadedFiles.Add(downloadFile(file)); } return downloadedFiles; }
private static void DownloadProjectsFromGitHub(IEnumerable<Repository> searchRepositoryResult, string buildFolder) { var parallelOptions = new ParallelOptions {MaxDegreeOfParallelism = 1}; Parallel.ForEach(searchRepositoryResult, parallelOptions, r => { var archivePath = Path.Combine(buildFolder, r.Name + ".zip"); var destinationDirectoryName = Path.Combine(buildFolder, r.Name); if (!File.Exists(archivePath)) { var downloadUrl = r.HtmlUrl + "/archive/master.zip"; Console.WriteLine("Downloading from: {0}", downloadUrl); using (var client = new WebClient()) { client.DownloadFile(downloadUrl, archivePath); } } try { Console.WriteLine("Extracting to: {0}", destinationDirectoryName); ZipFile.ExtractToDirectory(archivePath, destinationDirectoryName); } catch (Exception e) { Console.WriteLine(e); Directory.Delete(destinationDirectoryName, true); } }); }
public void MaxDegreeOfParallelismPropertyBehavior() { var po = new ParallelOptions {MaxDegreeOfParallelism = 10}; Assert.That(po.MaxDegreeOfParallelism, Is.EqualTo(10)); po.MaxDegreeOfParallelism = 3; Assert.That(po.MaxDegreeOfParallelism, Is.EqualTo(3)); }
public override async Task ExecuteAsync() { // Call BulkInsert to generate some data await new BulkInsert().ExecuteAsync(); // Generate the keys to retrieve var keys = Enumerable.Range(1, 100).Select(i => "dotnetDevguideExample-" + i).ToList(); // Option 1a: use Get with a IList<string> of document keys to retrieve // Note: There is no GetAsync overload that takes multiple keys (yet) // which is why this example wraps the synchronized method in a new Task. // If your code is fully synchronous, you can simply call _bucket.Get(...) var bulkResult = await Task.Run(() => _bucket.Get<Data>(keys)); var successCount = bulkResult.Where(r => r.Value.Success).Count(); Console.WriteLine("Got {0} values", bulkResult.Count); // Option 1b: Specify ParallelOptions to customize how the client parallelizes the gets var parallelOptions = new ParallelOptions { MaxDegreeOfParallelism = 32 }; var bulkResult2 = await Task.Run(() => _bucket.Get<Data>(keys, parallelOptions)); successCount = bulkResult2.Where(r => r.Value.Success).Count(); Console.WriteLine("Got {0} values", successCount); // Option 2: Spawn multiple Upsert tasks and wait on for all to complete var bulkTasks = keys.Select(key => _bucket.GetAsync<Data>(key)); var bulkResults = await Task.WhenAll(bulkTasks); successCount = bulkResults.Where(r => r.Success).Count(); Console.WriteLine("Got {0} values", successCount); }
public void ValidateRowKeysPDGetInstanceFromPaddedDoubleFileAccess() { DenseMatrix<string, string, double> denseMatObj = GetDenseMatrix(); ParallelOptions parOptObj = new ParallelOptions(); denseMatObj.WritePaddedDouble(Constants.FastQTempTxtFileName, parOptObj); using (RowKeysPaddedDouble rkpdObj = RowKeysPaddedDouble.GetInstanceFromPaddedDouble( Constants.FastQTempTxtFileName, parOptObj, FileAccess.ReadWrite, FileShare.ReadWrite)) { Assert.AreEqual(denseMatObj.ColCount, rkpdObj.ColCount); Assert.AreEqual(denseMatObj.RowCount, rkpdObj.RowCount); Assert.AreEqual(denseMatObj.RowKeys.Count, rkpdObj.RowKeys.Count); Assert.AreEqual(denseMatObj.ColKeys.Count, rkpdObj.ColKeys.Count); } if (File.Exists(Constants.FastQTempTxtFileName)) File.Delete(Constants.FastQTempTxtFileName); ApplicationLog.WriteLine( "RowKeysPaddedDouble BVT : Validation of GetInstanceFromPaddedDouble(file-access) method successful"); }
public int ConvertAllSvgToIco(string folder, bool recursive, bool refresh, int[] sizes, int maxDegreeOfParallelism) { var resultCode = 0; var iconInfos = _iconInfoProvider.GetIconInfos(folder, recursive, sizes); var parallelOptions = new ParallelOptions() {MaxDegreeOfParallelism = maxDegreeOfParallelism}; Parallel.ForEach(iconInfos, parallelOptions, (iconInfo, state) => { try { var isupdated = ConvertSvgToPngs(iconInfo, sizes, refresh); var iconFileExists = iconInfo.IconFile.Exists; if (isupdated || !iconFileExists || refresh) { _imageMagicProvider.CreateIconFromPngFilesFromSvg(iconInfo); } else { _logger.Info("Icon up to date: " + iconInfo.IconFile.FullName); } } catch (Exception ex) { _logger.Error(ex.Message); } }); return resultCode; }
public virtual void Initialize(string name, XmlElement xmlConfig) { _name = name; _populationSize = XmlUtils.GetValueAsInt(xmlConfig, "PopulationSize"); _specieCount = XmlUtils.GetValueAsInt(xmlConfig, "SpecieCount"); _activationScheme = ExperimentUtils.CreateActivationScheme(xmlConfig, "Activation"); _complexityRegulationStr = XmlUtils.TryGetValueAsString(xmlConfig, "DefaultComplexityRegulationStrategy"); _complexityThreshold = XmlUtils.TryGetValueAsInt(xmlConfig, "ComplexityThreshold"); _description = XmlUtils.TryGetValueAsString(xmlConfig, "Description"); _parallelOptions = ExperimentUtils.ReadParallelOptions(xmlConfig); _eaParams = new NeatEvolutionAlgorithmParameters(); _eaParams.SpecieCount = _specieCount; _neatGenomeParams = new NeatGenomeParameters(); _neatGenomeParams.FeedforwardOnly = _activationScheme.AcyclicNetwork; DefaultComplexityRegulationStrategy = ExperimentUtils.CreateComplexityRegulationStrategy( _complexityRegulationStr, _complexityThreshold); DefaultSpeciationStrategy = new KMeansClusteringStrategy<NeatGenome>(new ManhattanDistanceMetric(1.0, 0.0, 10.0)); DefaultNeatEvolutionAlgorithm = new NeatEvolutionAlgorithm<NeatGenome>( NeatEvolutionAlgorithmParameters, DefaultSpeciationStrategy, DefaultComplexityRegulationStrategy); }
public void ValidateMatrixFactoryParse() { denseMatObj = GetDenseMatrix(); MatrixFactory<String, String, Double> mfObj = MatrixFactory<String, String, Double>.GetInstance(); ParallelOptions poObj = new ParallelOptions(); TryParseMatrixDelegate<string, string, double> a = new TryParseMatrixDelegate<string, string, double>(this.TryParseMatrix); mfObj.RegisterMatrixParser(a); // Writes the text file denseMatObj.WritePaddedDouble(Constants.FastQTempTxtFileName, poObj); Matrix<string, string, double> newMatObj = mfObj.Parse(Constants.FastQTempTxtFileName, double.NaN, poObj); Assert.AreEqual(denseMatObj.RowCount, newMatObj.RowCount); Assert.AreEqual(denseMatObj.RowKeys.Count, newMatObj.RowKeys.Count); Assert.AreEqual(denseMatObj.ColCount, newMatObj.ColCount); Assert.AreEqual(denseMatObj.ColKeys.Count, newMatObj.ColKeys.Count); Assert.AreEqual(denseMatObj.Values.Count(), newMatObj.Values.Count()); ApplicationLog.WriteLine( "MatrixFactory BVT : Successfully validated Parse() method"); }
public MarketStateCollection(string fixtureId, IUpdatableMarketStateCollection collection) : this(fixtureId) { if (collection == null) return; Sport = collection.Sport; // this is just for creating the nodes foreach (var mkt_id in collection.Markets) { _States[mkt_id] = null; } ParallelOptions options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }; // fill the nodes and as they are already created, there is no race-condition here Parallel.ForEach(collection.Markets, options, x => { _States[x] = ((IUpdatableMarketState)collection[x]).Clone(); } ); }
static void ParallerInsert(CouchbaseClient client, int n) { var options = new ParallelOptions { MaxDegreeOfParallelism = 4 }; Parallel.For(0, n, options, i => { var key = "key" + i; var value = "value" + i; var result = client.ExecuteStore(StoreMode.Set, key, value); if (result.Success) { Console.WriteLine("Write Key: {0} - Value: {1}", key, value); var result2 = client.ExecuteGet<string>(key); if (result2.Success) { Console.WriteLine("Read Key: {0} - Value: {1}", key, result2.Value); } else { Console.WriteLine("Read Error: {0} - {1}", key, result.Message); } } else { Console.WriteLine("Write Error: {0} - {1}", key, result.Message); } }); }
private void Form1_DragDrop(object sender, DragEventArgs e) { string[] files = (string[])e.Data.GetData(DataFormats.FileDrop); if (Path.GetExtension(files[0]).ToUpper() == ".WIL" || Path.GetExtension(files[0]).ToUpper() == ".WZL" || Path.GetExtension(files[0]).ToUpper() == ".MIZ") { try { ParallelOptions options = new ParallelOptions { MaxDegreeOfParallelism = 8 }; Parallel.For(0, files.Length, options, i => { if (Path.GetExtension(files[i]) == ".wtl") { WTLLibrary WTLlib = new WTLLibrary(files[i]); WTLlib.ToMLibrary(); } else { WeMadeLibrary WILlib = new WeMadeLibrary(files[i]); WILlib.ToMLibrary(); } toolStripProgressBar.Value++; }); } catch (Exception ex) { MessageBox.Show(ex.ToString()); } toolStripProgressBar.Value = 0; MessageBox.Show( string.Format("Successfully converted {0} {1}", (OpenWeMadeDialog.FileNames.Length).ToString(), (OpenWeMadeDialog.FileNames.Length > 1) ? "libraries" : "library")); } else if (Path.GetExtension(files[0]).ToUpper() == ".LIB") { ClearInterface(); ImageList.Images.Clear(); PreviewListView.Items.Clear(); _indexList.Clear(); if (_library != null) _library.Close(); _library = new MLibraryV2(files[0]); PreviewListView.VirtualListSize = _library.Images.Count; PreviewListView.RedrawItems(0, PreviewListView.Items.Count - 1, true); // Show .Lib path in application title. this.Text = files[0].ToString(); } else { return; } }
/// <summary>Repeatedly executes an operation in parallel while the specified condition evaluates to true.</summary> /// <param name="parallelOptions">A ParallelOptions instance that configures the behavior of this operation.</param> /// <param name="condition">The condition to evaluate.</param> /// <param name="body">The loop body.</param> public static void ParallelWhile( ParallelOptions parallelOptions, Func<bool> condition, Action body) { if (parallelOptions == null) throw new ArgumentNullException("parallelOptions"); if (condition == null) throw new ArgumentNullException("condition"); if (body == null) throw new ArgumentNullException("body"); Parallel.ForEach(SingleItemPartitioner.Create(IterateUntilFalse(condition)), parallelOptions, ignored => body()); }
void DoExecute() { LoadResourceCaseMap(); ThreadingTasks.ParallelOptions options = new ThreadingTasks.ParallelOptions { CancellationToken = Token, TaskScheduler = ThreadingTasks.TaskScheduler.Default, }; ThreadingTasks.Parallel.ForEach(ResourceDirectories, options, ProcessDirectory); }
void DoExecute() { LoadResourceCaseMap(); assemblyMap.Load(Path.Combine(WorkingDirectory, AssemblyIdentityMapFile)); ThreadingTasks.ParallelOptions options = new ThreadingTasks.ParallelOptions { CancellationToken = Token, TaskScheduler = ThreadingTasks.TaskScheduler.Default, }; ThreadingTasks.Parallel.ForEach(ManifestFiles, options, ProcessManifest); }
/// <summary> /// Executes a while loop in parallel. /// </summary> /// <param name="parallelOptions">Parallel options.</param> /// <param name="condition">Condition function. Returns true if the loop should advance, false otherwise.</param> /// <param name="body">Body function.</param> public static void While(System.Threading.Tasks.ParallelOptions parallelOptions, Func <bool> condition, Action <ParallelLoopState> body) { System.Threading.Tasks.Parallel.ForEach(new InfinitePartitioner(), parallelOptions, (ignored, loopState) => { if (condition()) { body(loopState); } else { loopState.Stop(); } }); }
void DoExecute() { if (ResourceNameCaseMap != null) { foreach (var arr in ResourceNameCaseMap.Split(';').Select(l => l.Split('|')).Where(a => a.Length == 2)) { resource_name_case_map [arr [1]] = arr [0]; // lowercase -> original } } assemblyMap.Load(Path.Combine(WorkingDirectory, AssemblyIdentityMapFile)); ThreadingTasks.ParallelOptions options = new ThreadingTasks.ParallelOptions { CancellationToken = Token, TaskScheduler = ThreadingTasks.TaskScheduler.Default, }; ThreadingTasks.Parallel.ForEach(ManifestFiles, options, ProcessManifest); }
public override bool Execute() { Log.LogDebugMessage("Aapt Task"); Log.LogDebugMessage(" AssetDirectory: {0}", AssetDirectory); Log.LogDebugTaskItems(" ManifestFiles: ", ManifestFiles); Log.LogDebugMessage(" ResourceDirectory: {0}", ResourceDirectory); Log.LogDebugMessage(" JavaDesignerOutputDirectory: {0}", JavaDesignerOutputDirectory); Log.LogDebugMessage(" PackageName: {0}", PackageName); Log.LogDebugMessage(" UncompressedFileExtensions: {0}", UncompressedFileExtensions); Log.LogDebugMessage(" ExtraPackages: {0}", ExtraPackages); Log.LogDebugTaskItems(" AdditionalResourceDirectories: ", AdditionalResourceDirectories); Log.LogDebugTaskItems(" AdditionalAndroidResourcePaths: ", AdditionalAndroidResourcePaths); Log.LogDebugTaskItems(" LibraryProjectJars: ", LibraryProjectJars); Log.LogDebugMessage(" ExtraArgs: {0}", ExtraArgs); Log.LogDebugMessage(" CreatePackagePerAbi: {0}", CreatePackagePerAbi); Log.LogDebugMessage(" ResourceNameCaseMap: {0}", ResourceNameCaseMap); Log.LogDebugMessage(" VersionCodePattern: {0}", VersionCodePattern); Log.LogDebugMessage(" VersionCodeProperties: {0}", VersionCodeProperties); if (CreatePackagePerAbi) { Log.LogDebugMessage(" SupportedAbis: {0}", SupportedAbis); } if (ResourceNameCaseMap != null) { foreach (var arr in ResourceNameCaseMap.Split(';').Select(l => l.Split('|')).Where(a => a.Length == 2)) { resource_name_case_map [arr [1]] = arr [0]; // lowercase -> original } } assemblyMap.Load(AssemblyIdentityMapFile); ThreadingTasks.ParallelOptions options = new ThreadingTasks.ParallelOptions { CancellationToken = Token, TaskScheduler = ThreadingTasks.TaskScheduler.Current, }; ThreadingTasks.Parallel.ForEach(ManifestFiles, options, () => 0, DoExecute, (obj) => { Complete(); }); base.Execute(); return(!Log.HasLoggedErrors); }
bool RunParallelAotCompiler(List <string> nativeLibs) { CancellationTokenSource cts = null; try { cts = new CancellationTokenSource(); ThreadingTasks.ParallelOptions options = new ThreadingTasks.ParallelOptions { CancellationToken = cts.Token, TaskScheduler = ThreadingTasks.TaskScheduler.Current, }; ThreadingTasks.Parallel.ForEach(GetAotConfigs(), options, config => { if (!config.Valid) { cts.Cancel(); return; } if (!RunAotCompiler(config.AssembliesPath, config.AotCompiler, config.AotOptions, config.AssemblyPath, cts.Token)) { LogCodedError("XA3001", "Could not AOT the assembly: {0}", Path.GetFileName(config.AssemblyPath)); cts.Cancel(); return; } lock (nativeLibs) nativeLibs.Add(config.OutputFile); } ); } catch (OperationCanceledException) { return(false); } finally { if (cts != null) { cts.Dispose(); } } return(true); }
public override bool Execute() { LogDebugMessage("Crunch Task"); LogDebugTaskItems(" SourceFiles:", SourceFiles); // copy the changed files over to a temp location for processing var imageFiles = SourceFiles.Where(x => string.Equals(Path.GetExtension(x.ItemSpec), ".png", StringComparison.OrdinalIgnoreCase)); if (!imageFiles.Any()) { return(true); } ThreadingTasks.ParallelOptions options = new ThreadingTasks.ParallelOptions { CancellationToken = Token, TaskScheduler = ThreadingTasks.TaskScheduler.Current, }; var imageGroups = imageFiles.GroupBy(x => Path.GetDirectoryName(Path.GetFullPath(x.ItemSpec))); ThreadingTasks.Parallel.ForEach(imageGroups, options, () => 0, DoExecute, (obj) => { Complete(); }); return(!Log.HasLoggedErrors); }
public static Result Decide(Matrix aProposition, int aSecondsTimeout) { string lPositiveInput; string lNegativeInput; try { lPositiveInput = aProposition.Prover9Input; lNegativeInput = Factory.Not(aProposition).Prover9Input; } catch (EngineException lException) { if (lException.Message.Contains("modal")) { return(Result.NoDecision); } else { throw lException; } } bool lPositiveCounterexampleFound = false; bool lNegativeCounterexampleFound = false; bool lFoundThatPropositionIsNecessary = false; bool lFoundThatPropositionIsImpossible = false; // Time out value for the cancellation tokens. -1 signifies no time out. int aMillisecondsTimeout = aSecondsTimeout >= 0 ? aSecondsTimeout * 1000 : -1; // Time out argument for prover9 and mace4. Leave blank if the time out is negative. string aTimeoutArgument = aSecondsTimeout >= 0 ? string.Format("-t {0}", aSecondsTimeout) : ""; CancellationTokenSource lPositiveCaseTokenSource = new System.Threading.CancellationTokenSource(aMillisecondsTimeout); CancellationTokenSource lNegativeCaseTokenSource = new System.Threading.CancellationTokenSource(aMillisecondsTimeout); ParallelOptions lParallelOptions = new System.Threading.Tasks.ParallelOptions(); lParallelOptions.MaxDegreeOfParallelism = System.Environment.ProcessorCount; Parallel.Invoke( lParallelOptions, // Try to prove that the proposition is necessary. BackgroundProcesses.ExcuteUntilExitOrCancellation( lPositiveCaseTokenSource.Token, new ShellParameters(prover9, aTimeoutArgument, lPositiveInput), // If the proposition is proven, set a flag and cancel all other operations. (fOutput) => { if (TheoremProved.IsMatch(fOutput)) { lFoundThatPropositionIsNecessary = true; lPositiveCaseTokenSource.Cancel(); lNegativeCaseTokenSource.Cancel(); } }), // Try to prove that the proposition is impossible. BackgroundProcesses.ExcuteUntilExitOrCancellation( lNegativeCaseTokenSource.Token, new ShellParameters(prover9, aTimeoutArgument, lNegativeInput), // If the negation of the proposition is proven, set a flag and cancel all other operations. (fOutput) => { if (TheoremProved.IsMatch(fOutput)) { lFoundThatPropositionIsImpossible = true; lPositiveCaseTokenSource.Cancel(); lNegativeCaseTokenSource.Cancel(); } }), // Try to find a counterexample for the proposition. BackgroundProcesses.ExcuteUntilExitOrCancellation( lPositiveCaseTokenSource.Token, new ShellParameters(mace4, aTimeoutArgument, lPositiveInput), // If a counterexample is found for the positive case, // set a flag and cancel the attempt to prove that the proposition is necessary. (fOutput) => { if (CounterexampleFound.IsMatch(fOutput)) { lPositiveCounterexampleFound = true; lPositiveCaseTokenSource.Cancel(); } }), // Try to find a counterexample to the negative case. BackgroundProcesses.ExcuteUntilExitOrCancellation( lNegativeCaseTokenSource.Token, new ShellParameters(mace4, aTimeoutArgument, lNegativeInput), // If a counterexample is found for the negative case, // set a flag and cancel the attempt to prove that the proposition is impossible. (fOutput) => { if (CounterexampleFound.IsMatch(fOutput)) { lNegativeCounterexampleFound = true; lNegativeCaseTokenSource.Cancel(); } }) ); if (lPositiveCounterexampleFound && lFoundThatPropositionIsNecessary) { throw new EngineException("Inconsistent result!"); } if (lNegativeCounterexampleFound && lFoundThatPropositionIsImpossible) { throw new EngineException("Inconsistent result!"); } if (lFoundThatPropositionIsNecessary && lFoundThatPropositionIsImpossible) { throw new EngineException("Inconsistent result!"); } if (lFoundThatPropositionIsNecessary) { return(Result.Necessary); } if (lFoundThatPropositionIsImpossible) { return(Result.Impossible); } if (lPositiveCounterexampleFound && lNegativeCounterexampleFound) { return(Result.Contingent); } if (lPositiveCounterexampleFound) { return(Result.Unnecessary); } if (lNegativeCounterexampleFound) { return(Result.Possible); } return(Result.NoDecision); }
private TaskReplicator(ParallelOptions options, bool stopOnFirstFailure) { _scheduler = options.TaskScheduler ?? TaskScheduler.Current; _stopOnFirstFailure = stopOnFirstFailure; }
bool Generate(BindingGenerator generator) { var layoutGroups = new Dictionary <string, LayoutGroup> (StringComparer.Ordinal); string layoutGroupName; LayoutGroup group; foreach (ITaskItem item in ResourceFiles) { if (item == null) { continue; } if (!GetRequiredMetadata(item, CalculateLayoutCodeBehind.LayoutGroupMetadata, out layoutGroupName)) { return(true); // We need Complete() to be called by Execute above } if (!layoutGroups.TryGetValue(layoutGroupName, out group) || group == null) { group = new LayoutGroup { Items = new List <ITaskItem> () }; layoutGroups [layoutGroupName] = group; } group.Items.Add(item); } if (PartialClassFiles != null && PartialClassFiles.Length > 0) { foreach (ITaskItem item in PartialClassFiles) { if (!GetRequiredMetadata(item, CalculateLayoutCodeBehind.LayoutGroupMetadata, out layoutGroupName)) { return(true); } if (!layoutGroups.TryGetValue(layoutGroupName, out group) || group == null) { Log.LogError($"Partial class item without associated binding for layout group '{layoutGroupName}'"); return(true); } string partialClassName; if (!GetRequiredMetadata(item, CalculateLayoutCodeBehind.PartialCodeBehindClassNameMetadata, out partialClassName)) { return(true); } string outputFileName; if (!GetRequiredMetadata(item, CalculateLayoutCodeBehind.LayoutPartialClassFileNameMetadata, out outputFileName)) { return(true); } if (group.Classes == null) { group.Classes = new List <PartialClass> (); } if (group.ClassNames == null) { group.ClassNames = new HashSet <string> (); } if (group.ClassNames.Contains(partialClassName)) { continue; } string shortName; string namespaceName; int idx = partialClassName.LastIndexOf('.'); if (idx >= 0) { shortName = partialClassName.Substring(idx + 1); namespaceName = partialClassName.Substring(0, idx); } else { shortName = partialClassName; namespaceName = null; } group.Classes.Add(new PartialClass { Name = shortName, Namespace = namespaceName, OutputFilePath = Path.Combine(MonoAndroidCodeBehindDir, outputFileName) }); group.ClassNames.Add(partialClassName); } } IEnumerable <string> generatedFilePaths = null; bool needComplete = false; if (ResourceFiles.Length >= CalculateLayoutCodeBehind.ParallelGenerationThreshold) { // NOTE: Update the tests in $TOP_DIR/tests/CodeBehind/UnitTests/BuildTests.cs if this message // is changed! Log.LogDebugMessage($"Generating binding code in parallel (threshold of {CalculateLayoutCodeBehind.ParallelGenerationThreshold} layouts met)"); var fileSet = new ConcurrentBag <string> (); TPL.ParallelOptions options = new TPL.ParallelOptions { CancellationToken = Token, TaskScheduler = TPL.TaskScheduler.Default, }; TPL.Task.Factory.StartNew( () => TPL.Parallel.ForEach(layoutGroups, options, kvp => GenerateSourceForLayoutGroup(generator, kvp.Value, rpath => fileSet.Add(rpath))), Token, TPL.TaskCreationOptions.None, TPL.TaskScheduler.Default ).ContinueWith(t => Complete()); generatedFilePaths = fileSet; } else { var fileSet = new List <string> (); foreach (var kvp in layoutGroups) { GenerateSourceForLayoutGroup(generator, kvp.Value, rpath => fileSet.Add(rpath)); } generatedFilePaths = fileSet; needComplete = true; } GeneratedFiles = generatedFilePaths.Where(gfp => !String.IsNullOrEmpty(gfp)).Select(gfp => new TaskItem(gfp)).ToArray(); if (GeneratedFiles.Length == 0) { Log.LogWarning("No layout binding source files generated"); } Log.LogDebugTaskItems(" GeneratedFiles:", GeneratedFiles); return(needComplete); }
public override bool Execute() { Log.LogDebugMessage("CalculateLayoutCodeBehind Task"); Log.LogDebugMessage($" OutputLanguage: {OutputLanguage}"); Log.LogDebugMessage($" OutputFileExtension: {OutputFileExtension}"); Log.LogDebugMessage($" BaseNamespace: {BaseNamespace}"); Log.LogDebugMessage($" BindingDependenciesCacheFile: {BindingDependenciesCacheFile}"); Log.LogDebugTaskItems(" BoundLayouts:", BoundLayouts); widgetWithId = XPathExpression.Compile("//*[@android:id and string-length(@android:id) != 0] | //include[not(@android:id)]"); GenerateLayoutBindings.BindingGeneratorLanguage gen; if (!GenerateLayoutBindings.KnownBindingGenerators.TryGetValue(OutputLanguage, out gen) || gen == null) { Log.LogDebugMessage($"Language {OutputLanguage} isn't supported, will use {GenerateLayoutBindings.DefaultOutputGenerator.Name} instead"); sourceFileExtension = GenerateLayoutBindings.DefaultOutputGenerator.Extension; } else { sourceFileExtension = OutputFileExtension; } string partialClassNames = null; var layoutsByName = new Dictionary <string, LayoutGroup> (StringComparer.OrdinalIgnoreCase); foreach (ITaskItem item in BoundLayouts) { if (item == null) { continue; } AddLayoutFile(item, ref layoutsByName); } var layoutBindingFiles = new List <ITaskItem> (); var layoutPartialClassFiles = new List <ITaskItem> (); if (layoutsByName.Count >= ParallelGenerationThreshold) { // NOTE: Update the tests in $TOP_DIR/tests/CodeBehind/UnitTests/BuildTests.cs if this message // is changed! Log.LogDebugMessage($"Parsing layouts in parallel (threshold of {ParallelGenerationThreshold} layouts met)"); var cts = new CancellationTokenSource(); TPL.ParallelOptions options = new TPL.ParallelOptions { CancellationToken = cts.Token, TaskScheduler = TPL.TaskScheduler.Default, }; TPL.Task.Factory.StartNew( () => TPL.Parallel.ForEach(layoutsByName, options, kvp => ParseAndLoadGroup(layoutsByName, kvp.Key, kvp.Value.InputItems, ref kvp.Value.LayoutBindingItems, ref kvp.Value.LayoutPartialClassItems)), cts.Token, TPL.TaskCreationOptions.None, TPL.TaskScheduler.Default ).ContinueWith(t => Complete()); base.Execute(); foreach (var kvp in layoutsByName) { LayoutGroup group = kvp.Value; if (group == null) { continue; } if (group.LayoutBindingItems != null && group.LayoutBindingItems.Count > 0) { layoutBindingFiles.AddRange(group.LayoutBindingItems); } if (group.LayoutPartialClassItems != null && group.LayoutPartialClassItems.Count > 0) { layoutPartialClassFiles.AddRange(group.LayoutPartialClassItems); } } } else { foreach (var kvp in layoutsByName) { ParseAndLoadGroup(layoutsByName, kvp.Key, kvp.Value.InputItems, ref layoutBindingFiles, ref layoutPartialClassFiles); } Complete(); } LayoutBindingFiles = layoutBindingFiles.ToArray(); if (LayoutBindingFiles.Length == 0) { Log.LogDebugMessage(" No layout file qualifies for code-behind generation"); } LayoutPartialClassFiles = layoutPartialClassFiles.ToArray(); Log.LogDebugTaskItems(" LayoutBindingFiles:", LayoutBindingFiles, true); Log.LogDebugTaskItems(" LayoutPartialClassFiles:", LayoutPartialClassFiles, true); return(!Log.HasLoggedErrors); }