Concurrent Extensions Library (CEL)

  •        114

Concurrent Extensions Library (CEL) provides functionality and implementations commonly useful in concurrent programming.

http://threading.codeplex.com/

Tags
Implementation
License
Platform

   




Related Projects

RxJava - Reactive Extensions for the JVM

  •    Java

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences. It extends the observer pattern to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures.

crossbeam - Support for parallelism and low-level concurrency in Rust

  •    Rust

Crossbeam supports concurrent programming, especially focusing on memory management, synchronization, and non-blocking data structures. atomic for enhancing std::sync API. AtomicConsume provides C/C++11-style "consume" atomic operations (re-exported from crossbeam-utils). ArcCell provides atomic storage and retrieval of Arc.

queue - Asynchronous function queue with adjustable concurrency

  •    Javascript

Asynchronous function queue with adjustable concurrency. This module exports a class Queue that implements most of the Array API. Pass async functions (ones that accept a callback or return a promise) to an instance's additive array methods. Processing begins when you call q.start().


RxRuby - Reactive Extensions for Ruby

  •    Ruby

Reactive Programming is a hot topic as of late, especially with such things as the Reactive Manifesto. Applications' needs have changed over time, from simple polling for data to a full reactive system where data is pushed at you. Each time, we're adding more complexity, data, and asynchronous behavior to our applications. How do we manage it all? How do we scale it? By moving towards "Reactive Architectures" which are event-driven, resilient, and responsive. With the Reactive Extensions, you have all the tools you need to help build these systems.The Reactive Extensions for Ruby (RxRuby) is a set of libraries for composing asynchronous and event-based programs using observable sequences and fluent query operators that many of you already know in Ruby. Using RxRuby, developers represent asynchronous data streams with Observables, query asynchronous data streams using our many operators, and parameterize the concurrency in the asynchronous data streams using Schedulers. Simply put, RxRuby = Observables + Operators + Schedulers.

System.Threading.Joins

  •    

The Joins project provides asynchronous concurrency semantics based on join calculus and modeled after the Microsoft Research C? (C Omega) project.

libdill - Structured concurrency in C

  •    C

Libdill is a C library that makes writing structured concurrent programs easy. There is no interaction between threads. Each thread is treated as a separate process. Channels are always unbuffered. Coroutines can be canceled. Generally speaking, though, libdill's concurrency primitives are only a bit slower than basic C flow control statements. A context switch has been seen to execute in as little as 6 ns, with coroutine creation taking 26 ns. Passing a message through a channel takes about 40 ns.

RxPY - Reactive Extensions for Python

  •    Python

Reactive Extensions for Python (RxPY) is a set of libraries for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators in Python. Using Rx, developers represent asynchronous data streams with Observables, query asynchronous data streams using operators, and parameterize concurrency in data/event streams using Schedulers.Using Rx, you can represent multiple asynchronous data streams (that come from diverse sources, e.g., stock quote, Tweets, computer events, web service requests, etc.), and subscribe to the event stream using the Observer object. The Observable notifies the subscribed Observer instance whenever an event occurs.You can put various transformations in-between the source Observable and the consuming Observer as well.

yew - Rust framework for building client web apps

  •    Rust

Yew is a modern Rust framework inspired by Elm and ReactJS for creating multi-threaded frontend apps with WebAssembly. NEW! The framework supports multi-threading & concurrency out of the box. It uses Web Workers API to spawn actors (agents) in separate threads and uses a local scheduler attached to a thread for concurrent tasks.

Practical Parallel and Concurrent Programming

  •    

Eight two-week units of courseware (slides, lecture notes, samples, tools) for teaching how to program parallel/concurrent applications at a high-level using Microsoft’s Parallel Extensions to the .NET Framework.

Akka - Build Concurrent and Scalable Applications

  •    Java

Akka is the platform for the next generation event-driven, scalable and fault-tolerant architectures on the JVM. It helps to write simpler correct concurrent applications using Actors, STM & Transactors. It could scale out on multi-core or multiple nodes using asynchronous message passing. For fault-tolerance it adopts the Let it crash or Embrace failure model to build applications that self-heals, systems that never stop.

Overdrive - ⚡️ Fast async task based Swift framework with focus on type safety, concurrency and multi threading

  •    Swift

Our apps constantly do work. The faster you react to user input and produce an output, the more likely is that the user will continue to use your application. As our applications grow in complexity, the more and more work needs to be done. You need to start thinking about how to categorize and optimize work, how to make that work more efficient, more optimized and finally, faster. In most cases that doesn’t end very well because you need to know a lot about concurrency, multithreading etc. - it’s a very complex field. You need to know all API specifics before you are able to write something. Overdrive was created as a result of that struggle. It is a framework that exposes several simple concepts which are made on top of complex system frameworks that enable multithreading, concurrency and most importantly, more speed.

Overdrive - ⚡️ Fast async task based Swift framework with focus on type safety, concurrency and multi threading

  •    Swift

Our apps constantly do work. The faster you react to user input and produce an output, the more likely is that the user will continue to use your application. As our applications grow in complexity, the more and more work needs to be done. You need to start thinking about how to categorize and optimize work, how to make that work more efficient, more optimized and finally, faster. In most cases that doesn’t end very well because you need to know a lot about concurrency, multithreading etc. - it’s a very complex field. You need to know all API specifics before you are able to write something. Overdrive was created as a result of that struggle. It is a framework that exposes several simple concepts which are made on top of complex system frameworks that enable multithreading, concurrency and most importantly, more speed.

JCTools - Java Concurrency Tools for the JVM

  •    Java

Java Concurrency Tools for the JVM. This project aims to offer some concurrent data structures currently missing from the JDK.

Anything Over Anything (Network Tunneling)

  •    Perl

Tunneling software created using the Reactive Extensions framework! Rx is not just for events!!!

concurrent-map - a thread-safe concurrent map for go

  •    Go

As explained here and here, the map type in Go doesn't support concurrent reads and writes. concurrent-map provides a high-performance solution to this by sharding the map with minimal time spent waiting for locks. The package is now imported under the "cmap" namespace.

redis-objects - Map Redis types directly to Ruby objects

  •    Ruby

This is not an ORM. People that are wrapping ORM’s around Redis are missing the point. This gem originally arose out of a need for high-concurrency atomic operations; for a fun rant on the topic, see An Atomic Rant, or scroll down to Atomic Counters and Locks in this README.

concurrency-limits

  •    Java

Java Library that implements and integrates concepts from TCP congestion control to auto-detect concurrency limits to achieve optimal throughput with optimal latency. When thinking of service availability operators traditionally think in terms of RPS (requests per second). Stress tests are normally performed to determine the RPS at which point the service tips over. RPS limits are then set somewhere below this tipping point (say 75% of this value) and enforced via a token bucket. However, in large distributed systems that auto-scale this value quickly goes out of date and the service falls over anyway and becomes non-responsive to a point where it is unable to gracefully shed load. Instead of thinking in terms of RPS, we should be thinking in terms of concurrent request where we apply queuing theory to determine the number of concurrent requests a service can handle before a queue starts to build up, latencies increase and the service eventually exhausts a hard limit such as CPU, memory, disk or network. This relationship is covered very nicely with Little's Law where Limit = Average RPS * Average Latency.





We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.