Popularity

3.8

Growing

Activity

3.7

Stable

Stars 92

Watchers 3

Forks 8

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.8 5.2 cmap VS gods

GoDS (Go Data Structures) - Sets, Lists, Stacks, Maps, Trees, Queues, and much more
go-datastructures

9.4 7.3 cmap VS go-datastructures

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

SaaSHub - Software Alternatives and Reviews

SaaSHub helps you find the best software and product alternatives

Promo www.saashub.com

golang-set

8.8 3.7 cmap VS golang-set

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

8.6 0.0 cmap VS gota

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

8.5 2.9 cmap VS FSM for Go

Finite State Machine for Go
roaring

8.4 8.8 cmap VS roaring

Roaring bitmaps in Go (golang), used by InfluxDB, Bleve, DataDog
willf/bloom

8.3 3.3 cmap VS willf/bloom

Go package implementing Bloom filters, used by Milvus and Beego.
gocache

8.3 6.1 cmap VS gocache

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

7.8 0.0 cmap VS boomfilters

Probabilistic data structures for processing continuous, unbounded streams.
bitset

7.7 7.9 cmap VS bitset

Go package implementing bitsets
gostl

7.4 1.7 cmap VS gostl

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

7.4 2.1 cmap VS cuckoofilter

Cuckoo Filter: Practically Better Than Bloom
hyperloglog

7.2 5.1 cmap VS hyperloglog

HyperLogLog with lots of sugar (Sparse, LogLog-Beta bias correction and TailCut space reduction) brought to you by Axiom
algorithms

7.2 0.0 cmap VS algorithms

CLRS study. Codes are written with golang.
trie

7.1 4.3 cmap VS trie

Data structure and relevant algorithms for extremely fast prefix/fuzzy string searching.
merkletree

6.6 0.0 cmap VS merkletree

A Merkle Tree implementation written in Go.
ttlcache

6.5 6.4 cmap VS ttlcache

DISCONTINUED. An in-memory cache with item expiration and generics [Moved to: https://github.com/jellydator/ttlcache]
go-geoindex

6.4 0.0 cmap VS go-geoindex

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

6.1 1.3 cmap VS conjungo

A small flexible merge library in go
go-adaptive-radix-tree

6.1 6.3 cmap VS go-adaptive-radix-tree

Adaptive Radix Trees implemented in Go
Bloomfilter

6.0 0.0 cmap VS Bloomfilter

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

6.0 0.0 cmap VS mafsa

DISCONTINUED. MA-FSA implementation with Minimal Perfect Hashing
goconcurrentqueue

6.0 0.0 cmap VS goconcurrentqueue

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

5.9 5.0 cmap VS levenshtein

Go implementation to calculate Levenshtein Distance.
hilbert

5.9 0.0 cmap VS hilbert

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

5.8 0.0 cmap VS goskiplist

A skip list implementation in Go
bitmap

5.6 4.3 cmap VS bitmap

Simple dense bitmap index in Go with binary operators
cuckoo-filter

5.6 0.0 cmap VS cuckoo-filter

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

5.5 0.0 cmap VS binpacker

A binary stream packer and unpacker
bit

5.0 0.0 cmap VS bit

Bitset data structure
iter

4.9 0.0 cmap VS iter

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

4.8 3.4 cmap VS deque

A highly optimized double-ended queue
bloom

4.8 0.0 cmap VS bloom

Bloom filters implemented in Go.
encoding

4.5 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.
remember-go

4.4 0.0 cmap VS remember-go

Cache Slow Database Queries
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
skiplist

4.3 0.0 cmap VS skiplist

skiplist for golang
go-mcache

4.2 0.0 cmap VS go-mcache

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

4.1 5.1 cmap VS memlog

A Kafka log inspired in-memory and append-only data structure
crunch

4.0 0.0 cmap VS crunch

take bytes out of things easily ✨🍪
set

3.8 0.0 cmap VS set

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

3.8 3.0 cmap VS nan

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

3.5 6.2 cmap VS timedmap

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

3.4 3.2 cmap VS go-tuple

Go 1.18+ generic tuple
hide

3.4 0.0 cmap VS hide

A Go type to prevent internal numeric IDs from being exposed to clients using HashIDs and JSON.
goset

3.3 0.0 cmap VS goset

Set is a useful collection but there is no built-in implementation in Go lang.
ptrie

3.3 4.5 cmap VS ptrie

A prefix tree implementation in go
pipeline

3.3 0.0 cmap VS pipeline

Pipelines using goroutines
count-min-log

3.2 0.0 cmap VS count-min-log

Go implementation of Count-Min-Log

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