mioco - Scalable, coroutine-based, fibers/green-threads for Rust programming language

  •        189

Mioco provides green-threads (aka fibers) like eg. Goroutines in Go, for Rust. This repo is a complete re-implementation of mioco. The code of previous versions was moved to mioco.pre-0.9.

https://github.com/dpc/mioco

Tags
Implementation
License
Platform

   




Related Projects

mioco

  •    Rust

This is repository for mioco before version 0.9. It's hear for historical reasons, while I've started reworking mioco in the original location: https://github.com/dpc/mioco . Sorry for all the confusion. Rust community decided that futures should be main Rust async IO story, so you might want to look at tokio-fiber: coroutines as Futures project, which should have mioco-like API and allow easily porting code using mioco.

may - rust stackful coroutine library

  •    Rust

Rust Stackful Coroutine Library. May is a high performance stackful coroutine library that can be thought of rust version goroutine. You can use it easily to design and develop massive concurrent programs in Rust.

Zewo - Lightweight library for web server applications in Swift on macOS and Linux powered by coroutines

  •    Swift

Zewo is a lightweight library for web applications in Swift.Zewo is not a web framework. Zewo is a lightweight library for web applications in Swift. Most server-side Swift projects use Grand Central Dispatch (GCD) as the concurrency library of choice. The drawback of using GCD is that its APIs are asynchronous. With async code comes callback hell and we all know it, it's no fun.

concurrencpp - Modern concurrency for C++

  •    C++

concurrencpp is a tasking library for C++ allowing developers to write highly concurrent applications easily and safely by using tasks, executors and coroutines. By using concurrencpp applications can break down big procedures that need to be processed asynchronously into smaller tasks that run concurrently and work in a co-operative manner to achieve the wanted result. concurrencpp also allows applications to write parallel algorithms easily by using parallel coroutines. concurrencpp is a task-centric library. A task is an asynchronous operation. Tasks offer a higher level of abstraction for concurrent code than traditional thread-centric approaches. Tasks can be chained together, meaning that tasks pass their asynchronous result from one to another, where the result of one task is used as if it were a parameter or an intermediate value of another ongoing task. Tasks allow applications to utilize available hardware resources better and scale much more than using raw threads, since tasks can be suspended, waiting for another task to produce a result, without blocking underlying OS-threads. Tasks bring much more productivity to developers by allowing them to focus more on business-logic and less on low-level concepts like thread management and inter-thread synchronization.

node-fibers - Fiber/coroutine support for v8 and node.

  •    C++

Fibers, sometimes called coroutines, are a powerful tool which expose an API to jump between multiple call stacks from within a single thread. This can be useful to make code written for a synchronous library play nicely in an asynchronous environment. Note: node-fibers uses node-gyp for building. To manually invoke the build process, you can use node-gyp rebuild. This will put the compiled extension in build/Release/fibers.node. However, when you do require('fibers'), it will expect the module to be in, for example, bin/linux-x64-v8-3.11/fibers.node. You can manually put the module here every time you build, or you can use the included build script. Either npm install or node build -f will do this for you. If you are going to be hacking on node-fibers, it may be worthwhile to first do node-gyp configure and then for subsequent rebuilds you can just do node-gyp build which will be faster than a full npm install or node-gyp rebuild.


EA Async - Implements async-await methods in the JVM

  •    Java

EA Async implements Async-Await methods in the JVM. It allows programmers to write asynchronous code in a sequential fashion. It is heavily inspired by Async-Await on the .NET CLR. EA Async should be used to write non-blocking asynchronous code that makes heavy use of CompletableFutures or CompletionStage. It improves scalability by freeing worker threads while your code awaits other processes; And improves productivity by making asynchronous code simpler and more readable.

Zio - A type-safe, composable library for async and concurrent programming in Scala

  •    Scala

ZIO is a zero-dependency Scala library for asynchronous and concurrent programming. It is powered by highly-scalable, non-blocking fibers that never waste or leak resources, ZIO lets you build scalable, resilient, and reactive applications that meet the needs of your business.

