## 測試目的
由於K8s緣故涉獵go語言，發現golang的web框架很多，都號稱高效能標杆；之前一直致力於c++高效能服務端框架研究，出於好奇，想單從效能層面客觀比較一下go的眾多web框架，另一方面也希望看看c++的實現與go語言實現之間究竟存在多大差異。

高效能服務框架評估指標很多，但一般來講吞吐量與QPS是關鍵考量指標，吞吐量衡量頻寬利用率，QPS主要考驗框架排程效能（幾乎所有可稱之為“高效能”的服務框架都沒有吞吐量問題，畢竟網路瓶頸很輕易就達到了）。由於是框架本身QPS測試，為了遮蔽http協議實現差異選擇最精簡的協議頭（協議處理一般不會有鎖，為cpu密集型），因此要求請求/返回報文儘可能小，本文測試基於http協議，返回空報文。

為了實現測試的第二個目的，特將一個自擼的c++服務框架作為c++實現的”磚頭”，加入到對比測試中。此框架尚未開源，其高效能特性保障體現在如下設計上：
* 跨平臺實現socket多路複用，支援：poll、epoll、kqueue、port、select、IOCP等模型
* 採用lock-free演算法
* 執行緒池設計
* socket連線池
* 多級任務佇列
……

PS：
	好吧，這樣一來貌似更接近測試socket服務框架排程效能……
	不要糾結keep-alive，因為wrk使用HTTP/1.1，預設都是keep-alive的

