feat: support more cmd and add benchmark result

Author: yusank

README.md

@@ -27,4 +27,8 @@
 
 ## Design
 
-![data transfer](./static/godis_data_transfer.png)
+![data transfer](./static/godis_data_transfer.png)
+
+## Benchmark
+
+[压测结果](benchmark/README.md)

benchmark/README.md

@@ -0,0 +1,3 @@
+# Benchmark
+
+- 2021/12/08 first benchmark [result](benchmark.20211208.csv).

benchmark/benchmark.20211208.csv

@@ -0,0 +1,21 @@
+"test","rps","avg_latency_ms","min_latency_ms","p50_latency_ms","p95_latency_ms","p99_latency_ms","max_latency_ms"
+"PING_INLINE","77519.38","0.458","0.072","0.383","0.679","1.119","18.479"
+"PING_MBULK","83333.34","0.459","0.080","0.335","0.735","0.919","36.287"
+"SET","82644.62","0.421","0.064","0.351","0.687","1.007","16.639"
+"GET","83333.34","0.412","0.064","0.383","0.679","0.935","2.055"
+"INCR","83333.34","0.452","0.080","0.367","0.743","1.103","21.295"
+"LPUSH","83333.34","0.396","0.136","0.375","0.583","0.847","1.655"
+"RPUSH","84033.61","0.447","0.064","0.343","0.735","1.007","27.631"
+"LPOP","84033.61","0.424","0.088","0.375","0.703","0.991","6.367"
+"RPOP","82644.62","0.444","0.080","0.327","0.679","0.807","35.647"
+"SADD","84033.61","0.441","0.080","0.383","0.711","0.871","12.967"
+"HSET","77519.38","0.450","0.112","0.375","0.967","1.231","1.671"
+"SPOP","52631.58","0.644","0.096","0.527","1.183","1.951","12.183"
+"ZADD","83333.34","0.447","0.072","0.367","0.791","0.967","18.207"
+"ZPOPMIN","87719.30","0.397","0.120","0.391","0.543","0.855","1.343"
+"LPUSH (needed to benchmark LRANGE)","84745.77","0.448","0.080","0.351","0.687","0.919","30.191"
+"LRANGE_100 (first 100 elements)","26109.66","1.014","0.128","0.967","1.319","1.735","10.623"
+"LRANGE_300 (first 300 elements)","11210.76","2.361","0.304","2.223","2.887","4.303","32.351"
+"LRANGE_500 (first 500 elements)","7309.94","3.551","0.648","3.399","4.319","5.951","39.647"
+"LRANGE_600 (first 600 elements)","6180.47","4.167","0.536","4.071","4.983","6.279","20.399"
+"MSET (10 keys)","73529.41","0.475","0.080","0.375","1.143","1.727","2.559"

datastruct/list.go

