golang redis memcached performance rps test

main.go

package main

import (
	"log"
	"time"

	"github.com/garyburd/redigo/redis"
	"github.com/youtube/vitess/go/pools"
	"golang.org/x/net/context"
	"sync"
	//	"runtime"

	"github.com/rainycape/memcache"
)


type ResourceConn struct {
	redis.Conn
}

func (r ResourceConn) Close() {
	r.Conn.Close()
}

func main() {
	//	runtime.GOMAXPROCS(1)

	parallel := 1000
	iter := 1000
	p := pools.NewResourcePool(func() (pools.Resource, error) {
		c, err := redis.Dial("tcp", ":6379")
		return ResourceConn{c}, err
	}, 100, 1000000, time.Minute)
	defer p.Close()

	redisSetHelper(p)

	var start, end time.Time
	var wg *sync.WaitGroup

	log.Println("Start redis test bench")
	wg = &sync.WaitGroup{}
	start = time.Now()
	for i := 0; i < parallel; i++ {
		wg.Add(1)
		go redisWorker(p, wg, iter)
	}
	wg.Wait()
	end = time.Now()
	log.Println("requests per second", int64(parallel*iter)/((end.UnixNano()-start.UnixNano())/1000000000))

	memcachedClient, err := memcache.New("127.0.0.1:11211")
	memcachedClient.SetTimeout(time.Second * 10)
	memcachedClient.SetMaxIdleConnsPerAddr(100)
	memcachedClient.Set(&memcache.Item{Key: "key", Value: []byte("data")})
	if err != nil {
		panic(err)
	}

	log.Println("Start memcached test bench")
	wg = &sync.WaitGroup{}
	start = time.Now()
	for i := 0; i < parallel; i++ {
		wg.Add(1)
		go memcachedWorker(memcachedClient, wg, iter)
	}
	wg.Wait()
	end = time.Now()
	log.Println("requests per second", int64(parallel*iter)/((end.UnixNano()-start.UnixNano())/1000000000))

}

func memcachedWorker(m *memcache.Client, wg *sync.WaitGroup, n int) {
	for i := 0; i < n; i++ {

		_, err := m.Get("key")

		if err != nil {
			panic(err)
		}
	}
	wg.Done()
}


func redisSetHelper(p *pools.ResourcePool) {
	ctx := context.TODO()

	r, err := p.Get(ctx)
	if err != nil {
		panic(err)
	}
	c := r.(ResourceConn)

	_, err = c.Do("SET", "key", "data")
	if err != nil {
		panic(err)
	}
	p.Put(r)
}

func redisWorker(p *pools.ResourcePool, wg *sync.WaitGroup, n int) {
	for i := 0; i < n; i++ {
		ctx := context.TODO()

		r, err := p.Get(ctx)
		if err != nil {
			panic(err)
		}
		c := r.(ResourceConn)

		_, err = c.Do("GET", "key")
		if err != nil {
			panic(err)
		}
		p.Put(r)

	}
	wg.Done()
}

  # go run main.go

2016/11/04 14:10:37 Start redis test bench
2016/11/04 14:10:44 requests per second 142857
2016/11/04 14:10:44 Start memcached test bench
2016/11/04 14:10:47 requests per second 333333

cpu
redis 100%
memcached use over 400%

  # redis-benchmark -q -n 100000
PING_INLINE: 140449.44 requests per second
PING_BULK: 140449.44 requests per second
SET: 141442.72 requests per second
GET: 141242.94 requests per second

Intel(R) Core(TM) i7 CPU X 980 @ 3.33GHz