func main()

in benchmark/client/main.go [60:182]
98 lines of code
12 McCabe index (conditional complexity)

func main() {
	flag.Parse()

	n := *concurrency
	m := *total / n

	log.Printf("Servers: %+v\n\n", *ip)
	log.Printf("concurrency: %d\nrequests per client: %d\n\n", n, m)

	var wg sync.WaitGroup
	wg.Add(n * m)

	d := make([][]int64, n, n)
	var trans uint64
	var transOK uint64

	totalT := time.Now().UnixNano()
	for i := 0; i < n; i++ {
		dt := make([]int64, 0, m)
		d = append(d, dt)

		go func(ii int) {
			client := getty.NewTCPClient(
				getty.WithServerAddress(*ip),
				getty.WithConnectionNumber(*connections),
				getty.WithClientTaskPool(taskPool),
			)

			var tmpSession getty.Session
			NewHelloClientSession := func(session getty.Session) (err error) {
				pkgHandler := &PackageHandler{}
				EventListener := &MessageHandler{}

				EventListener.SessionOnOpen = func(session getty.Session) {
					tmpSession = session
				}

				tcpConn, ok := session.Conn().(*net.TCPConn)
				if !ok {
					panic(fmt.Sprintf("newSession: %s, session.conn{%#v} is not tcp connection", session.Stat(), session.Conn()))
				}

				if err = tcpConn.SetNoDelay(true); err != nil {
					return err
				}
				if err = tcpConn.SetKeepAlive(true); err != nil {
					return err
				}
				if err = tcpConn.SetKeepAlivePeriod(10 * time.Second); err != nil {
					return err
				}
				if err = tcpConn.SetReadBuffer(262144); err != nil {
					return err
				}
				if err = tcpConn.SetWriteBuffer(524288); err != nil {
					return err
				}

				session.SetName("hello")
				session.SetMaxMsgLen(128 * 1024) // max message package length is 128k
				session.SetReadTimeout(time.Second)
				session.SetWriteTimeout(5 * time.Second)
				session.SetCronPeriod(int(CronPeriod / 1e6))
				session.SetWaitTime(time.Second)

				session.SetPkgHandler(pkgHandler)
				session.SetEventListener(EventListener)
				return nil
			}

			client.RunEventLoop(NewHelloClientSession)

			for j := 0; j < m; j++ {
				atomic.AddUint64(&trans, 1)

				t := time.Now().UnixNano()
				msg := buildSendMsg()
				_, _, err := tmpSession.WritePkg(msg, WritePkgTimeout)
				if err != nil {
					log.Printf("Err:session.WritePkg(session{%s}, error{%v}", tmpSession.Stat(), err)
				}

				atomic.AddUint64(&transOK, 1)

				t = time.Now().UnixNano() - t
				d[ii] = append(d[ii], t)

				wg.Done()
			}

			client.Close()
		}(i)
	}

	wg.Wait()

	totalT = time.Now().UnixNano() - totalT
	totalT = totalT / 1000000
	log.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)
	p99, _ := stats.Percentile(totalD2, 99.9)

	log.Printf("sent     requests    : %d\n", n*m)
	log.Printf("received requests    : %d\n", atomic.LoadUint64(&trans))
	log.Printf("received requests_OK : %d\n", atomic.LoadUint64(&transOK))
	log.Printf("throughput  (TPS)    : %d\n", int64(n*m)*1000/totalT)
	log.Printf("mean: %.f ns, median: %.f ns, max: %.f ns, min: %.f ns, p99: %.f ns\n", mean, median, max, min, p99)
	log.Printf("mean: %d ms, median: %d ms, max: %d ms, min: %d ms, p99: %d ms\n", int64(mean/1000000), int64(median/1000000), int64(max/1000000), int64(min/1000000), int64(p99/1000000))
}