Benchmark: fix build tags

benchmark/client/main.go

@@ -28,12 +28,12 @@ import (
 	"time"
 
 	"golang.org/x/net/context"
-	"golang.org/x/sys/unix"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/benchmark"
 	testpb "google.golang.org/grpc/benchmark/grpc_testing"
 	"google.golang.org/grpc/benchmark/stats"
 	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/internal/syscall"
 )
 
 var (
@@ -82,12 +82,12 @@ func main() {
 	}
 	defer cf.Close()
 	pprof.StartCPUProfile(cf)
-	cpuBeg := getCPUTime()
+	cpuBeg := syscall.GetCPUTime()
 	for _, cc := range ccs {
 		runWithConn(cc, req, warmDeadline, endDeadline)
 	}
 	wg.Wait()
-	cpu := time.Duration(getCPUTime() - cpuBeg)
+	cpu := time.Duration(syscall.GetCPUTime() - cpuBeg)
 	pprof.StopCPUProfile()
 	mf, err := os.Create("/tmp/" + *testName + ".mem")
 	if err != nil {
@@ -185,11 +185,3 @@ func median(percentile float64, h *stats.Histogram) int64 {
 	}
 	panic("should have found a bound")
 }
-
-func getCPUTime() int64 {
-	var ts unix.Timespec
-	if err := unix.ClockGettime(unix.CLOCK_PROCESS_CPUTIME_ID, &ts); err != nil {
-		grpclog.Fatal(err)
-	}
-	return ts.Nano()
-}

benchmark/server/main.go

@@ -30,9 +30,9 @@ import (
 	"syscall"
 	"time"
 
-	"golang.org/x/sys/unix"
 	"google.golang.org/grpc/benchmark"
 	"google.golang.org/grpc/grpclog"
+	grpcsyscall "google.golang.org/grpc/internal/syscall"
 )
 
 var (
@@ -57,14 +57,14 @@ func main() {
 	}
 	defer cf.Close()
 	pprof.StartCPUProfile(cf)
-	cpuBeg := getCPUTime()
+	cpuBeg := grpcsyscall.GetCPUTime()
 	// Launch server in a separate goroutine.
 	stop := benchmark.StartServer(benchmark.ServerInfo{Type: "protobuf", Listener: lis})
 	// Wait on OS terminate signal.
 	ch := make(chan os.Signal, 1)
 	signal.Notify(ch, syscall.SIGTERM)
 	<-ch
-	cpu := time.Duration(getCPUTime() - cpuBeg)
+	cpu := time.Duration(grpcsyscall.GetCPUTime() - cpuBeg)
 	stop()
 	pprof.StopCPUProfile()
 	mf, err := os.Create("/tmp/" + *testName + ".mem")
@@ -80,11 +80,3 @@ func main() {
 	fmt.Println("Server CPU profile:", cf.Name())
 	fmt.Println("Server Mem Profile:", mf.Name())
 }
-
-func getCPUTime() int64 {
-	var ts unix.Timespec
-	if err := unix.ClockGettime(unix.CLOCK_PROCESS_CPUTIME_ID, &ts); err != nil {
-		grpclog.Fatal(err)
-	}
-	return ts.Nano()
-}

benchmark/worker/benchmark_client.go

@@ -23,7 +23,6 @@ import (
 	"math"
 	"runtime"
 	"sync"
-	"syscall"
 	"time"
 
 	"golang.org/x/net/context"
@@ -34,6 +33,7 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/internal/syscall"
 	"google.golang.org/grpc/status"
 	"google.golang.org/grpc/testdata"
 )
@@ -217,9 +217,6 @@ func startBenchmarkClient(config *testpb.ClientConfig) (*benchmarkClient, error)
 		return nil, err
 	}
 
-	rusage := new(syscall.Rusage)
-	syscall.Getrusage(syscall.RUSAGE_SELF, rusage)
-
 	rpcCountPerConn := int(config.OutstandingRpcsPerChannel)
 	bc := &benchmarkClient{
 		histogramOptions: stats.HistogramOptions{
@@ -233,7 +230,7 @@ func startBenchmarkClient(config *testpb.ClientConfig) (*benchmarkClient, error)
 		stop:            make(chan bool),
 		lastResetTime:   time.Now(),
 		closeConns:      closeConns,
-		rusageLastReset: rusage,
+		rusageLastReset: syscall.GetRusage(),
 	}
 
 	if err = performRPCs(config, conns, bc); err != nil {
@@ -335,7 +332,6 @@ func (bc *benchmarkClient) doCloseLoopStreaming(conns []*grpc.ClientConn, rpcCou
 func (bc *benchmarkClient) getStats(reset bool) *testpb.ClientStats {
 	var wallTimeElapsed, uTimeElapsed, sTimeElapsed float64
 	mergedHistogram := stats.NewHistogram(bc.histogramOptions)
-	latestRusage := new(syscall.Rusage)
 
 	if reset {
 		// Merging histogram may take some time.
@@ -350,8 +346,8 @@ func (bc *benchmarkClient) getStats(reset bool) *testpb.ClientStats {
 		}
 
 		wallTimeElapsed = time.Since(bc.lastResetTime).Seconds()
-		syscall.Getrusage(syscall.RUSAGE_SELF, latestRusage)
-		uTimeElapsed, sTimeElapsed = cpuTimeDiff(bc.rusageLastReset, latestRusage)
+		latestRusage := syscall.GetRusage()
+		uTimeElapsed, sTimeElapsed = syscall.CPUTimeDiff(bc.rusageLastReset, latestRusage)
 
 		bc.rusageLastReset = latestRusage
 		bc.lastResetTime = time.Now()
@@ -362,8 +358,7 @@ func (bc *benchmarkClient) getStats(reset bool) *testpb.ClientStats {
 		}
 
 		wallTimeElapsed = time.Since(bc.lastResetTime).Seconds()
-		syscall.Getrusage(syscall.RUSAGE_SELF, latestRusage)
-		uTimeElapsed, sTimeElapsed = cpuTimeDiff(bc.rusageLastReset, latestRusage)
+		uTimeElapsed, sTimeElapsed = syscall.CPUTimeDiff(bc.rusageLastReset, syscall.GetRusage())
 	}
 
 	b := make([]uint32, len(mergedHistogram.Buckets))

benchmark/worker/benchmark_server.go

@@ -26,7 +26,6 @@ import (
 	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 
 	"google.golang.org/grpc"
@@ -35,6 +34,7 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/grpclog"
+	"google.golang.org/grpc/internal/syscall"
 	"google.golang.org/grpc/status"
 	"google.golang.org/grpc/testdata"
 )
@@ -154,15 +154,12 @@ func startBenchmarkServer(config *testpb.ServerConfig, serverPort int) (*benchma
 		grpclog.Fatalf("failed to get port number from server address: %v", err)
 	}
 
-	rusage := new(syscall.Rusage)
-	syscall.Getrusage(syscall.RUSAGE_SELF, rusage)
-
 	return &benchmarkServer{
 		port:            p,
 		cores:           numOfCores,
 		closeFunc:       closeFunc,
 		lastResetTime:   time.Now(),
-		rusageLastReset: rusage,
+		rusageLastReset: syscall.GetRusage(),
 	}, nil
 }
 
@@ -172,9 +169,8 @@ func (bs *benchmarkServer) getStats(reset bool) *testpb.ServerStats {
 	bs.mu.RLock()
 	defer bs.mu.RUnlock()
 	wallTimeElapsed := time.Since(bs.lastResetTime).Seconds()
-	rusageLatest := new(syscall.Rusage)
-	syscall.Getrusage(syscall.RUSAGE_SELF, rusageLatest)
-	uTimeElapsed, sTimeElapsed := cpuTimeDiff(bs.rusageLastReset, rusageLatest)
+	rusageLatest := syscall.GetRusage()
+	uTimeElapsed, sTimeElapsed := syscall.CPUTimeDiff(bs.rusageLastReset, rusageLatest)
 
 	if reset {
 		bs.lastResetTime = time.Now()

internal/syscall/syscall_linux.go

@@ -0,0 +1,66 @@
+// +build !appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package syscall
+
+import (
+	"syscall"
+
+	"golang.org/x/sys/unix"
+	"google.golang.org/grpc/grpclog"
+)
+
+// GetCPUTime returns the how much CPU time has passed since the start of this process.
+func GetCPUTime() int64 {
+	var ts unix.Timespec
+	if err := unix.ClockGettime(unix.CLOCK_PROCESS_CPUTIME_ID, &ts); err != nil {
+		grpclog.Fatal(err)
+	}
+	return ts.Nano()
+}
+
+// Rusage is an alias for syscall.Rusage under linux non-appengine environment.
+// TODO(lyuxuan): use type alias after go1.8 is no longer supported.
+type Rusage syscall.Rusage
+
+// GetRusage returns the resource usage of current process.
+func GetRusage() (rusage *Rusage) {
+	rusage = new(Rusage)
+	syscall.Getrusage(syscall.RUSAGE_SELF, (*syscall.Rusage)(rusage))
+	return
+}
+
+// CPUTimeDiff returns the differences of user CPU time and system CPU time used
+// between two Rusage structs.
+func CPUTimeDiff(first *Rusage, latest *Rusage) (float64, float64) {
+	f := (*syscall.Rusage)(first)
+	l := (*syscall.Rusage)(latest)
+	var (
+		utimeDiffs  = l.Utime.Sec - f.Utime.Sec
+		utimeDiffus = l.Utime.Usec - f.Utime.Usec
+		stimeDiffs  = l.Stime.Sec - f.Stime.Sec
+		stimeDiffus = l.Stime.Usec - f.Stime.Usec
+	)
+
+	uTimeElapsed := float64(utimeDiffs) + float64(utimeDiffus)*1.0e-6
+	sTimeElapsed := float64(stimeDiffs) + float64(stimeDiffus)*1.0e-6
+
+	return uTimeElapsed, sTimeElapsed
+}

internal/syscall/syscall_nonlinux.go

@@ -0,0 +1,47 @@
+// +build !linux appengine
+
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package syscall
+
+import "google.golang.org/grpc/grpclog"
+
+func init() {
+	grpclog.Info("CPU time info is unavailable on non-linux or appengine environment.")
+}
+
+// GetCPUTime returns the how much CPU time has passed since the start of this process.
+// It always returns 0 under non-linux or appengine environment.
+func GetCPUTime() int64 {
+	return 0
+}
+
+// Rusage is an empty struct under non-linux or appengine environment.
+type Rusage struct{}
+
+// GetRusage is a no-op function under non-linux or appengine environment.
+func GetRusage() (rusage *Rusage) {
+	return nil
+}
+
+// CPUTimeDiff returns the differences of user CPU time and system CPU time used
+// between two Rusage structs. It a no-op function for non-linux or appengine environment.
+func CPUTimeDiff(first *Rusage, latest *Rusage) (float64, float64) {
+	return 0, 0
+}