Found 79 packages
Implementation of a lock-free dictionary on .Net Included types: === NonBlocking.ConcurrentDictionary Lock-free, wait-free implementation of a dictionary. - has the same API as System.Collections.Concurrent.ConcurrentDictionary. - No locks are taken during any operation including Get, Add, Remove, internal resizes etc... - While multiple threads accessing NonBlocking dictionary will help each other in operations such as table resizing, there is no dependency on such behavior. If any thread get unscheduled or delayed for whatever reason, other threads will be able to make progress independently. - NonBlocking dictionary scales linearly with the number of active threads if hardware permits. On most operations NonBlocking dictionary is faster than Concurrent, especially in write-heavy scenarios. Core algorithms are based on NonBlockingHashMap, written and released to the public domain by Dr. Cliff Click. A good overview could be found here: https://www.youtube.com/watch?v=HJ-719EGIts === Counter32 === Counter64 Low-overhead scalable counters.
Provides several thread-safe collection classes that should be used in place of the corresponding types in the System.Collections.NonGeneric and System.Collections packages whenever multiple threads are accessing the collection concurrently. Commonly Used Types: System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue> System.Collections.Concurrent.ConcurrentQueue<T> System.Collections.Concurrent.ConcurrentBag<T> System.Collections.Concurrent.BlockingCollection<T> System.Collections.Concurrent.ConcurrentStack<T> When using NuGet 3.x this package requires at least version 3.4.
Docker.DotNet is a library that allows you to interact with the Docker Remote API programmatically with fully asynchronous, non-blocking and object-oriented code in your .NET applications.
A .NET client for the Docker Engine API with fully asynchronous, non-blocking, object-oriented APIs.
Serilog sink that writes to console with high-performance non-blocking output.
3 Easy Steps: (1) Link to toastr.css (2) Link to toastr.js (3) Use toastr to display a toast for info, success, warning or error // Display an info toast with no title toastr.info('Are you the 6 fingered man?') *** For other API calls, see the demo
Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient. Node.js' package ecosystem, npm, is the largest ecosystem of open source libraries in the world.
Implementation of a lock-free dictionary on .Net This fork contain the following changes: - Non-snapshotting Keys and Values properties (Azure Gem) - Attempt at reducing GC pressure (Azure Gem, TODO: Measure effectiveness, seems to be minimal-to-nonexistent-to-imaginary, YMMV) - NonBlockingHashset wrapper (Azure Gem, TODO: Implement a proper one instead of a wrapper) - Capacity getter property (Azure Gem) - Capacity is not doubled on construction (Azure Gem) - Clear with capacity (Azure Gem) - EstimatedCount getter property (Azure Gem) - Removal of the hash mixer (Idea from https://github.com/VSadov/NonBlocking/issues/20#issuecomment-1545057207) - Rename everything from "Concurrent" to "Nonblocking" (Azure Gem) Some changes are specific to my use case. Included types: === NonBlocking.NonBlockingDictionary Lock-free, wait-free implementation of a dictionary. - has the same API as System.Collections.Concurrent.ConcurrentDictionary. - No locks are taken during any operation including Get, Add, Remove, internal resizes etc... - While multiple threads accessing NonBlocking dictionary will help each other in operations such as table resizing, there is no dependency on such behavior. If any thread get unscheduled or delayed for whatever reason, other threads will be able to make progress independently. - NonBlocking dictionary scales linearly with the number of active threads if hardware permits. On most operations NonBlocking dictionary is faster than Concurrent, especially in write-heavy scenarios. Core algorithms are based on NonBlockingHashMap, written and released to the public domain by Dr. Cliff Click. A good overview could be found here: https://www.youtube.com/watch?v=HJ-719EGIts === NonBlocking.NonBlockingHashSet Lock-free, wait-free implementation of a hashset based on NonBlockingDictionary. - No locks are taken during any operation including Get, Add, Remove, internal resizes etc... - While multiple threads accessing NonBlocking dictionary will help each other in operations such as table resizing, there is no dependency on such behavior. If any thread get unscheduled or delayed for whatever reason, other threads will be able to make progress independently. - NonBlocking dictionary scales linearly with the number of active threads if hardware permits. === Counter32 === Counter64 Low-overhead scalable counters. === Disclaimer I, Azure Gem, do not intend to maintain this fork.
A high-performance async/non-blocking redis client components for dotnet core,default support json and protobuf data format
AngularJS Toaster is a customized version of "toastr" non-blocking notification javascript library.
.NET for Android and MAUI bindings for the Android Java library 'org.reactivestreams:reactive-streams'. Library description: A Protocol for Asynchronous Non-Blocking Data Sequence
Docker.DotNet is a library that allows you to interact with the Docker Registry API V2 programmatically with fully asynchronous, non-blocking and object-oriented code in your .NET applications.
Portable .NET client for InfluxDB. It is fully asynchronous and non-blocking way to interact with InfluxDB programmatically.
Thread-safe, non-blocking, managed pool of re-usable resources, with a specified minimum and optional maximum number of resources, and optional expiry time for resources to be cleaned up if not used for a time.
Non-blocking, fast and lightweight async/await-able lock
Docker.Registry.DotNet is a library that allows you to interact with the Docker Registry API V2 programmatically with fully asynchronous, non-blocking and object-oriented code in your .NET applications. This is a fork of the original Docker.Registry.DotNet library, ported to .NET 7.
The fastest cache library written in C# for items with set expiration time. Easy to use, thread-safe and light on memory. Optimized to scale from dozens to millions of items. Features lock-free reads and writes, allocation-free reads and automatic eviction. Credit to Vladimir Sadov for his implementation of NonBlocking.ConcurrentDictionary which is used as an underlying store.
The defining characteristic of LABjs is the ability to load all JavaScript files in parallel, as fast as the browser will allow, but giving you the option to ensure proper execution order if you have dependencies between files. with regular <script> tags, you cannot control their loading and executing behavior reliably cross-browser. Some new browsers will load them in parallel but execute them serially, delaying execution of a smaller (quicker loading) script in the pessimistic assumption of dependency on previous scripts. Older browsers will load and execute them one-at-a-time, completely losing any parallel loading speed optimizations and slowing the whole process drastically. All browsers will, however, block other page resources (like stylesheets, images, etc) while these scripts are loading, which causes the rest of the page's content loading to appear much more sluggish to the user. LABjs by contrast will load ALL the scripts in parallel, and will execute them as soon as possible, unless you express an execution order dependency in the chain by inserting .wait(). In addition, you can "couple" inline script logic to execute in the proper order in your chain as desired by passing a function to .wait(...). It's important to realize that explicitly, separate $LAB chains operate completely independently, meaning there will be no explicit waiting for execution order between them. NOTE: JavaScript execution is always still a single-threaded, first-come-first-served environment. Also, some browsers use internal loading queues which create implicit "blocking" on script execution between separate chains. Also, the 'AllowDuplicates:false' config option will de-duplicate across chains, meaning chain B can be made to implicitly "wait" on chain A if chain B references a same script URL as chain A, and that script is still downloading.