UPD。在Golang上测试REST API。12万[＃/秒]不是极限吗？

我注意到Java与GO的对比不是很积极。被大量用户测试。

我决定检查Go是否一切都那么美好。
展望未来，我要说的是，在内存中进行缓存并即时创建JSON时，我设法在8个物理内核上达到了120,000 [＃/秒]。

基本的GET请求脚本：

• 如果数据在内存缓存中找到并且是有效的，则我们从结构中形成JSON
• 如果缓存中没有数据，请在Bolt DB中查找它们，如果找到它，则读取完成的JSON
• 如果Bolt DB中没有数据，那么我们从数据库中请求它们，将它们保存在内存缓存中
• 内存高速缓存中的数据累积在缓冲区通道中，累积大约10,000个元素后，通过一次保存在Bolt DB中将其重置
• 如果数据库中的数据已更改（更新/插入），则将通过pg_notify发送通知，并将缓存中的数据标记为无效，下次读取时，将从数据库中再次读取

根据削减的测试结果，以及测试台的代码GitHub

更新05/06/2020

有机会在Oracle云中进行测试。

• 支架安装在3台服务器上-8核Intel（16个虚拟核），120内存（GB），Oracle Linux 7.7
• NVMe — 6.4 TB NVMe SSD Storage min 250k IOPS (4k block)
• — 8.2 Network Bandwidth (Gbps)
• PostgreSQL — 16 000 [get/sec], oncurrency 1024, 60 [ms]. Get 360 000 000 . JSON 1800 .
• — 100 000 — 120 000 [get/sec], oncurrency 1024, 2 [ms].
• PostgreSQL — 10 000 [insert/sec].
• 2 4 8 Core, .

• JSON Bolt DB 2 HDD, SSD
• PostgreSQL HDD SDD 100
• Bolt DB SDD HDD 100
• JSON " " 10 PostgreSQL SDD
• — Failed requests Concurrency 16 384

,
— GitHub. 4000 , .

, JSON encoder/decode — JSON 2 .

HTTP Get handler JSON

BenchmarkHandler_DeptGetHandler-2         1000000          41277 ns/op     4845.26 MB/s        10941 B/op          259 allocs/op

HTTP Get handler francoispqt/gojay

BenchmarkHandler_DeptGetHandler-2         1000000          13300 ns/op     15036.97 MB/s         3265 B/op           11 allocs/op

:

• PostgreSQL 11 Windows 10, — 30 .
• — 10 000 000 , 100 000 000 .
• JSON 1500 , 1 10 .
• — core i7-3770 — 4 core (8 thread), 16 , HDD (WD 2.0TB WD2000fyyz), SSD (Intel 530 Series).
• ApacheBench, concurrency level 1 4096, 1 000 000 .
• Windows, .
• RAID . .

:

• GET PostgreSQL — HDD ( , JSON ).
• GET PostgreSQL — SSD ( , JSON ). SSD
• GET BOLT DB — HDD (JSON BOLT DB)
• GET BOLT DB — SSD (JSON BOLT DB)
• GET (JSON )

Concurrency Level , ApacheBench " ".

GET PostgreSQL — HDD ( )

GET PostgreSQL — SSD ( )

GET BOLT DB — HDD (JSON BOLT DB)

GET BOLT DB — SSD (JSON BOLT DB)

GET

Oracle

Oracle 3- :

• VM.DenseIO2.8 — 8 Core Intel (16 virtual core), 120 Memory (GB), Oracle Linux 7.7
• NVMe — 6.4 TB NVMe SSD Storage (1 drives) min 250k IOPS (4k block)
• — 8.2 Network Bandwidth (Gbps)
• — PostgreSQL 12. .
• ApacheBench:
  
  • concurrency level 4 16384
  • 10 000 1 000 000 .
  • 2 8 ApacheBench ( ab 1 )

GET

• JSON — 1800 . Dept 10 Emp.
• Dept — 33 000 000, Emp — 330 000 000 .

:

• GET PostgreSQL
• GET JSON BBolt ( 74 )
• GET ( map)

.

Requests per second Concurrency.

Time per req. [ms] Concurrency ( ).

99% percentile [ms] Concurrency.

99% percentile [ms] Concurrency ( ).

backend 100 000 [#/sec] BBolt (oncurrency 128).
1600% , 1464%.
/ NVMe 0,02 [ms] (500 000 IOPS).

Benchmark, HTTP Get handler 13300 ns

BenchmarkHandler_DeptGetHandler-2         1000000          13300 ns/op     15036.97 MB/s         3265 B/op           11 allocs/op

ApacheBench, mean — 0.088 ms.
0.088 — 0.013 = 0.055 ms.
—

:

• net/http.(*conn).serve — (61.85%)
• net/http.(*connReader).backgroundRead — (7.04%)
• runtime.gcBgMarkWorker — (18.30%)

HTTP server (61.85%):

• — net/http.(*conn).readRequest — (9.29%). .
• — net/http.(*response).finishRequest — (21.74%). .
• — net/http.(*ServeMux).ServeHTTP — (23.33%).

readRequest, finishRequest backgroundRead (39.66%), IO Windows — internalpoll.(ioSrv).ExecIO — (24.78%).

让我们看看我们的主要net / http。（* ServeMux）.ServeHTTP处理程序做了什么：

• URL解析和参数处理-github.com/gorilla/mux.(*Route）。匹配-（2.29％）
• 从内存中的结构生成JSON-github.com/francoispqt/gojay.marshal-（9.92％）
• 处理内存中的缓存-（4.53％）