Create & Init Project...

library/net/rpc/warden/benchmark/bench/client/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "client",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["client.go"],
+    importpath = "go-common/library/net/rpc/warden/benchmark/bench/client",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/netutil/breaker:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/rpc/warden/benchmark/bench/proto:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/montanaflynn/stats:go_default_library",
+        "@com_github_gogo_protobuf//proto:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_x_net//context:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/benchmark/bench/client/client.go

@@ -0,0 +1,189 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"reflect"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"go-common/library/net/netutil/breaker"
+	"go-common/library/net/rpc/warden"
+	"go-common/library/net/rpc/warden/benchmark/bench/proto"
+	xtime "go-common/library/time"
+
+	goproto "github.com/gogo/protobuf/proto"
+	"github.com/montanaflynn/stats"
+	"golang.org/x/net/context"
+	"google.golang.org/grpc"
+)
+
+const (
+	iws         = 65535 * 1000
+	iwsc        = 65535 * 10000
+	readBuffer  = 32 * 1024
+	writeBuffer = 32 * 1024
+)
+
+var concurrency = flag.Int("c", 50, "concurrency")
+var total = flag.Int("t", 500000, "total requests for all clients")
+var host = flag.String("s", "127.0.0.1:8972", "server ip and port")
+var isWarden = flag.Bool("w", true, "is warden or grpc client")
+var strLen = flag.Int("l", 600, "the length of the str")
+
+func wardenCli() proto.HelloClient {
+	log.Println("start warden cli")
+	client := warden.NewClient(&warden.ClientConfig{
+		Dial:    xtime.Duration(time.Second * 10),
+		Timeout: xtime.Duration(time.Second * 10),
+		Breaker: &breaker.Config{
+			Window:  xtime.Duration(3 * time.Second),
+			Sleep:   xtime.Duration(3 * time.Second),
+			Bucket:  10,
+			Ratio:   0.3,
+			Request: 20,
+		},
+	},
+		grpc.WithInitialWindowSize(iws),
+		grpc.WithInitialConnWindowSize(iwsc),
+		grpc.WithReadBufferSize(readBuffer),
+		grpc.WithWriteBufferSize(writeBuffer))
+	conn, err := client.Dial(context.Background(), *host)
+	if err != nil {
+		log.Fatalf("did not connect: %v", err)
+	}
+	cli := proto.NewHelloClient(conn)
+	return cli
+}
+
+func grpcCli() proto.HelloClient {
+	log.Println("start grpc cli")
+	conn, err := grpc.Dial(*host, grpc.WithInsecure(),
+		grpc.WithInitialWindowSize(iws),
+		grpc.WithInitialConnWindowSize(iwsc),
+		grpc.WithReadBufferSize(readBuffer),
+		grpc.WithWriteBufferSize(writeBuffer))
+	if err != nil {
+		log.Fatalf("did not connect: %v", err)
+	}
+	cli := proto.NewHelloClient(conn)
+	return cli
+}
+
+func main() {
+	flag.Parse()
+	c := *concurrency
+	m := *total / c
+	var wg sync.WaitGroup
+	wg.Add(c)
+	log.Printf("concurrency: %d\nrequests per client: %d\n\n", c, m)
+
+	args := prepareArgs()
+	b, _ := goproto.Marshal(args)
+	log.Printf("message size: %d bytes\n\n", len(b))
+
+	var trans uint64
+	var transOK uint64
+	d := make([][]int64, c)
+	for i := 0; i < c; i++ {
+		dt := make([]int64, 0, m)
+		d = append(d, dt)
+	}
+	var cli proto.HelloClient
+	if *isWarden {
+		cli = wardenCli()
+	} else {
+		cli = grpcCli()
+	}
+	//warmup
+	cli.Say(context.Background(), args)
+
+	totalT := time.Now().UnixNano()
+	for i := 0; i < c; i++ {
+		go func(i int) {
+			for j := 0; j < m; j++ {
+				t := time.Now().UnixNano()
+				reply, err := cli.Say(context.Background(), args)
+				t = time.Now().UnixNano() - t
+				d[i] = append(d[i], t)
+				if err == nil && reply.Field1 == "OK" {
+					atomic.AddUint64(&transOK, 1)
+				}
+				atomic.AddUint64(&trans, 1)
+			}
+			wg.Done()
+		}(i)
+
+	}
+	wg.Wait()
+
+	totalT = time.Now().UnixNano() - totalT
+	totalT = totalT / 1e6
+	log.Printf("took %d ms for %d requests\n", totalT, *total)
+	totalD := make([]int64, 0, *total)
+	for _, k := range d {
+		totalD = append(totalD, k...)
+	}
+	totalD2 := make([]float64, 0, *total)
+	for _, k := range totalD {
+		totalD2 = append(totalD2, float64(k))
+	}
+
+	mean, _ := stats.Mean(totalD2)
+	median, _ := stats.Median(totalD2)
+	max, _ := stats.Max(totalD2)
+	min, _ := stats.Min(totalD2)
+	tp99, _ := stats.Percentile(totalD2, 99)
+	tp999, _ := stats.Percentile(totalD2, 99.9)
+
+	log.Printf("sent     requests    : %d\n", *total)
+	log.Printf("received requests_OK : %d\n", atomic.LoadUint64(&transOK))
+	log.Printf("throughput  (TPS)    : %d\n", int64(c*m)*1000/totalT)
+	log.Printf("mean: %v ms, median: %v ms, max: %v ms, min: %v ms, p99: %v ms, p999:%v ms\n", mean/1e6, median/1e6, max/1e6, min/1e6, tp99/1e6, tp999/1e6)
+
+}
+
+func prepareArgs() *proto.BenchmarkMessage {
+	b := true
+	var i int32 = 120000
+	var i64 int64 = 98765432101234
+	var s = "许多往事在眼前一幕一幕，变的那麼模糊"
+	repeat := *strLen / (8 * 54)
+	if repeat == 0 {
+		repeat = 1
+	}
+	var str string
+	for i := 0; i < repeat; i++ {
+		str += s
+	}
+	var args proto.BenchmarkMessage
+
+	v := reflect.ValueOf(&args).Elem()
+	num := v.NumField()
+	for k := 0; k < num; k++ {
+		field := v.Field(k)
+		if field.Type().Kind() == reflect.Ptr {
+			switch v.Field(k).Type().Elem().Kind() {
+			case reflect.Int, reflect.Int32:
+				field.Set(reflect.ValueOf(&i))
+			case reflect.Int64:
+				field.Set(reflect.ValueOf(&i64))
+			case reflect.Bool:
+				field.Set(reflect.ValueOf(&b))
+			case reflect.String:
+				field.Set(reflect.ValueOf(&str))
+			}
+		} else {
+			switch field.Kind() {
+			case reflect.Int, reflect.Int32, reflect.Int64:
+				field.SetInt(9876543)
+			case reflect.Bool:
+				field.SetBool(true)
+			case reflect.String:
+				field.SetString(str)
+			}
+		}
+	}
+	return &args
+}

