Popularity

1.6

Growing

Activity

0.0

Declining

Stars 16

Watchers 2

Forks 0

Last Commit about 1 year ago

Programming language: Go

License: MIT License

Tags: Data Structures

cmap alternatives and similar packages

Based on the "Data Structures" category.
Alternatively, view cmap alternatives based on common mentions on social networks and blogs.

gods

9.7 0.0 cmap VS gods

GoDS (Go Data Structures). Containers (Sets, Lists, Stacks, Maps, Trees), Sets (HashSet, TreeSet, LinkedHashSet), Lists (ArrayList, SinglyLinkedList, DoublyLinkedList), Stacks (LinkedListStack, ArrayStack), Maps (HashMap, TreeMap, HashBidiMap, TreeBidiMap, LinkedHashMap), Trees (RedBlackTree, AVLTree, BTree, BinaryHeap), Comparators, Iterators, Enumerables, Sort, JSON
go-datastructures

9.5 3.9 cmap VS go-datastructures

A collection of useful, performant, and threadsafe Go datastructures.

Run Linux Software Faster and Safer than Linux with Unikernels

Promo github.com/nanovms

golang-set

8.5 0.1 cmap VS golang-set

A simple set type for the Go language. Trusted by Docker, 1Password, Ethereum and Hashicorp.
gota

8.4 5.8 cmap VS gota

Gota: DataFrames and data wrangling in Go (Golang)
FSM for Go

8.2 1.3 cmap VS FSM for Go

Finite State Machine for Go
willf/bloom

8.0 5.5 cmap VS willf/bloom

Go package implementing Bloom filters
boomfilters

7.9 1.2 cmap VS boomfilters

Probabilistic data structures for processing continuous, unbounded streams.
roaring

7.9 7.6 cmap VS roaring

Roaring bitmaps in Go (golang)
gocache

7.6 7.2 cmap VS gocache

☔️ A complete Go cache library that brings you multiple ways of managing your caches
bitset

7.4 3.0 cmap VS bitset

Go package implementing bitsets
cuckoofilter

7.3 1.9 cmap VS cuckoofilter

Cuckoo Filter: Practically Better Than Bloom
hyperloglog

7.2 2.0 cmap VS hyperloglog

HyperLogLog with lots of sugar (Sparse, LogLog-Beta bias correction and TailCut space reduction)
algorithms

7.1 0.0 cmap VS algorithms

CLRS study. Codes are written with golang.
trie

7.0 0.0 cmap VS trie

Data structure and relevant algorithms for extremely fast prefix/fuzzy string searching.
go-geoindex

6.6 0.0 cmap VS go-geoindex

Go native library for fast point tracking and K-Nearest queries
gostl

6.3 0.3 cmap VS gostl

Data structure and algorithm library for go, designed to provide functions similar to C++ STL
conjungo

6.2 0.0 cmap VS conjungo

A small flexible merge library in go
merkletree

6.1 0.0 cmap VS merkletree

A Merkle Tree implementation written in Go.
ttlcache

6.1 6.8 cmap VS ttlcache

An in-memory string-interface{} map with various expiration options for golang
mafsa

6.0 0.0 cmap VS mafsa

MA-FSA implementation with Minimal Perfect Hashing
Bloomfilter

6.0 0.0 cmap VS Bloomfilter

Face-meltingly fast, thread-safe, marshalable, unionable, probability- and optimal-size-calculating Bloom filter in go
goskiplist

6.0 0.0 cmap VS goskiplist

A skip list implementation in Go
hilbert

5.9 0.0 cmap VS hilbert

Go package for mapping values to and from space-filling curves, such as Hilbert and Peano curves.
binpacker

5.5 1.1 cmap VS binpacker

A binary stream packer and unpacker
go-adaptive-radix-tree

5.5 0.1 cmap VS go-adaptive-radix-tree

Adaptive Radix Trees implemented in Go
bloom

5.0 0.0 cmap VS bloom

Bloom filters implemented in Go.
levenshtein

5.0 3.0 cmap VS levenshtein

Go implementation to calculate Levenshtein Distance.
cuckoo-filter

5.0 6.0 cmap VS cuckoo-filter

Cuckoo Filter go implement, better than Bloom Filter, configurable and space optimized 布谷鸟过滤器的Go实现，优于布隆过滤器，可以定制化过滤器参数，并进行了空间优化
iter

4.7 0.0 cmap VS iter

Go implementation of C++ STL iterators and algorithms.
goconcurrentqueue

4.7 0.0 cmap VS goconcurrentqueue

Go concurrent-safe, goroutine-safe, thread-safe queue
bit

4.6 0.0 cmap VS bit

Bitset data structure
encoding

4.6 0.0 cmap VS encoding

Integer Compression Libraries for Go
ring

4.5 0.0 cmap VS ring

Package ring provides a high performance and thread safe Go implementation of a bloom filter.
skiplist

4.4 0.0 cmap VS skiplist

skiplist for golang
go-rquad

4.4 0.0 cmap VS go-rquad

:pushpin: State of the art point location and neighbour finding algorithms for region quadtrees, in Go
remember-go

4.3 1.2 cmap VS remember-go

Cache Slow Database Queries
bitmap

4.1 7.2 cmap VS bitmap

Simple dense bitmap index in Go with binary operators
go-mcache

4.0 0.0 cmap VS go-mcache

Fast in-memory key:value store/cache with TTL
set

3.7 0.0 cmap VS set

A simple Set data structure implementation in Go (Golang) using LinkedHashMap.
crunch

3.4 3.3 cmap VS crunch

take bytes out of things easily ✨🍪
goset

3.2 0.0 cmap VS goset

Set is a useful collection but there is no built-in implementation in Go lang.
count-min-log

