func main() {
server1 := clientselector.ServerPair{Network: "tcp", Address: "127.0.0.1:8972"}
server2 := clientselector.ServerPair{Network: "tcp", Address: "127.0.0.1:8973"}
servers := []clientselector.ServerPair{server1, server2}
s := clientselector.NewMultiClientSelector(servers, rpcx.RoundRobin, 10*time.Second)
for i := 0; i < 10; i++ {
callServer(s)
}
}
func main() {
server1 := clientselector.ServerPair{Network: "tcp", Address: "127.0.0.1:8972"}
server2 := clientselector.ServerPair{Network: "tcp", Address: "127.0.0.1:8973"}
servers := []clientselector.ServerPair{server1, server2}
s := clientselector.NewMultiClientSelector(servers, rpcx.RandomSelect, 10*time.Second)
clientPool := &sync.Pool{
New: func() interface{} {
return rpcx.NewClient(s)
},
}
for i := 0; i < 10000; i++ {
callServer(clientPool, s)
}
}
func main() {
flag.Parse()
n := *concurrency
m := *total / n
servers := strings.Split(*host, ",")
var serverPairs []clientselector.ServerPair
for _, server := range servers {
serverPairs = append(serverPairs, clientselector.ServerPair{Network: "tcp", Address: server})
}
fmt.Printf("Servers: %+v\n\n", serverPairs)
fmt.Printf("concurrency: %d\nrequests per client: %d\n\n", n, m)
serviceMethodName := "Hello.Say"
args := prepareArgs()
b := make([]byte, 1024*1024)
i, _ := args.MarshalTo(b)
fmt.Printf("message size: %d bytes\n\n", i)
var wg sync.WaitGroup
wg.Add(n * m)
var trans uint64
var transOK uint64
d := make([][]int64, n, n)
//it contains warmup time but we can ignore it
totalT := time.Now().UnixNano()
for i := 0; i < n; i++ {
dt := make([]int64, 0, m)
d = append(d, dt)
go func(i int) {
s := clientselector.NewMultiClientSelector(serverPairs, rpcx.RoundRobin, 10*time.Second)
client := rpcx.NewClient(s)
client.ClientCodecFunc = codec.NewProtobufClientCodec
var reply BenchmarkMessage
//warmup
for j := 0; j < 5; j++ {
client.Call(serviceMethodName, args, &reply)
}
for j := 0; j < m; j++ {
t := time.Now().UnixNano()
err := client.Call(serviceMethodName, args, &reply)
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()
}
client.Close()
}(i)
}
wg.Wait()
totalT = time.Now().UnixNano() - totalT
totalT = totalT / 1000000
fmt.Printf("took %d ms for %d requests", totalT, n*m)
totalD := make([]int64, 0, n*m)
for _, k := range d {
totalD = append(totalD, k...)
}
totalD2 := make([]float64, 0, n*m)
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)
fmt.Printf("sent requests : %d\n", n*m)
fmt.Printf("received requests : %d\n", atomic.LoadUint64(&trans))
fmt.Printf("received requests_OK : %d\n", atomic.LoadUint64(&transOK))
fmt.Printf("throughput (TPS) : %d\n", int64(n*m)*1000/totalT)
fmt.Printf("mean: %.f ns, median: %.f ns, max: %.f ns, min: %.f ns\n", mean, median, max, min)
fmt.Printf("mean: %d ms, median: %d ms, max: %d ms, min: %d ms\n", int64(mean/1000000), int64(median/1000000), int64(max/1000000), int64(min/1000000))
}