library/net/rpc/warden/benchmark/bench/proto/BUILD

@@ -0,0 +1,56 @@
+load(
+    "@io_bazel_rules_go//proto:def.bzl",
+    "go_proto_library",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+proto_library(
+    name = "grpc_proto",
+    srcs = ["hello.proto"],
+    tags = ["automanaged"],
+    deps = ["@gogo_special_proto//github.com/gogo/protobuf/gogoproto"],
+)
+
+go_proto_library(
+    name = "grpc_go_proto",
+    compilers = ["@io_bazel_rules_go//proto:gogofast_grpc"],
+    importpath = "go-common/library/net/rpc/warden/benchmark/bench/proto",
+    proto = ":grpc_proto",
+    tags = ["automanaged"],
+    deps = ["@com_github_gogo_protobuf//gogoproto:go_default_library"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [],
+    embed = [":grpc_go_proto"],
+    importpath = "go-common/library/net/rpc/warden/benchmark/bench/proto",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@com_github_gogo_protobuf//gogoproto:go_default_library",
+        "@com_github_golang_protobuf//proto:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+        "@org_golang_x_net//context:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/benchmark/bench/proto/hello.proto

@@ -0,0 +1,60 @@
+syntax = "proto3";
+package grpc;
+
+import "github.com/gogo/protobuf/gogoproto/gogo.proto";
+
+option optimize_for = SPEED;
+option (gogoproto.goproto_enum_prefix_all) = false;
+option (gogoproto.goproto_getters_all) = false;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+
+service Hello {
+  // Sends a greeting
+  rpc Say (BenchmarkMessage) returns (BenchmarkMessage) {}
+}
+
+
+message BenchmarkMessage {
+    string field1 = 1;
+    string field9 = 9;
+    string field18 = 18;
+    bool field80 = 80;
+    bool field81 = 81;
+    int32 field2 = 2;
+    int32 field3 = 3;
+    int32 field280 = 280;
+    int32 field6 = 6;
+    int64 field22 = 22;
+    string field4 = 4;
+    fixed64 field5 = 5;
+    bool field59 = 59;
+    string field7 = 7;
+    int32 field16 = 16;
+    int32 field130 = 130;
+    bool field12 = 12;
+    bool field17 = 17;
+    bool field13 = 13;
+    bool field14 = 14;
+    int32 field104 = 104;
+    int32 field100 = 100;
+    int32 field101 = 101;
+    string field102 = 102;
+    string field103 = 103;
+    int32 field29 = 29;
+    bool field30 = 30;
+    int32 field60 = 60;
+    int32 field271 = 271;
+    int32 field272 = 272;
+    int32 field150 = 150;
+    int32 field23 = 23;
+    bool field24 = 24 ;
+    int32 field25 = 25 ;
+    bool field78 = 78;
+    int32 field67 = 67;
+    int32 field68 = 68;
+    int32 field128 = 128;
+    string field129 = 129;
+    int32 field131 = 131;
+}

library/net/rpc/warden/benchmark/bench/server/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "server",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["server.go"],
+    importpath = "go-common/library/net/rpc/warden/benchmark/bench/server",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/rpc/warden/benchmark/bench/proto:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/prometheus/client_golang/prometheus/promhttp:go_default_library",
+        "@org_golang_google_grpc//:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/benchmark/bench/server/server.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"log"
+	"net"
+	"net/http"
+	_ "net/http/pprof"
+	"sync/atomic"
+	"time"
+
+	"go-common/library/net/rpc/warden"
+	"go-common/library/net/rpc/warden/benchmark/bench/proto"
+	xtime "go-common/library/time"
+
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"google.golang.org/grpc"
+)
+
+const (
+	iws         = 65535 * 1000
+	iwsc        = 65535 * 10000
+	readBuffer  = 32 * 1024
+	writeBuffer = 32 * 1024
+)
+
+var reqNum uint64
+
+type Hello struct{}
+
+func (t *Hello) Say(ctx context.Context, args *proto.BenchmarkMessage) (reply *proto.BenchmarkMessage, err error) {
+	s := "OK"
+	var i int32 = 100
+	args.Field1 = s
+	args.Field2 = i
+	atomic.AddUint64(&reqNum, 1)
+	return args, nil
+}
+
+var host = flag.String("s", "0.0.0.0:8972", "listened ip and port")
+var isWarden = flag.Bool("w", true, "is warden or grpc client")
+
+func main() {
+	go func() {
+		log.Println("run http at :6060")
+		http.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {
+			h := promhttp.Handler()
+			h.ServeHTTP(w, r)
+		})
+		log.Println(http.ListenAndServe("0.0.0.0:6060", nil))
+	}()
+
+	flag.Parse()
+
+	go stat()
+	if *isWarden {
+		runWarden()
+	} else {
+		runGrpc()
+	}
+}
+
+func runGrpc() {
+	log.Println("run grpc")
+	lis, err := net.Listen("tcp", *host)
+	if err != nil {
+		log.Fatalf("failed to listen: %v", err)
+	}
+	s := grpc.NewServer(grpc.InitialWindowSize(iws),
+		grpc.InitialConnWindowSize(iwsc),
+		grpc.ReadBufferSize(readBuffer),
+		grpc.WriteBufferSize(writeBuffer))
+	proto.RegisterHelloServer(s, &Hello{})
+	s.Serve(lis)
+}
+
+func runWarden() {
+	log.Println("run warden")
+	s := warden.NewServer(&warden.ServerConfig{Timeout: xtime.Duration(time.Second * 3)},
+		grpc.InitialWindowSize(iws),
+		grpc.InitialConnWindowSize(iwsc),
+		grpc.ReadBufferSize(readBuffer),
+		grpc.WriteBufferSize(writeBuffer))
+	proto.RegisterHelloServer(s.Server(), &Hello{})
+	s.Run(*host)
+}
+
+func stat() {
+	ticker := time.NewTicker(time.Second * 5)
+	defer ticker.Stop()
+	var last uint64
+	lastTs := uint64(time.Now().UnixNano())
+	for {
+		<-ticker.C
+		now := atomic.LoadUint64(&reqNum)
+		nowTs := uint64(time.Now().UnixNano())
+		qps := (now - last) * 1e6 / ((nowTs - lastTs) / 1e3)
+		last = now
+		lastTs = nowTs
+		log.Println("qps:", qps)
+	}
+}

library/net/rpc/warden/benchmark/helloworld/client.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+go build -o client greeter_client.go
+echo size 100 concurrent 30
+./client -s 100 -c 30
+echo size 1000 concurrent 30
+./client -s 1000 -c 30
+echo size 10000 concurrent 30
+./client -s 10000 -c 30
+echo size 100 concurrent 300
+./client -s 100 -c 300
+echo size 1000 concurrent 300
+./client -s 1000 -c 300
+echo size 10000 concurrent 300
+./client -s 10000 -c 300
+rm client

library/net/rpc/warden/benchmark/helloworld/client/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "client",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["greeter_client.go"],
+    importpath = "go-common/library/net/rpc/warden/benchmark/helloworld/client",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/netutil/breaker:go_default_library",
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/rpc/warden/proto/testproto:go_default_library",
+        "//library/time:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/benchmark/helloworld/client/greeter_client.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"math/rand"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"go-common/library/net/netutil/breaker"
+	"go-common/library/net/rpc/warden"
+	pb "go-common/library/net/rpc/warden/proto/testproto"
+	xtime "go-common/library/time"
+)
+
+var (
+	ccf = &warden.ClientConfig{
+		Dial:    xtime.Duration(time.Second * 10),
+		Timeout: xtime.Duration(time.Second * 10),
+		Breaker: &breaker.Config{
+			Window:  xtime.Duration(3 * time.Second),
+			Sleep:   xtime.Duration(3 * time.Second),
+			Bucket:  10,
+			Ratio:   0.3,
+			Request: 20,
+		},
+	}
+	cli         pb.GreeterClient
+	wg          sync.WaitGroup
+	reqSize     int
+	concurrency int
+	request     int
+	all         int64
+)
+
+func init() {
+	flag.IntVar(&reqSize, "s", 10, "request size")
+	flag.IntVar(&concurrency, "c", 10, "concurrency")
+	flag.IntVar(&request, "r", 1000, "request per routine")
+}
+
+func main() {
+	flag.Parse()
+	name := randSeq(reqSize)
+	cli = newClient()
+	for i := 0; i < concurrency; i++ {
+		wg.Add(1)
+		go sayHello(&pb.HelloRequest{Name: name})
+	}
+	wg.Wait()
+	fmt.Printf("per request cost %v\n", all/int64(request*concurrency))
+
+}
+
+func sayHello(in *pb.HelloRequest) {
+	defer wg.Done()
+	now := time.Now()
+	for i := 0; i < request; i++ {
+		cli.SayHello(context.TODO(), in)
+	}
+	delta := time.Since(now)
+	atomic.AddInt64(&all, int64(delta/time.Millisecond))
+}
+
+var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+
+func randSeq(n int) string {
+	b := make([]rune, n)
+	for i := range b {
+		b[i] = letters[rand.Intn(len(letters))]
+	}
+	return string(b)
+}
+
+func newClient() (cli pb.GreeterClient) {
+	client := warden.NewClient(ccf)
+	conn, err := client.Dial(context.TODO(), "127.0.0.1:9999")
+	if err != nil {
+		return
+	}
+	cli = pb.NewGreeterClient(conn)
+	return
+}