cats-effect - The IO monad for Scala

  •    Scala

For when purity just isn't impure enough. In this way, IO is more similar to common Task implementations than it is to the classic scalaz.effect.IO or even Haskell's IO, both of which are purely synchronous in nature. As Haskell's runtime uses green threading, a synchronous IO (and the requisite thread blocking) makes a lot of sense. With Scala though, we're either on a runtime with native threads (the JVM) or only a single thread (JavaScript), meaning that asynchronous effects are every bit as important as synchronous ones.

asyncoro

  •    Python

Python framework for asynchronous, concurrent, distributed programming

async-io-demo - demo for rust asynchronous io: from mio to stackless coroutine

  •    Rust

2019 is approaching. The rust team keeps their promise about asynchronous IO: async is introduced as keywords, Pin, Future, Poll and await! is introduced into standard library. I have never used rust for asynchronous IO programming earlier, so I almost know nothing about it. However, I would use it for a project recently but couldn't find many documents that are remarkably helpful for newbie of rust asynchronous programming.

dispy

  •    Python

Python framework for distributed and parallel computing

lwt - OCaml promises and concurrent I/O.

  •    OCaml

Lwt is OCaml's concurrent programming library. It provides a single data type: the promise, which is a value that will become determined in the future. Creating a promise spawns a computation. When that computation is I/O, Lwt runs it in parallel with your OCaml code. OCaml code, including creating and waiting on promises, is run in a single thread by default, so you don't have to worry about locking or preemption. You can detach code to be run in separate threads on an opt-in basis.

FiberTaskingLib - A library for enabling task-based multi-threading

  •    C++

This is a library for enabling task-based multi-threading. It allows execution of task graphs with arbitrary dependencies. Dependencies are represented as atomic counters. Under the covers, the task graph is executed using fibers, which in turn, are run on a pool of worker threads (one thread per CPU core). This allows the scheduler to wait on dependencies without task chaining or context switches.

posterus - Composable async primitives (futures) with cancelation, control over scheduling, and coroutines

  •    Javascript

Posterus is a library of promise-like asynchronous primitives (futures) that support cancelation. Futures compose just like promises, but can also be cleanly shut down, aborting pending operations and freeing resources. Posterus also exposes its inner scheduling capabilities, allowing you to "opt out" of asynchrony when needed (motivating example).

AsyncAwait - async/await for Android built upon coroutines introduced in Kotlin 1.1

  •    Kotlin

As you see in the example above, you can write asynchronous code in a imperative style, step by step. Calling await to run code in background doesn't lock the UI thread. And execution continues in UI thread after background work is finished. There is no magic, see how it works. Use it to show loading progress, its second parameter is a progress handler.

amp - A non-blocking concurrency framework for PHP applications.

  •    PHP

Amp is a non-blocking concurrency framework for PHP. It provides an event loop, promises and streams as a base for asynchronous programming.Promises in combination with generators are used to build coroutines, which allow writing asynchronous code just like synchronous code, without any callbacks.

Smith Async .NET Memcached Client

  •    DotNet

Async .NET Memcached Client is a fully asynchronous implementation of a memcached client. The advantage of a fully asynchronous client is that you do not have threads wasted in waiting for i/o operations. The client is developed in c# 4.0. (Subject to change to 3.5 possible)

Glommio - Thread-per-core framework that aims to make the task of writing highly parallel asynchronous application in a thread-per-core architecture easier for rustaceans

  •    Rust

Glommio (pronounced glo-mee-jow or |glomjəʊ|) is a Cooperative Thread-per-Core crate for Rust & Linux based on io_uring. Like other rust asynchronous crates, it allows one to write asynchronous code that takes advantage of rust async/await, but unlike its counterparts, it doesn't use helper threads anywhere.

kilim - Lightweight threads for Java, with message passing, nio, http and scheduling support.

  •    Java

Coroutines, continuations, fibers, actors and message passing for the JVM






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.