Displaying 1 to 17 from 17 results

bild - A collection of parallel image processing algorithms in pure Go

  •    Go

A collection of parallel image processing algorithms in pure Go.The aim of this project is simplicity in use and development over high performance, but most algorithms are designed to be efficient and make use of parallelism when available. It is based on standard Go packages to reduce dependency use and development abstractions.

phobos - The standard library of the D programming language

  •    D

Phobos is the standard library that comes with the D Programming Language Compiler. Phobos is packaged together with the compiler. You should download the whole precompiled package.

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.

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.

Gpars - Groovy parallel systems

  •    Groovy

Gpars is a framework which provides straightforward Java or Groovy-based APIs to declare, which parts of the code should be performed in parallel. Collections can have their elements processed concurrently, closures can be turned into composable asynchronous functions and run in the background on your behalf, mutable data can be protected by agents or software transactional memory.

fetch - Simple & Efficient data access for Scala and Scala.js

  •    Scala

Add the following dependency to your project's build file.Fetch is a library for making access to data both simple & efficient. Fetch is especially useful when querying data that has a latency cost, such as databases or web services.

throat - Throttle a collection of promise returning functions

  •    Javascript

Throttle the parallelism of an asynchronous, promise returning, function / functions. This has special utility when you set the concurrency to 1. That way you get a mutually exclusive lock. This returns a function that acts a bit like a lock (exactly as a lock if concurrency is 1).

start - :red_circle: Functional task runner for Node.js

  •    TypeScript

Coming soon. All the packages in this repository are released under the terms of the MIT License.

imminent - A composable Futures library for Clojure

  •    Clojure

Simply put, because the (1) core abstractions don't compose and (2) in order to get the value out of one of them you have to necessarily block the current thread. Imminent solves both problems. It is also heavily inspired by Scala's Futures and Twitter Futures.

semaphorejs - A functional-style Semaphore for managing concurrent access to a resource

  •    Javascript

A functional-style Semaphore for managing concurrent access to a resource with async functions and Promises. Most of the time, you should use limit() instead of creating a Semaphore yourself. limit() preserves your existing API and simply "decorates" the async function with rate limiting.

pht - A new threading extension for PHP

  •    C

This extension exposes a new approach to threading in PHP. Any Unix-based OS is supported (including OS X), along with Windows. This extension was explicitly tested on OS X (Yosemite and Sierra), Ubuntu 14.04 (32bit), and Windows Server 2012 (the pthreads-win32 library is needed).

chymyst-core - Declarative concurrency in Scala - The implementation of the chemical machine

  •    Scala

This repository hosts Chymyst Core — a domain-specific language for purely functional, declarative concurrency, implemented as a Scala library. Chymyst is a framework-in-planning that will build upon Chymyst Core to enable creating concurrent applications declaratively. The code is extensively tested under Oracle JDK 8 with Scala 2.11.8, 2.11.11, and 2.12.2-2.12.6.

control.async - Migrating to https://github.com/origamitower/folktale

  •    Javascript

Operations for asynchronous control flow. This will generate the dist/control.async.umd.js file, which you can load in any JavaScript environment.

ThreadCC - Portable C++ compiler suite for Windows, preconfigured for parallelism and concurrency.

  •    C++

This is a general purpose compiler suite that includes GCC, GNU make and GDB. If you just need to "download a C/++ compiler and be done with it", this is the way to go. This doesn't require any installation or path config etc. It comes preconfigured with static builds of the Intel® Threading Building Blocks library, which is a sane extension of C++ for dead-simple threading and concurrency. Click the link to learn more. This hosts GCC 5.

viuavm - Parallel virtual machine designed to reliably run massively concurrent programs

  •    C++

A register-based, parallel virtual machine programmable in custom assembly lookalike language with strong emphasis on reliability, predictability, and concurrency. Note: the default build is run with -O0 (without any optimisations). You can compile Viua VM with higher optimisation leves, but keep in mind that the compilation might not succeed on machines with 4GB or less RAM (with -O3). This is tracked by issue #184 on GitHub, or by issue 7c06177872c3a718510a54e6513820f8fe0fb99b in the embedded issue repository.