libcds - A C++ library of Concurrent Data Structures

  •        18

The Concurrent Data Structures (CDS) library is a collection of concurrent containers that don't require external (manual) synchronization for shared access, and safe memory reclamation (SMR) algorithms like Hazard Pointer and user-space RCU that is used as an epoch-based SMR. CDS is mostly header-only template library. Only SMR core implementation is segregated to .so/.dll file.

http://libcds.sourceforge.net/doc/cds-api/index.html
https://github.com/khizmax/libcds

Tags
Implementation
License
Platform

   




Related Projects

cds

  •    C++

CDS (Concurrent Data Structures) is a C++ template library of lock-free and fine-grained lock-based algorithms. It contains a collection of concurrent data structures: queues, maps, hazard pointer reclamation schema, user-space RCU implementations, - and many others.

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.

awesome-threat-intelligence - A curated list of Awesome Threat Intelligence resources

  •    

A concise definition of Threat Intelligence: evidence-based knowledge, including context, mechanisms, indicators, implications and actionable advice, about an existing or emerging menace or hazard to assets that can be used to inform decisions regarding the subject’s response to that menace or hazard. Feel free to contribute.

hashmap - A Golang lock-free thread-safe HashMap optimized for fastest read access.

  •    Go

A Golang lock-free thread-safe HashMap optimized for fastest read access. The benchmarks were run with Golang 1.10.1 on MacOS.

dom-examples - Code examples that accompany various MDN DOM and Web API documentation pages

  •    HTML

Code examples that accompany various MDN DOM and Web API documentation pages. The "abort-api" directory contains an example of how to use the "Abort API" (aka AbortSignal and AbortController). Run the example live.


PEP - Pointer Events Polyfill: a unified event system for the web platform

  •    Javascript

PEP polyfills pointer events in all browsers that haven't yet implemented them, providing a unified, responsive input model for all devices and input types. You can read more about pointer events below. By default, no pointer events are sent from an element. This maximizes the possibility that a browser can deliver smooth scrolling and jank-free gestures. If you want to receive events, you must set the touch-action property of that element. Set up some elements to create events with the touch-action attribute.

FLoM - Free Lock Manager

  •    C

FLoM is a free, open source, distributed lock manager that can be used to synchronize shell commands, scripts and custom developed C, C++, Java, PHP and Python software. When used in a shell environment, FLoM manages process serialization in the same way "nice" manages process prioritization.

pointer-generator - Code for the ACL 2017 paper "Get To The Point: Summarization with Pointer-Generator Networks"

  •    Python

Note: this code is no longer actively maintained. However, feel free to use the Issues section to discuss the code with other users. Some users have updated this code for newer versions of Tensorflow and Python - see information below and Issues section. This repository contains code for the ACL 2017 paper Get To The Point: Summarization with Pointer-Generator Networks. For an intuitive overview of the paper, read the blog post.

cadvisor - Analyzes resource usage and performance characteristics of running containers.

  •    Go

cAdvisor (Container Advisor) provides container users an understanding of the resource usage and performance characteristics of their running containers. It is a running daemon that collects, aggregates, processes, and exports information about running containers. Specifically, for each container it keeps resource isolation parameters, historical resource usage, histograms of complete historical resource usage and network statistics. This data is exported by container and machine-wide.cAdvisor has native support for Docker containers and should support just about any other container type out of the box. We strive for support across the board so feel free to open an issue if that is not the case. cAdvisor's container abstraction is based on lmctfy's so containers are inherently nested hierarchically.

docker-slim - DockerSlim (docker-slim): Optimize and secure your Docker containers (free and open source)

  •    Go

Creating small containers requires a lot of voodoo magic and it can be pretty painful. You shouldn't have to throw away your tools and your workflow to have skinny containers. Using Docker should be easy.docker-slim is a magic diet pill for your containers :) It will use static and dynamic analysis to create a skinny container for your app.

concurrentqueue - A fast multi-producer, multi-consumer lock-free concurrent queue for C++11

  •    C++

An industrial-strength lock-free queue for C++. Note: If all you need is a single-producer, single-consumer queue, I have one of those too.

readerwriterqueue - A fast single-producer, single-consumer lock-free queue for C++

  •    C++

This mini-repository has my very own implementation of a lock-free queue (that I designed from scratch) for C++. It only supports a two-thread use case (one consuming, and one producing). The threads can't switch roles, though you could use this queue completely from a single thread if you wish (but that would sort of defeat the purpose!).

tla-rust - writing correct lock-free and distributed stateful systems in Rust, assisted by TLA+

  •    TLA

Stable stateful systems through modeling, linear types and simulation. I like to use things that wake me up at 4am as rarely as possible. Unfortunately, infrastructure vendors don't focus on reliability. Even if a company gives reliability lip service, it's unlikely that they use techniques like modeling or simulation to create a rock-solid core. Let's just build an open-source distributed store that takes correctness seriously at the local storage, sharding, and distributed transactional layers.

go-queue - High-performance lock-free queue (Disruptor 1400/s)

  •    Go

High-performance lock-free queue (Disruptor 1400/s)

checkup - Distributed, lock-free, self-hosted health checks and status pages

  •    Go

Checkup is distributed, lock-free, self-hosted health checks and status pages, written in Go. It features an elegant, minimalistic CLI and an idiomatic Go library. They are completely interoperable and their configuration is beautifully symmetric.

json - JSON for Modern C++

  •    C++

Intuitive syntax. In languages such as Python, JSON feels like a first class data type. We used all the operator magic of modern C++ to achieve the same feeling in your code. Check out the examples below and you'll know what I mean.Trivial integration. Our whole code consists of a single header file json.hpp. That's it. No library, no subproject, no dependencies, no complex build system. The class is written in vanilla C++11. All in all, everything should require no adjustment of your compiler flags or project settings.

STLplus C++ library collection

  •    C++

Containers to extend STL: graph, tree, matrix, smart-pointer. Persistence (serialisation) of C++ data structures. Portability: subprocesses, TCP, file system. Reusable subsystems: library manager, message handler. Portable between OSs and compilers.

Planet Hazard

  •    C++

Planet Hazard is open source multiplayer first person shooter.

Toxtree: Toxic Hazard Estimation

  •    Java

Toxicity prediction for chemical compounds

zabbix-docker-monitoring - :whale: Docker/Kubernetes/Mesos/Marathon/Chronos/LXC/LXD/Swarm container monitoring - Docker image, Zabbix template and C module

  •    C

If you like or use this project, please provide feedback to author - Star it ★ and write what's missing for you.Monitoring of Docker container by using Zabbix. Available CPU, mem, blkio, net container metrics and some containers config details, e.g. IP, name, ... Zabbix Docker module has native support for Docker containers (Systemd included) and should also support a few other container types (e.g. LXC) out of the box. Please feel free to test and provide feedback/open issue. The module is focused on performance, see section Module vs. UserParameter script.