3.1 0.0 cmap VS count-min-log

Go implementation of Count-Min-Log
nan

3.1 2.7 cmap VS nan

Zero allocation Nullable structures in one library with handy conversion functions, marshallers and unmarshallers
hide

2.9 1.0 cmap VS hide

ID type with marshalling to/from hash to prevent sending IDs to clients.
ptrie

2.7 0.0 cmap VS ptrie

A prefix tree implementation in go
pipeline

2.6 0.0 cmap VS pipeline

Pipelines using goroutines
deque

2.5 0.0 cmap VS deque

A highly optimized double-ended queue
timedmap

2.5 5.6 cmap VS timedmap

A thread safe map which has expiring key-value pairs.
go-ef

2.1 0.0 cmap VS go-ef

A Go implementation of the Elias-Fano encoding
null

2.1 1.0 cmap VS null

Nullable Go types that can be marshalled/unmarshalled to/from JSON.

Do you think we are missing an alternative of cmap or a related project?

Add another 'Data Structures' Package

Popular Comparisons

README

cmap

The map type in Go doesn't support concurrent reads and writes. cmap(concurrent-map) provides a high-performance solution to this by sharding the map with minimal time spent waiting for locks.

The sync.Map has a few key differences from this map. The stdlib sync.Map is designed for append-only scenarios. So if you want to use the map for something more like in-memory db, you might benefit from using our version. You can read more about it in the golang repo, for example here and here

Here we fork some README document from concurrent-map

usage

Import the package:

import (
    "github.com/lrita/cmap"
)

go get "github.com/lrita/cmap"

The package is now imported under the "cmap" namespace.

example


    // Create a new map.
    var m cmap.Cmap

    // Stores item within map, sets "bar" under key "foo"
    m.Store("foo", "bar")

    // Retrieve item from map.
    if tmp, ok := m.Load("foo"); ok {
        bar := tmp.(string)
    }

    // Deletes item under key "foo"
    m.Delete("foo")

benchmark

goos: darwin
goarch: amd64
pkg: github.com/lrita/cmap
BenchmarkLoadMostlyHits/*cmap_test.DeepCopyMap-4            50000000            34.5 ns/op
BenchmarkLoadMostlyHits/*cmap_test.RWMutexMap-4             20000000            65.2 ns/op
BenchmarkLoadMostlyHits/*sync.Map-4                         50000000            34.8 ns/op
BenchmarkLoadMostlyHits/*cmap.Cmap-4                        30000000            53.5 ns/op
BenchmarkLoadMostlyMisses/*cmap_test.DeepCopyMap-4          50000000            26.7 ns/op
BenchmarkLoadMostlyMisses/*cmap_test.RWMutexMap-4           20000000            62.5 ns/op
BenchmarkLoadMostlyMisses/*sync.Map-4                       50000000            22.7 ns/op
BenchmarkLoadMostlyMisses/*cmap.Cmap-4                      30000000            40.3 ns/op
--- SKIP: BenchmarkLoadOrStoreBalanced/*cmap_test.DeepCopyMap
    cmap_bench_test.go:91: DeepCopyMap has quadratic running time.
BenchmarkLoadOrStoreBalanced/*cmap_test.RWMutexMap-4         3000000           437 ns/op
BenchmarkLoadOrStoreBalanced/*sync.Map-4                     3000000           546 ns/op
BenchmarkLoadOrStoreBalanced/*cmap.Cmap-4                    3000000           497 ns/op
--- SKIP: BenchmarkLoadOrStoreUnique/*cmap_test.DeepCopyMap
    cmap_bench_test.go:123: DeepCopyMap has quadratic running time.
BenchmarkLoadOrStoreUnique/*cmap_test.RWMutexMap-4           2000000           990 ns/op
BenchmarkLoadOrStoreUnique/*sync.Map-4                       1000000          1032 ns/op
BenchmarkLoadOrStoreUnique/*cmap.Cmap-4                      2000000           892 ns/op
BenchmarkLoadOrStoreCollision/*cmap_test.DeepCopyMap-4      100000000           18.2 ns/op
BenchmarkLoadOrStoreCollision/*cmap_test.RWMutexMap-4       10000000           165 ns/op
BenchmarkLoadOrStoreCollision/*sync.Map-4                   100000000           19.6 ns/op
BenchmarkLoadOrStoreCollision/*cmap.Cmap-4                  20000000            65.7 ns/op
BenchmarkRange/*cmap_test.DeepCopyMap-4                       200000          8646 ns/op
BenchmarkRange/*cmap_test.RWMutexMap-4                         20000         62046 ns/op
BenchmarkRange/*sync.Map-4                                    200000          9317 ns/op
BenchmarkRange/*cmap.Cmap-4                                    50000         31107 ns/op
BenchmarkAdversarialAlloc/*cmap_test.DeepCopyMap-4           2000000           531 ns/op
BenchmarkAdversarialAlloc/*cmap_test.RWMutexMap-4           20000000            74.3 ns/op
BenchmarkAdversarialAlloc/*sync.Map-4                        5000000           390 ns/op
BenchmarkAdversarialAlloc/*cmap.Cmap-4                      30000000            53.6 ns/op
BenchmarkAdversarialDelete/*cmap_test.DeepCopyMap-4          5000000           273 ns/op
BenchmarkAdversarialDelete/*cmap_test.RWMutexMap-4          20000000            94.4 ns/op
BenchmarkAdversarialDelete/*sync.Map-4                      10000000           137 ns/op
BenchmarkAdversarialDelete/*cmap.Cmap-4                     30000000            43.3 ns/op

cmap

a thread-safe concurrent map for go

cmap alternatives and similar packages

Popular Comparisons

README

cmap

usage

example

benchmark