library/net/rpc/warden/benchmark/helloworld/server/BUILD

@@ -0,0 +1,41 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+)
+
+go_binary(
+    name = "server",
+    embed = [":go_default_library"],
+    tags = ["automanaged"],
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = ["greeter_server.go"],
+    importpath = "go-common/library/net/rpc/warden/benchmark/helloworld/server",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/rpc/warden:go_default_library",
+        "//library/net/rpc/warden/proto/testproto:go_default_library",
+        "//library/time:go_default_library",
+        "//vendor/github.com/prometheus/client_golang/prometheus/promhttp:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

library/net/rpc/warden/benchmark/helloworld/server/greeter_server.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"go-common/library/net/rpc/warden"
+	pb "go-common/library/net/rpc/warden/proto/testproto"
+	xtime "go-common/library/time"
+
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+var (
+	config = &warden.ServerConfig{Timeout: xtime.Duration(time.Second)}
+)
+
+func main() {
+	newServer()
+}
+
+type hello struct {
+}
+
+func (s *hello) SayHello(c context.Context, in *pb.HelloRequest) (out *pb.HelloReply, err error) {
+	out = new(pb.HelloReply)
+	out.Message = in.Name
+	return
+}
+
+func (s *hello) StreamHello(ss pb.Greeter_StreamHelloServer) error {
+	return nil
+}
+func newServer() {
+	server := warden.NewServer(config)
+	pb.RegisterGreeterServer(server.Server(), &hello{})
+	go func() {
+		http.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {
+			h := promhttp.Handler()
+			h.ServeHTTP(w, r)
+		})
+		http.ListenAndServe("0.0.0.0:9998", nil)
+	}()
+	err := server.Run(":9999")
+	if err != nil {
+		return
+	}
+
+}