Displaying 1 to 20 from 64 results

puma - A Ruby/Rack web server built for concurrency

  •    Ruby

Puma is a simple, fast, threaded, and highly concurrent HTTP 1.1 server for Ruby/Rack applications in development and production. Under the hood, Puma processes requests using a C-optimized Ragel extension (inherited from Mongrel) that provides fast, accurate HTTP 1.1 protocol parsing in a portable way. Puma then serves the request in a thread from an internal thread pool. Since each request is served in a separate thread, truly concurrent Ruby implementations (JRuby, Rubinius) will use all available CPU cores.

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.

NNPACK - Acceleration package for neural networks on multi-core CPUs

  •    C

NNPACK is an acceleration package for neural network computations. NNPACK aims to provide high-performance implementations of convnet layers for multi-core CPUs. NNPACK is not intended to be directly used by machine learning researchers; instead it provides low-level performance primitives leveraged in leading deep learning frameworks, such as PyTorch, Caffe2, MXNet, tiny-dnn, Caffe, Torch, and Darknet.

microjob - A tiny wrapper for turning Node

  •    TypeScript

A tiny wrapper for turning Node.js threads in easy-to-use routines for CPU-bound. Microjob is a tiny wrapper for Node.js threads and is intended to perform heavy CPU loads using anonymous functions. So, Microjob treats Node.js threads as temporary working units: if you need to spawn a long-living thread, then you should use the default API.




cpp-taskflow - Fast C++ Parallel Programming with Task Dependency Graphs

  •    C++

A fast C++ header-only library to help you quickly build parallel programs with complex task dependencies. Cpp-Taskflow lets you quickly build parallel dependency graphs using modern C++17. It supports both static and dynamic tasking, and is by far faster, more expressive, and easier for drop-in integration than existing libraries.

yew - Rust / Wasm framework for building client web apps

  •    Rust

Yew is a modern Rust framework for creating multi-threaded front-end web apps with WebAssembly. Note: Yew is not (yet) production ready but is great for side projects and internal tools.

react-native-multithreading - 🧵 Fast and easy multithreading for React Native using JSI

  •    C++

Since JSI is not officially released, installing react-native-multithreading requires you to edit a few native files. See the setup guide (SETUP.md) for more details. Requires react-native-reanimated 2.1.0 or higher.

Napa.js - A multi-threaded JavaScript runtime

  •    C++

Napa.js is a multi-threaded JavaScript runtime built on V8, which was originally designed to develop highly iterative services with non-compromised performance in Bing. As it evolves, we find it useful to complement Node.js in CPU-bound tasks, with the capability of executing JavaScript in multiple V8 isolates and communicating between them. Napa.js is exposed as a Node.js module, while it can also be embedded in a host process without Node.js dependency.


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.

libco - Cooperative multithreading library written in C89.

  •    C

libco is a cooperative multithreading library written in C89. Although cooperative multithreading is limited to a single CPU core, it scales substantially better than preemptive multithreading. For applications that need 100,000 or more context switches per second, the kernel overhead involved in preemptive multithreading can end up becoming the bottleneck in the application. libco can easily scale to 10,000,000 or more context switches per second.

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.

fast_gicp - A collection of GICP-based fast point cloud registration algorithms

  •    C++

This package is a collection of GICP-based fast point cloud registration algorithms. It constains a multi-threaded GICP as well as multi-thread and GPU implementations of our voxelized GICP (VGICP) algorithm. All the implemented algorithms have the PCL registration interface so that they can be used as an inplace replacement for GICP in PCL. We have tested this package on Ubuntu 18.04/20.04 and CUDA 11.1.

SpeedRunner

  •    DotNet

SpeedRunner - multi-threading file manager. Good alternative for Total Commander and FAR Manager.

xNet

  •    DotNet

xNet - a class library for .NET Framework, which includes: - Classes for work with proxy servers: HTTP, Socks4 (and), Socks5. - Classes for work with HTTP 1.0/1.1 protocol: keep-alive, gzip, deflate, chunked, SSL, proxies and more. - Classes for work with multithreading: _a...

NiceThreads

  •    DotNet

A threading utility library designed to make multiple .NET threading classes easier to use through a more consistent API and various convenience classes. It includes a common wrapper API for locking classes, support for disposable locks, and wrappers for unsafe objects.

XecMe - Task based execution framework

  •    DotNet

XecMe is a hosting and execution framework. It follows the task oriented design approach for solving the business problems.

Do Work in Background Thread to Keep GUI Responsive

  •    DotNet

Demonstrate simple example of using BackgroundWorker class to do work on a background thread and then update the GUI in a thread-safe manner.






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.