Cmap (#5)

* 分区map

* 更新

Author: guonaihong

README.md

@@ -160,7 +160,7 @@ rwmap与sync.Map类似支持并发访问，只解决sync.Map 2个问题.
 1. 没有Len成员函数  
 2. 以及没有使用泛型语法，有运行才发现类型使用错误的烦恼
 ```go
-var m RWMap[string, string] // 声明一个string, string的map
+var m rwmap.RWMap[string, string] // 声明一个string, string的map
 m.Store("hello", "1") // 保存
 v1, ok1 := m.Load("hello") // 获取值
 v1, ok1 = m.LoadAndDelete("hello") //返回hello对应值，然后删除hello
@@ -182,3 +182,28 @@ m.Len()// 获取长度
 allKeys := m.Keys() //返回所有的key
 allValues := m.Values()// 返回所有的value
 ```
+## 十二、`cmap`
+cmap是用锁分区的方式实现的，(TODO与sync.Map测试下性能对比，从sync.Map的源代码上看只能用于读多写少，如果写读对半分，或者写多读少？)
+```go
+var m cmap.CMap[string, string] // 声明一个string, string的map
+m.Store("hello", "1") // 保存
+v1, ok1 := m.Load("hello") // 获取值
+v1, ok1 = m.LoadAndDelete("hello") //返回hello对应值，然后删除hello
+Delete("hello") // 删除
+v1, ok1 = m.LoadOrStore("hello", "world")
+
+// 遍历，使用回调函数
+m.Range(func(key, val string) bool {
+	fmt.Printf("k:%s, val:%s\n"i, key, val)
+	return true
+})
+
+// 遍历，迭代器
+for pair := range m.Iter() {
+  fmt.Printf("k:%s, val:%s\n", pair.Key, pair.Val)
+}
+
+m.Len()// 获取长度
+allKeys := m.Keys() //返回所有的key
+allValues := m.Values()// 返回所有的value
+```

api/api.go

@@ -38,3 +38,12 @@ type Trie[V any] interface {
 	Delete(k string)
 	Len() int
 }
+
+type CMaper[K comparable, V any] interface {
+	Delete(key K)
+	Load(key K) (value V, ok bool)
+	LoadAndDelete(key K) (value V, loaded bool)
+	LoadOrStore(key K, value V) (actual V, loaded bool)
+	Range(f func(key K, value V) bool)
+	Store(key K, value V)
+}

btree/btree.go

@@ -17,7 +17,7 @@ import (
 var _ api.SortedMap[int, int] = (*Btree[int, int])(nil)
 var ErrNotFound = errors.New("btree not found")
 
-//btree头结点
+// btree头结点
 type Btree[K constraints.Ordered, V any] struct {
 	count    int         //当前元素个数
 	root     *node[K, V] // root结点指针

cmap/cmap.go

@@ -0,0 +1,222 @@
+package cmap
+
+import (
+	"reflect"
+	"runtime"
+	"sync"
+	"unsafe"
+
+	"github.com/antlabs/gstl/api"
+	"github.com/antlabs/gstl/mapex"
+	xxhash "github.com/cespare/xxhash/v2"
+)
+
+var _ api.CMaper[int, int] = (*CMap[int, int])(nil)
+
+type Pair[K comparable, V any] struct {
+	Key K
+	Val V
+}
+
+type CMap[K comparable, V any] struct {
+	bucket   []Item[K, V]
+	keySize  int
+	isKeyStr bool
+}
+
+type Item[K comparable, V any] struct {
+	rw sync.RWMutex
+	m  map[K]V
+}
+
+func New[K comparable, V any]() (c *CMap[K, V]) {
+	np := runtime.GOMAXPROCS(0)
+	if np <= 0 {
+		np = 8
+	}
+
+	c = &CMap[K, V]{
+		bucket: make([]Item[K, V], np),
+	}
+
+	for i := range c.bucket {
+		c.bucket[i].m = make(map[K]V)
+	}
+	return c
+}
+
+// 计算hash值
+func (c *CMap[K, V]) calHash(k K) uint64 {
+	var key string
+
+	if c.isKeyStr {
+		// 直接赋值会报错, 使用unsafe绕过编译器检查
+		key = *(*string)(unsafe.Pointer(&k))
+	} else {
+		// 因为xxhash.Sum64String 接收string, 所以要把非string类型变量当成string类型来处理
+		key = *(*string)(unsafe.Pointer(&reflect.StringHeader{
+			Data: uintptr(unsafe.Pointer(&k)),
+			Len:  c.keySize,
+		}))
+	}
+
+	return xxhash.Sum64String(key)
+}
+
+// 保存key的类型和key的长度
+func (h *CMap[K, V]) keyTypeAndKeySize() {
+	var k K
+	switch (interface{})(k).(type) {
+	case string:
+		h.isKeyStr = true
+	default:
+		h.keySize = int(unsafe.Sizeof(k))
+	}
+}
+
+// 找到索引
+func (c *CMap[K, V]) findIndex(key K) *Item[K, V] {
+	index := c.calHash(key) % uint64(len(c.bucket))
+	return &c.bucket[index]
+}
+
+// 删除
+func (c *CMap[K, V]) Delete(key K) {
+	item := c.findIndex(key)
+	item.rw.Lock()
+	delete(item.m, key)
+	item.rw.Unlock()
+}
+
+func (c *CMap[K, V]) Load(key K) (value V, ok bool) {
+	item := c.findIndex(key)
+	item.rw.RLock()
+	value, ok = item.m[key]
+	item.rw.RUnlock()
+	return
+}
+
+func (c *CMap[K, V]) LoadAndDelete(key K) (value V, loaded bool) {
+	item := c.findIndex(key)
+	item.rw.Lock()
+	value, loaded = item.m[key]
+	if !loaded {
+		item.rw.Unlock()
+		return
+	}
+	delete(item.m, key)
+	item.rw.Unlock()
+	return
+}
+
+func (c *CMap[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {
+	item := c.findIndex(key)
+	item.rw.Lock()
+	actual, loaded = item.m[key]
+	if !loaded {
+		actual = value
+		item.m[key] = actual
+		item.rw.Unlock()
+		return
+	}
+	actual, loaded = item.m[key]
+	item.rw.Unlock()
+	return
+}
+
+func (c *CMap[K, V]) Range(f func(key K, value V) bool) {
+	for i := 0; i < len(c.bucket); i++ {
+		item := &c.bucket[i]
+		item.rw.RLock()
+		for k, v := range item.m {
+			if !f(k, v) {
+				item.rw.RUnlock()
+				return
+			}
+		}
+		item.rw.RUnlock()
+	}
+}
+
+func (c *CMap[K, V]) Iter() (rv chan Pair[K, V]) {
+
+	rv = make(chan Pair[K, V])
+	var wg sync.WaitGroup
+
+	wg.Add(len(c.bucket))
+
+	go func() {
+		wg.Wait()
+		close(rv)
+	}()
+
+	for i := 0; i < len(c.bucket); i++ {
+		item := &c.bucket[i]
+		go func(item *Item[K, V]) {
+
+			defer wg.Done()
+			item.rw.RLock()
+			for k, v := range item.m {
+				rv <- Pair[K, V]{Key: k, Val: v}
+			}
+			item.rw.RUnlock()
+
+		}(item)
+	}
+	return rv
+
+}
+
+func (c *CMap[K, V]) Store(key K, value V) {
+	item := c.findIndex(key)
+	item.rw.Lock()
+	item.m[key] = value
+	item.rw.Unlock()
+	return
+}
+
+// TODO 优化
+func (c *CMap[K, V]) Keys() []K {
+	l := c.Len()
+	all := make([]K, 0, l)
+	if l == 0 {
+		return nil
+	}
+
+	for i := 0; i < len(c.bucket); i++ {
+
+		item := &c.bucket[i]
+		item.rw.RLock()
+		all = append(all, mapex.Keys(item.m)...)
+		item.rw.RUnlock()
+	}
+	return all
+}
+
+func (c *CMap[K, V]) Values() []V {
+	l := c.Len()
+	all := make([]V, 0, l)
+	if l == 0 {
+		return nil
+	}
+
+	for i := 0; i < len(c.bucket); i++ {
+
+		item := &c.bucket[i]
+		item.rw.RLock()
+		all = append(all, mapex.Values(item.m)...)
+		item.rw.RUnlock()
+	}
+	return all
+}
+
+func (c *CMap[K, V]) Len() int {
+	l := 0
+	for i := 0; i < len(c.bucket); i++ {
+		item := &c.bucket[i]
+		item.rw.RLock()
+		l += len(item.m)
+		item.rw.RUnlock()
+	}
+	return l
+}