## 測試環境
![env.jpg](https://upload-images.jianshu.io/upload_images/14968752-7406a43f27631d81.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

### 環境設定
ulimit -n 2000
### 壓測工具
wrk
由於環境限制，只能wrk客戶端和待測試服務端在一臺機器上執行

## c++自研框架
* 啟動指令碼：(最大2000個併發連線，2個執行緒處理，http埠8080)
./proxy_server -i2000 -o2000 -w2 -x8080
* 如有條件測試linux系統可自行下載服務端(選擇對應平臺的包)：https://github.com/lazy-luo/smarGate
* http返回報文：
```
$ curl -i http://localhost:8080/
HTTP/1.1 200 OK
Content-Length: 0
Connection: keep-alive
```

* 壓測結果：
```
$wrk -d 100s -c 1024 -t 8 http://localhost:8080/
Running 2m test @ http://localhost:8080/
  8 threads and 1024 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    13.03ms    3.80ms 100.73ms   86.97%
    Req/Sec     9.43k     1.64k   39.35k    88.23%
  7509655 requests in 1.67m, 444.03MB read
  Socket errors: connect 0, read 794, write 2, timeout 0
Requests/sec:  75018.11
Transfer/sec:      4.44MB
```

* 資源佔用：
![proxy_server.jpg](https://upload-images.jianshu.io/upload_images/14968752-bac9fb1760c6424b.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## go-restful框架：
* main_go-restful.go
```
package main
import (
   "github.com/emicklei/go-restful"
   "net/http"
)
func main(){
	ws := new(restful.WebService)
	ws.Route(ws.GET("/").To(hello))
	restful.Add(ws)
	http.ListenAndServe(":8080",nil)
}
func hello(req *restful.Request,resp *restful.Response){
	resp.Write([]byte(""))
}
```

* http返回報文：
```
$curl -i http://localhost:8080/
HTTP/1.1 200 OK
Date: Mon, 21 Oct 2019 03:54:27 GMT
Content-Length: 0
```

* 壓測結果：
```
$wrk -d 100s -c 1024 -t 8 http://localhost:8080/
Running 2m test @ http://localhost:8080/
  8 threads and 1024 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    19.72ms   10.57ms 331.94ms   87.67%
    Req/Sec     6.52k     1.24k   23.75k    80.42%
  5180908 requests in 1.67m, 370.57MB read
  Socket errors: connect 0, read 844, write 3, timeout 0
Requests/sec:  51757.61
Transfer/sec:      3.70MB
```

* 資源佔用：
![go-restful.jpg](https://upload-images.jianshu.io/upload_images/14968752-4188c7b87270312c.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## go-echo框架：
* main_go-echo.go
```
package main
import (
	"net/http"
	"github.com/labstack/echo"
)
func main() {
	e := echo.New()
	e.GET("/", func(c echo.Context) error {
		return c.String(http.StatusOK, "")
	})
	e.Logger.Fatal(e.Start(":8080"))
}
```

* http返回報文：
```
$ curl -i http://localhost:8080/
HTTP/1.1 200 OK
Content-Type: text/plain; charset=UTF-8
Date: Mon, 21 Oct 2019 04:09:24 GMT
Content-Length: 0
```

* 壓測結果：
```
$ wrk -d 100s -c 1024 -t 8 http://localhost:8080/
Running 2m test @ http://localhost:8080/
  8 threads and 1024 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    17.32ms    8.19ms 252.60ms   90.70%
    Req/Sec     7.52k     1.35k   39.96k    80.55%
  5974370 requests in 1.67m, 660.92MB read
  Socket errors: connect 0, read 431, write 67, timeout 0
Requests/sec:  59686.09
Transfer/sec:      6.60MB
```

* 資源佔用：
![go-echo.jpg](https://upload-images.jianshu.io/upload_images/14968752-83ecd53ff43067a5.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## go-iris框架：

* main_go-iris.go
```
package main
import(
	"time"
	"github.com/kataras/iris"
	"github.com/kataras/iris/cache"
)
func main(){
	app := iris.New()
	app.Logger().SetLevel("error")
	app.Get("/",cache.Handler(10*time.Second),writeMarkdown)
	app.Run(iris.Addr(":8080"))
}
func writeMarkdown(ctx iris.Context){
	ctx.Markdown([]byte(""))
}
```
* http返回報文：
```
$ curl -i http://localhost:8080/
HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
Date: Mon, 21 Oct 2019 04:11:59 GMT
Content-Length: 0
```

* 壓測結果：
```
$ wrk -d 100s -c 1024 -t 8 http://localhost:8080/
Running 2m test @ http://localhost:8080/
  8 threads and 1024 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    22.03ms    7.99ms 140.47ms   84.58%
    Req/Sec     5.79k   775.23    19.31k    80.35%
  4608572 requests in 1.67m, 505.43MB read
  Socket errors: connect 0, read 726, write 22, timeout 0
Requests/sec:  46041.23
Transfer/sec:      5.05MB
```

* 資源佔用：
![go-iris.jpg](https://upload-images.jianshu.io/upload_images/14968752-4d0ce01647a332b1.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## go-gin框架
* main_go-gin.go
```
package main
import (
    "fmt"
    "net/http"
    "log"
    "github.com/julienschmidt/httprouter"
)
func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    fmt.Fprint(w, "")
}
func main() {
    router := httprouter.New()
    router.GET("/", Index)
    log.Fatal(http.ListenAndServe(":8080", router))
}
```

* http返回報文：
```
$ curl -i http://localhost:8080/
HTTP/1.1 200 OK
Date: Mon, 21 Oct 2019 04:15:33 GMT
Content-Length: 0
```

* 壓測結果：
```
$ wrk -d 100s -c 1024 -t 8 http://localhost:8080/
Running 2m test @ http://localhost:8080/
  8 threads and 1024 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    16.71ms    7.72ms 268.45ms   87.79%
    Req/Sec     7.71k     1.58k   21.27k    82.12%
  6130281 requests in 1.67m, 438.47MB read
  Socket errors: connect 0, read 693, write 36, timeout 0
Requests/sec:  61243.74
Transfer/sec:      4.38MB
```
* 資源佔用：
![go-gin.jpg](https://upload-images.jianshu.io/upload_images/14968752-4e0e3274352383f8.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## go-chi框架：
* main_go-chi.go
```
package main
import (
    "net/http"
    "github.com/go-chi/chi"
)
func main() {
    r := chi.NewRouter()
    r.Get("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(""))
    })
    http.ListenAndServe(":8080", r)
}
```

* http返回報文：
```
$ curl -i http://localhost:8080/
HTTP/1.1 200 OK
Date: Mon, 21 Oct 2019 04:18:42 GMT
Content-Length: 0
```

* 壓測結果：
```
$ wrk -d 100s -c 1024 -t 8 http://localhost:8080/
Running 2m test @ http://localhost:8080/
  8 threads and 1024 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency    17.17ms    8.47ms 253.47ms   90.07%
    Req/Sec     7.65k     1.42k   26.08k    79.76%
  6071695 requests in 1.67m, 434.28MB read
  Socket errors: connect 0, read 110, write 2, timeout 0
Requests/sec:  60658.49
Transfer/sec:      4.34MB
```

* 資源佔用：
![go-chi.jpg](https://upload-images.jianshu.io/upload_images/14968752-68ca82a3730c5f5c.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

## 結論：
|     -     | cpu-free | mem-usage |   qps    |
| --------- | ------- | -------- | ------- |
| c++        | 15%-20%  | 6M        | 75018.11 |
| go-gin     | 0%-1.5%  | 28M       | 61243.74 |
| go-chi     | 0%-1%    | 28M       | 60658.49 |
| go-echo    | 0%-0.5%  | 28M       | 59686.09 |
| go-restful | 0%-0.5%  | 34M       | 51757.61 |
| go-iris    | 0%-1%    | 37M       | 46041.23 |

* go語言web框架中gin、chi、echo效能相當，gin略顯優勢，iris實測效果不佳；
* go語言與c++語言網路框架比較還是存在一定效能差距，但不是決定性的；
* go語言整體資源耗用大，c++足夠輕量高效；
* go語言真的很易用且簡潔！！就是三方依賴太多 ，拿來主義，問題排查那是相當酸爽...... 當然，隨著依賴包升級你會一直爽 ：）

主流 go-web 服務端框架效能測試

相關文章