237 packages tagged with “parallel”
TPL Dataflow promotes actor/agent-oriented designs through primitives for in-process message passing, dataflow, and pipelining. TDF builds upon the APIs and scheduling infrastructure provided by the Task Parallel Library (TPL), and integrates with the language support for asynchrony provided by C#, Visual Basic, and F#. Supported Platforms: - .NET Framework 4.5 - Windows 8 - Windows Phone 8.1 - Windows Phone Silverlight 8 - Portable Class Libraries
Introduces IAsyncEnumerable, IAsyncEnumerator, ForEachAsync(), and ParallelForEachAsync() GitHub: https://github.com/Dasync/AsyncEnumerable PROBLEM SPACE Helps to (a) create an element provider, where producing an element can take a lot of time due to dependency on other asynchronous events (e.g. wait handles, network streams), and (b) a consumer that processes those element as soon as they are ready without blocking the thread (the processing is scheduled on a worker thread instead). EXAMPLE using Dasync.Collections; static IAsyncEnumerable<int> ProduceAsyncNumbers(int start, int end) { return new AsyncEnumerable<int>(async yield => { // Just to show that ReturnAsync can be used multiple times await yield.ReturnAsync(start); for (int number = start + 1; number <= end; number++) await yield.ReturnAsync(number); // You can break the enumeration loop with the following call: yield.Break(); // This won't be executed due to the loop break above await yield.ReturnAsync(12345); }); } // Just to compare with synchronous version of enumerator static IEnumerable<int> ProduceNumbers(int start, int end) { yield return start; for (int number = start + 1; number <= end; number++) yield return number; yield break; yield return 12345; } static async Task ConsumeNumbersAsync() { var asyncEnumerableCollection = ProduceAsyncNumbers(start: 1, end: 10); await asyncEnumerableCollection.ForEachAsync(async number => { await Console.Out.WriteLineAsync($"{number}"); }); } // Just to compare with synchronous version of enumeration static void ConsumeNumbers() { var enumerableCollection = ProduceNumbers(start: 1, end: 10); foreach (var number in enumerableCollection) { Console.Out.WriteLine($"{number}"); } }
This package includes high performance .NET helpers such as: - Memory2D<T> and Span2D<T>: two types providing fast and allocation-free abstraction over 2D memory areas. - ArrayPoolBufferWriter<T>: an IBufferWriter<T> implementation using pooled arrays, which also supports IMemoryOwner<T>. - MemoryBufferWriter<T>: an IBufferWriter<T>: implementation that can wrap external Memory<T>: instances. - MemoryOwner<T>: an IMemoryOwner<T> implementation with an embedded length and a fast Span<T> accessor. - SpanOwner<T>: a stack-only type with the ability to rent a buffer of a specified length and getting a Span<T> from it. - StringPool: a configurable pool for string instances that be used to minimize allocations when creating multiple strings from char buffers. - String, array, Memory<T>, Span<T> extensions and more, all focused on high performance. - HashCode<T>: a SIMD-enabled extension of HashCode to quickly process sequences of values. - BitHelper: a class with helper methods to perform bit operations on numeric types. - ParallelHelper: helpers to work with parallel code in a highly optimized manner. - Box<T>: a type mapping boxed value types and exposing some utility and high performance methods. - Ref<T>: a stack-only struct that can store a reference to a value of a specified type. - NullableRef<T>: a stack-only struct similar to Ref<T>, which also supports nullable references.
Create and compose complex asynchronous behavior in .Net.
A collection of basic extensions on the common BCL System.Threading namespace.
Provides an F#-style API for parallel operations on sequences that are part in .NET 4.0 as System.Linq.ParallelEnumerable class. The API is akin to F# operations on sequences.
Adds a concept of thread safety to C# and VB so that most threading defects are detected at build-time or in a single-threaded test coverage. Includes a deadlock detection policy and thread dispatching aspects. An official PostSharp pattern library.
This class library provides a plethora of interesting and useful extensions to take advantage of and complement the functionality available in the .NET Framework 4 for parallel programming. Some (not all) features of this package are included in newer versions of .NET. See https://stackoverflow.com/q/37494157/328397
The package includes: * Task<T> for executing asynchronous operations. * Concurrent Collections such as ConcurrentStack, ConcurentQueue ad ConcurrentDictionary. * PLINQ for writing parallel queries. * additional Threading operations such as Barrier,SpinLock and SpinWait.
Provides additional Linq collection APIs that can classify elements and select values in parallel.
A Blazor utility library assisting with asynchronous module loading
Easy to use SIMD accelerated span and array methods Now each method in SimdOps is generic, instead of SimdOps<T>, i.e SimdOps.Abs<T>() instead of SimdOps<T>.Abs().
The 'async8' library is a utility package designed to simplify asynchronous programming in .NET applications. It offers a comprehensive set of tools, including extension methods for Task-based operations, concurrent task management helpers, async-enabled caching, and robust retry policies. These features help developers write clean, efficient, and maintainable asynchronous code, reducing complexity while improving scalability and performance.
Redistributable components for package 'PostSharp.Patterns.Threading'. This package should only be installed as a dependency. (This is not the package you are looking for).
Wintellect's own Jeffrey Richter has produced the Power Threading library (DLL) containing many classes to help with threading and asynchronous programming. There are versions of the library for the .NET Framework, Silverlight, and the .NET Compact Framework. Jeffrey has described many of the classes contained in the library by way of his MSDN Magazine Concurrent Affairs columns. The library also contains some non-threading related classes for working with exceptions, command-line parsing, and more. When you download it, please read the enclosed End User License Agreement (EULA) before using the library in your own projects. For limited support, questions, and comments, Jeffrey Richter has set up a Yahoo new group: Group link: http://tech.groups.yahoo.com/group/PowerThreading/ Post message: PowerThreading@YahooGroups.com Subscribe: PowerThreading-subscribe@YahooGroups.com Unsubscribe: PowerThreading-unsubscribe@YahooGroups.com To purchase extended support, please contact Wintellect.
A .NET utility library for running async methods in parallel batches
Useful extensions contribution by Bnaya Eshet Blog: http://blogs.microsoft.co.il/bnaya/ Source Code: https://github.com/bnayae/Bnaya.CSharp.AsyncExtensions # NuGet this library available on NuGet via Install-Package Bnaya.CSharp.AsyncExtensions ## This library have the following goodies: * Exception Handling * ThrowAll (produce AggregateException when waiting on Task.WhenAll) * Format (format async exception into friendlier call-stack representation) * Timeout (will apply timeout semantic for any Task) * WithTimeout (will throw on timeout) * IsTimeoutAsync (will return indication without throwing, ideal for SLA checks [practice: check and produce warning]) * Cancellation * CancelSafe (will run the CancellationTokenSource.Cancel within try catch and prevent unexpected side effect which can happen when cancellation token registration throw) * Friendly async locking facilities (which can replace the classical lock statement). * Extensions * TryAcquireAsync * AcquireAsync * Instance-able * AsyncLock * WhenN: use to complete task after n task succeed THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
CsCheck is a C# random testing library inspired by QuickCheck. It differs in that generation and shrinking are both based on PCG, a fast random number generator. This gives the following advantages: - Automatic shrinking. Gen classes are composable with no need for Arb classes. So less boilerplate. - Random testing and shrinking are parallelized. This and PCG make it very fast. - Shrunk cases have a seed value. Simpler examples can easily be reproduced. - Shrinking can be continued later to give simpler cases for high dimensional problems. - Parallel testing and random shrinking work well together. CsCheck also makes parallel, performance and regression testing simple and fast.
Parallel Extensions for the .NET Framework and .NET Standard. For examples of how to use this library, please visit https://devblogs.microsoft.com/pfxteam/tag/parallelextensionsextras/
Provides types, classes and methods that provide .NET bindings to OpenCL
ILGPU Algorithms library for high-level GPU programming. Samples can be found in the GitHub repository: https://github.com/m4rs-mt/ILGPU/tree/master/Samples
Generic performance testing library for executing load-tests written in .NET c# Visit project website for examples.
Similar to Task.WhenAll but allows you to limit the number of tasks in flight (max concurrency).
PNUnit provides a way to test applications composed of distributed, communicating components. It was developed by the folks at Codice Software for their internal use and contributed to NUnit. Note that pNUnit is not intended for running tests in parallel simply to make them run faster. It requires careful setup of each parallel test using an XML description of the individual cooperating tests. This package includes only the pNUnit framework assembly, which is referenced by your tests. Executing the tests requires using the pNUnit launcher, which is distributed as part of the NUnit.Runners package.
fszmq is an MPLv2-licensed F# binding for the ZeroMQ distributed computing library. This library is primarily designed to be consumed from F#. However, where possible, the library has been designed to appear "friendly" when consumed by other .NET languages (C#, et aliam). NOTE: This package **ONLY** provides the managed `fszmq.dll` file. **You** need to provide the appropriate native `libzmq` file.
Utilities for concurrent message processing with configurable degree of parallelism, and per-partition ordering
Helpers for asynchronous programming
Parallel high performance cross-platform C#/.NET algorithms. 30+ algorithms with familiar interfaces and examples. Multi-core and data parallel (SIMD/SSE). Open source and free. See project Readme, blog, and videos...
Transformerizer: Parallel transform library for .NET
A WebDriver that distributes commands to multiple drivers in parallel.