@@ -435,7 +435,7 @@ func loadAndCheckList(key string, checkLen bool) (*List, error) {
 }
 
 func LPush(key string, values ...string) (ln int, err error) {
-	info, err := loadKeyInfo(key, KeyTypeList)
+	list, err := loadAndCheckList(key, false)
 	if err == ErrNil {
 		list := newListByLPush(values...)
 		defaultCache.keys.Set(key, &KeyInfo{
@@ -450,7 +450,6 @@ func LPush(key string, values ...string) (ln int, err error) {
 		return 0, err
 	}
 
-	list := info.Value.(*List)
 	for _, value := range values {
 		list.LPush(value)
 	}
@@ -459,12 +458,11 @@ func LPush(key string, values ...string) (ln int, err error) {
 }
 
 func LPop(key string, count int) (values []string, err error) {
-	info, err := loadKeyInfo(key, KeyTypeList)
+	list, err := loadAndCheckList(key, true)
 	if err != nil {
 		return nil, err
 	}
 
-	list := info.Value.(*List)
 	for count > 0 && list.length > 0 {
 		value, ok := list.LPop()
 		if !ok {
@@ -479,9 +477,9 @@ func LPop(key string, count int) (values []string, err error) {
 }
 
 func RPush(key string, values ...string) (ln int, err error) {
-	info, err := loadKeyInfo(key, KeyTypeList)
+	list, err := loadAndCheckList(key, false)
 	if err == ErrNil {
-		list := newListByRPush(values...)
+		list = newListByRPush(values...)
 		defaultCache.keys.Set(key, &KeyInfo{
 			Type:  KeyTypeList,
 			Value: list,
@@ -494,7 +492,6 @@ func RPush(key string, values ...string) (ln int, err error) {
 		return 0, err
 	}
 
-	list := info.Value.(*List)
 	for _, value := range values {
 		list.RPush(value)
 	}

datastruct/set.go

@@ -44,6 +44,20 @@ func (s *set) sRem(key string) int {
 	return 0
 }
 
+func (s *set) sPop(cnt int) []string {
+	var (
+		result []string
+		ch     = s.m.IterBuffered()
+	)
+	for i := 0; i < cnt; i++ {
+		item := <-ch
+		s.sRem(item.Key)
+		result = append(result, item.Key)
+	}
+
+	return result
+}
+
 func sDiff(s1, s2 *set) *set {
 	var result = newSet()
 	s1.m.IterCb(func(key string, _ interface{}) {
@@ -82,7 +96,7 @@ func sUnion(sets ...*set) *set {
  */
 
 func loadAndCheckSet(key string, check bool) (*set, error) {
-	info, err := loadKeyInfo(key, KeyTypeSortedSet)
+	info, err := loadKeyInfo(key, KeyTypeSet)
 	if err != nil {
 		return nil, err
 	}
@@ -343,6 +357,15 @@ func SUnionStore(storeKey string, keys ...string) (int, error) {
 	return result.length, nil
 }
 
+func SPop(key string, cnt int) ([]string, error) {
+	s, err := loadAndCheckSet(key, true)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.sPop(cnt), nil
+}
+
 /*
  * compare with sync map
  * just for compare, not using in any data struct

datastruct/sorted_set.go

@@ -786,6 +786,50 @@ func ZRevRange(key, minStr, maxStr string, flag int) ([]string, error) {
 	return zs.zsl.zRevRange(start, stop, withScores), nil
 }
 
+func ZPopMin(key string, cnt int) ([]string, error) {
+	zs, err := loadAndCheckZSet(key, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []string
+	for i := 0; i < cnt; i++ {
+		node := zs.zsl.findElementByRank(1)
+		if node == nil {
+			return result, nil
+		}
+
+		zs.zsl.delete(node.score, node.value, nil)
+		result = append(result,
+			node.value,
+			strconv.FormatFloat(node.score, 'g', -1, 64))
+	}
+
+	return result, nil
+}
+
+func ZPopMax(key string, cnt int) ([]string, error) {
+	zs, err := loadAndCheckZSet(key, true)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []string
+	for i := 0; i < cnt; i++ {
+		node := zs.zsl.findElementByRank(uint(zs.zsl.length))
+		if node == nil {
+			return result, nil
+		}
+
+		zs.zsl.delete(node.score, node.value, nil)
+		result = append(result,
+			node.value,
+			strconv.FormatFloat(node.score, 'g', -1, 64))
+	}
+
+	return result, nil
+}
+
 // parse score input and return value and true if is open interval
 // example '(5' => 5, true,   '3' => 3, false  '-inf' => math.Inf(-1), false
 func handleFloatScoreStr(str string) (float64, bool, error) {

datastruct/string.go

@@ -13,6 +13,12 @@ func Set(key string, value string, options ...string) {
 	defaultCache.keys.Set(key, &KeyInfo{Type: KeyTypeString, Value: value})
 }
 
+func MSet(kvs ...string) {
+	for i := 0; i < len(kvs)-1; i += 2 {
+		Set(kvs[i], kvs[i+1])
+	}
+}
+
 func Append(key, value string) (ln int, err error) {
 	v, ok := defaultCache.keys.Get(key)
 	if !ok {

protocol/decode.go

@@ -57,6 +57,7 @@ func ReceiveDataAsync(r Reader) *AsyncReceive {
 				if errors.Is(err, io.EOF) || errors.Is(err, net.ErrClosed) {
 					return
 				}
+				log.Println(err)
 				continue
 			}
 
@@ -71,7 +72,7 @@ func DecodeFromReader(r Reader) (rec Receive, err error) {
 	rec = make([]string, 0)
 	b, err := r.ReadBytes('\n')
 	if err != nil {
-		log.Println("readBytes err:", err)
+		//log.Println("readBytes err:", err)
 		return nil, err
 	}
 
@@ -121,6 +122,9 @@ func decodeSingleLine(line []byte) (str string, length int, desc byte, err error
 	case DescriptionSimpleStrings, DescriptionErrors, DescriptionIntegers:
 		str = string(line[1 : len(line)-CRLFLen])
 	default:
+		if string(line) == "PING\r\n" {
+			return "PING", 0, DescriptionSimpleStrings, nil
+		}
 		return "", 0, 0, fmt.Errorf("unsupport protocol: %s", string(line))
 	}
 

redis/command.go

@@ -34,7 +34,6 @@ func NewCommandFromReceive(rec protocol.Receive) *Command {
 		c.Values = append(c.Values, e)
 	}
 
-	log.Println("command: ", c.Command)
 	return c
 }
 
@@ -54,15 +53,21 @@ func (c *Command) ExecuteWithContext(ctx context.Context) chan *protocol.Respons
 	}
 
 	go func() {
-		defer close(rspChan)
+		defer func() {
+			if recover() != nil {
+				log.Println(c.Command, c.Values)
+			}
+		}()
 		f, ok := implementedCommands[c.Command]
 		if !ok {
+			log.Println(c.Command, c.Values)
 			c.putRspToChan(rspChan, protocol.NewResponseWithError(ErrUnknownCommand))
 			return
 		}
 
 		rsp, err := f(c)
 		if err != nil {
+			log.Println(c.Command)
 			c.putRspToChan(rspChan, protocol.NewResponseWithError(err))
 			return
 		}

redis/keys.go

@@ -1,8 +1,6 @@
 package redis
 
 import (
-	"time"
-
 	"github.com/yusank/godis/datastruct"
 	"github.com/yusank/godis/protocol"
 )
@@ -59,7 +57,6 @@ func keyType(c *Command) (*protocol.Response, error) {
 }
 
 func ping(c *Command) (*protocol.Response, error) {
-	time.Sleep(2 * time.Second)
 	return protocol.NewResponseWithSimpleString(RespPong), nil
 }
 

redis/set.cmd.go

@@ -1,6 +1,8 @@
 package redis
 
 import (
+	"strconv"
+
 	"github.com/yusank/godis/datastruct"
 	"github.com/yusank/godis/protocol"
 )
@@ -215,3 +217,33 @@ func sRem(c *Command) (*protocol.Response, error) {
 
 	return protocol.NewResponseWithInteger(int64(cnt)), nil
 }
+
+// SPop .
+func SPop(c *Command) (*protocol.Response, error) {
+	if len(c.Values) < 1 {
+		return nil, ErrCommandArgsNotEnough
+	}
+
+	var (
+		key = c.Values[0]
+		cnt int
+		err error
+	)
+
+	if len(c.Values) > 1 {
+		cnt, err = strconv.Atoi(c.Values[1])
+		if err != nil {
+			return nil, datastruct.ErrNotInteger
+		}
+	}
+
+	values, err := datastruct.SPop(key, cnt)
+	if err == datastruct.ErrNil {
+		return protocol.NewResponseWithEmptyArray(), nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return protocol.NewResponse(true).AppendBulkStrings(values...), nil
+}

redis/set.go

@@ -249,5 +249,66 @@ func zRevRange(c *Command) (*protocol.Response, error) {
 	}
 
 	return protocol.NewResponse(true).AppendBulkStrings(values...), nil
+}
+
+// zPopMin .
+func zPopMin(c *Command) (*protocol.Response, error) {
+	if len(c.Values) < 1 {
+		return nil, ErrCommandArgsNotEnough
+	}
 
+	var (
+		key = c.Values[0]
+		cnt = 1
+		err error
+	)
+
+	if len(c.Values) > 1 {
+		cnt, err = strconv.Atoi(c.Values[1])
+		if err != nil {
+			return nil, datastruct.ErrNotInteger
+		}
+	}
+
+	values, err := datastruct.ZPopMin(key, cnt)
+	if err == datastruct.ErrNil || len(values) == 0 {
+		return protocol.NewResponseWithEmptyArray(), nil
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return protocol.NewResponse(true).AppendBulkStrings(values...), nil
+}
+
+// zPopMax .
+func zPopMix(c *Command) (*protocol.Response, error) {
+	if len(c.Values) < 1 {
+		return nil, ErrCommandArgsNotEnough
+	}
+
+	var (
+		key = c.Values[0]
+		cnt = 1
+		err error
+	)
+
+	if len(c.Values) > 1 {
+		cnt, err = strconv.Atoi(c.Values[1])
+		if err != nil {
+			return nil, datastruct.ErrNotInteger
+		}
+	}
+
+	values, err := datastruct.ZPopMax(key, cnt)
+	if err == datastruct.ErrNil || len(values) == 0 {
+		return protocol.NewResponseWithEmptyArray(), nil
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return protocol.NewResponse(true).AppendBulkStrings(values...), nil
 }