๐ฅ_๊ณ ์ฑ๋ฅ_๋์์ฑ_ํ๋ ์์ํฌ_์ ํ_๊ธฐ์ _๊ฒฐ์ [20251229165950]
Source: Dev.to
์๊ฐ
์๋ง์ ํ๋ก๋์ ํ๊ฒฝ ๋ฌธ์ ๋ฅผ ๊ฒช์ด์จ ์๋์ด ์์ง๋์ด๋ก์, ๊ณ ๋์์ฑ ์๋๋ฆฌ์ค์์ ์ฌ๋ฐ๋ฅธ ๊ธฐ์ ์คํ์ ์ ํํ๋ ๊ฒ์ด ์ผ๋ง๋ ์ค์ํ์ง ๊น์ด ์ดํดํ๊ณ ์์ต๋๋ค.
์ต๊ทผ ์ ๋ ์ผ์ผ ํ์ฑ ์ฌ์ฉ์ 1์ฒ๋ง ๋ช ์ ๋ณด์ ํ ๋ํ ์ ์์๊ฑฐ๋ ํ๋ซํผ ์ฌ๊ตฌ์ถ ํ๋ก์ ํธ์ ์ฐธ์ฌํ์ต๋๋ค. ์ด ๊ฒฝํ์ ํตํด ๊ทนํ ๋ถํ ์ํฉ์์ ์น ํ๋ ์์ํฌ์ ์ฑ๋ฅ์ ์ฌ๊ณ ํ๊ฒ ๋์์ต๋๋ค. ์๋๋ ์ฐ๋ฆฌ ํ์ด 6๊ฐ์๊ฐ ์ํํ ์คํธ๋ ์ค ํ ์คํธ์ ๋ชจ๋ํฐ๋ง ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ ํ๋ ์์ํฌ ์ฑ๋ฅ ๋ถ์์ ๋๋ค.
์ผ๋ฐ์ ์ธ ์ฑ๋ฅ ๊ณผ์
| ์๋๋ฆฌ์ค | ์ค๋ช |
|---|---|
| ํผํฌ ํธ๋ํฝ ์ ํ ํ์ด์ง | ์ฃผ์ ํ๋ก๋ชจ์ (์: Doubleโฏ11) ๊ธฐ๊ฐ ๋์ ์ ํ ์์ธ ํ์ด์ง๋ ์ด๋น ์์ญ๋ง ๊ฑด์ ์์ฒญ์ ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค. ์ด๋ ๋์ ์ฒ๋ฆฌ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ํฐ ๋ถ๋ด์ ์ค๋๋ค. |
| ๊ฒฐ์ ๊ฒ์ดํธ์จ์ด | ์ด์ ์ง์ฐ ์๋ต ์๊ฐ์ ์๊ตฌํ๋ ๋จ๊ธฐ๊ฐ ์ฐ๊ฒฐ์ ๋๋์ผ๋ก ์ฒ๋ฆฌํด์ผ ํ๋ฉฐ, ์ด๋ ์ฐ๊ฒฐ ๊ด๋ฆฌ ํจ์จ์ฑ๊ณผ ๋น๋๊ธฐ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ ์ํํฉ๋๋ค. |
| ์ค์๊ฐ ๋ถ์ | ์ฌ์ฉ์ ํ๋ ๋ฐ์ดํฐ์ ์ง์์ ์ธ ์ง๊ณ๋ ๋์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ ์ฒ๋ฆฌ๋๊ณผ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ ํจ์จ์ฑ์ ์๊ตฌํฉ๋๋ค. |
| ์ฅ๊ธฐ ์ฐ๊ฒฐ ํธ๋ํฝ | ์ ์ฒด ํธ๋ํฝ์ 70โฏ% ์ด์์ด ์ง์ ์ฐ๊ฒฐ์ ์ฌ์ฉํ๋ฏ๋ก ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ ๋ฐ ์ง์ฐ ์๊ฐ์ด ํต์ฌ ์์๊ฐ ๋ฉ๋๋ค. |
1๏ธโฃ ์ฅ๊ธฐ ์ฐ๊ฒฐ ์๋๋ฆฌ์ค โ ํต์ฌ ๋น์ฆ๋์ค ํธ๋ํฝ
| ํ๋ ์์ํฌ | QPS | ํ๊ท ์ง์ฐ ์๊ฐ | P99 ์ง์ฐ ์๊ฐ | ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ | CPU ์ฌ์ฉ๋ |
|---|---|---|---|---|---|
| Tokio | 340,130.92 | 1.22โฏms | 5.96โฏms | 128โฏMB | 45โฏ% |
| Hyperlane | 334,888.27 | 3.10โฏms | 13.94โฏms | 96โฏMB | 42โฏ% |
| Rocket | 298,945.31 | 1.42โฏms | 6.67โฏms | 156โฏMB | 48โฏ% |
| Rust std lib | 291,218.96 | 1.64โฏms | 8.62โฏms | 84โฏMB | 44โฏ% |
| Gin | 242,570.16 | 1.67โฏms | 4.67โฏms | 112โฏMB | 52โฏ% |
| Go std lib | 234,178.93 | 1.58โฏms | 1.15โฏms | 98โฏMB | 49โฏ% |
| Node std lib | 139,412.13 | 2.58โฏms | 0.84โฏms | 186โฏMB | 65โฏ% |
2๏ธโฃ ์ฅ๊ธฐ ์ฐ๊ฒฐ ์๋๋ฆฌ์ค โ ์์ธ ๋ฉํธ๋ฆญ
| Framework | QPS | Avg. Latency | Error Rate | Throughput | Conn. Setup Time |
|---|---|---|---|---|---|
| Hyperlane | 316,211.63 | 3.162โฏms | 0โฏ% | 32,115.24โฏKB/s | 0.3โฏms |
| Tokio | 308,596.26 | 3.240โฏms | 0โฏ% | 28,026.81โฏKB/s | 0.3โฏms |
| Rocket | 267,931.52 | 3.732โฏms | 0โฏ% | 70,907.66โฏKB/s | 0.2โฏms |
| Rust std lib | 260,514.56 | 3.839โฏms | 0โฏ% | 23,660.01โฏKB/s | 21.2โฏms |
| Go std lib | 226,550.34 | 4.414โฏms | 0โฏ% | 34,071.05โฏKB/s | 0.2โฏms |
| Gin | 224,296.16 | 4.458โฏms | 0โฏ% | 31,760.69โฏKB/s | 0.2โฏms |
| Node std lib | 85,357.18 | 11.715โฏms | 81.2โฏ% | 4,961.70โฏKB/s | 33.5โฏms |
3๏ธโฃ ๋จ๊ธฐ ์ฐ๊ฒฐ ์๋๋ฆฌ์ค โ ํต์ฌ ๋น์ฆ๋์ค (๊ฒฐ์ , ๋ก๊ทธ์ธ)
| ํ๋ ์์ํฌ | QPS | ํ๊ท ์ง์ฐ์๊ฐ | ์ฐ๊ฒฐ ์ค์ ์๊ฐ | ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ | ์ค๋ฅ์จ |
|---|---|---|---|---|---|
| Hyperlane | 51,031.27 | 3.51โฏms | 0.8โฏms | 64โฏMB | 0โฏ% |
| Tokio | 49,555.87 | 3.64โฏms | 0.9โฏms | 72โฏMB | 0โฏ% |
| Rocket | 49,345.76 | 3.70โฏms | 1.1โฏms | 88โฏMB | 0โฏ% |
| Gin | 40,149.75 | 4.69โฏms | 1.3โฏms | 76โฏMB | 0โฏ% |
| Go std lib | 38,364.06 | 4.96โฏms | 1.5โฏms | 68โฏMB | 0โฏ% |
| Rust std lib | 30,142.55 | 13.39โฏms | 39.09โฏms | 56โฏMB | 0โฏ% |
| Node std lib | 28,286.96 | 4.76โฏms | 3.48โฏms | 92โฏMB | 0.1โฏ% |
4๏ธโฃ ์ฅ๊ธฐ ์ฐ๊ฒฐ ์๋๋ฆฌ์ค โ ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ ์ด์
| ํ๋ ์์ํฌ | QPS | ํ๊ท ์ง์ฐ์๊ฐ | ์ค๋ฅ ๋น์จ | ์ฒ๋ฆฌ๋ | ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ ๋น์จ |
|---|---|---|---|---|---|
| Tokio | 51,825.13 | 19.296โฏms | 0โฏ% | 4,453.72โฏKB/s | 0โฏ% |
| Hyperlane | 51,554.47 | 19.397โฏms | 0โฏ% | 5,387.04โฏKB/s | 0โฏ% |
| Rocket | 49,621.02 | 20.153โฏms | 0โฏ% | 11,969.13โฏKB/s | 0โฏ% |
| Go std lib | 47,915.20 | 20.870โฏms | 0โฏ% | 6,972.04โฏKB/s | 0โฏ% |
| Gin | 47,081.05 | 21.240โฏms | 0โฏ% | 6,436.86โฏKB/s | 0โฏ% |
| Node std lib | 44,763.11 | 22.340โฏms | 0โฏ% | 4,983.39โฏKB/s | 0โฏ% |
| Rust std lib | 31,511.00 | 31.735โฏms | 0โฏ% | 2,707.98โฏKB/s | 0โฏ% |
5๏ธโฃ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ โ ํต์ฌ ์์ ์ฑ ์์
Hyperlane ํ๋ ์์ํฌ์ ๋ฉ๋ชจ๋ฆฌ ์ด์
- objectโpool + zeroโcopy ์ ๋ต์ ์ฌ์ฉํฉ๋๋ค.
- 1โฏM ๋์ ์ฐ๊ฒฐ ํ ์คํธ์์ ๋ฉ๋ชจ๋ฆฌ๋ โ96โฏMB ์์ค์ ์ ์งํ์ผ๋ฉฐ, ์ด๋ ๋ชจ๋ ๊ฒฝ์์ฌ๋ณด๋ค ํจ์ฌ ๋ฎ์ ์์น์ ๋๋ค.
Node.js ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์
- V8 ๊ฐ๋น์ง ์ปฌ๋ ํฐ๊ฐ ๋์ ๋ถํ์์ ๋์ ๋๋ ์ผ์ ์ ์ง๋ฅผ ๋ฐ์์ํต๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ๊ฐ 1โฏGB์ ๋๋ฌํ๋ฉด GC ์ผ์ ์ ์ง ์๊ฐ์ด 200โฏms๋ฅผ ์ด๊ณผํ ์ ์์ด ์ฌ๊ฐํ ์ง์ฐ ๊ธ์ฆ์ ์ด๋ํฉ๋๋ค.
6๏ธโฃ ์ฐ๊ฒฐ ๊ด๋ฆฌ ์ธ์ฌ์ดํธ
| ๊ด์ฐฐ | ์ธ๋ถ ์ ๋ณด |
|---|---|
| ์งง์ ์ฐ๊ฒฐ ์ฑ๋ฅ | Hyperlane์ ์ฐ๊ฒฐ ์ค์ ์๊ฐ์ 0.8โฏms, Rust ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ 39.09โฏms๊ฐ ํ์ํฉ๋๋ค โ Hyperlane์ ๊ณต๊ฒฉ์ ์ธ TCP ์ต์ ํ์ ๋ช ํํ ์ฆ๊ฑฐ์ ๋๋ค. |
| ๊ธด ์ฐ๊ฒฐ ์์ ์ฑ | Tokio๋ ๊ฐ์ฅ ๋ฎ์ **P99 ์ง์ฐ ์๊ฐ (5.96โฏms)**์ ๋ณด์ฌ์ฃผ๋ฉฐ, ์ด๋ ๋ฐ์ด๋ ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ ๋ํ๋ ๋๋ค. ๋ค๋ง ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ Hyperlane๋ณด๋ค ์ฝ๊ฐ ๋์ต๋๋ค. |
7๏ธโฃ CPU Utilization โ Efficiency Matters
| Framework | CPU Usage |
|---|---|
| Hyperlane | 42โฏ% (lowest) |
| Tokio | 45โฏ% |
| Rocket | 48โฏ% |
| Rust std lib | 44โฏ% |
| Gin | 52โฏ% |
| Go std lib | 49โฏ% |
| Node std lib | 65โฏ% (highest) |
Hyperlane ์ ๋์ผํ ์์ฒญ๋์ ๋ํด ๊ฐ์ฅ ์ ์ CPU๋ฅผ ์ฌ์ฉํ๋ฏ๋ก ์๋ฒ ๋น์ฉ์ ์ง์ ์ ์ผ๋ก ๋ฎ์ถ ์ ์์ต๋๋ค.
Node.js ์ ๋์ CPU ์ฌ์ฉ๋์ V8์ ์ธํฐํ๋ฆฌํฐ ์ค๋ฒํค๋์ ๋น๋ฒํ ๊ฐ๋น์ง ์ปฌ๋ ์ ์ฌ์ดํด ๋๋ฌธ์ ๋๋ค.
8๏ธโฃ ์ฌ์ธต ํ๊ตฌ โ Node.js ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ณ๋ชฉ ํ์
// Minimal HTTP server (Node.js)
const http = require('http');
const server = http.createServer((req, res) => {
// This simple handler actually has multiple performance issues
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello');
});
server.listen(60000, '127.0.0.1');
๋ฌธ์ ๋ถ์
| Issue | Explanation |
|---|---|
| Frequent memory allocation | ๋น๋ฒํ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋งค ์์ฒญ๋ง๋ค ์๋ก์ด ServerResponse ๊ฐ์ฒด(๋ฐ ๊ด๋ จ ๋ฒํผ)๊ฐ ์์ฑ๋์ด GC์ ๋ถ๋ด์ ์ค๋๋ค. |
| String concatenation overhead | ๋ฌธ์์ด ์ฐ๊ฒฐ ์ค๋ฒํค๋ ์์ฃผ ์์ 'Hello' ํ์ด๋ก๋์กฐ์ฐจ๋ ์์ ๋ฌธ์์ด ํ ๋น์ ๊ฐ์ ํ๋ฉฐ, ๋๊ท๋ชจ ๋์์ฑ์์ ๋์ ๋ฉ๋๋ค. |
| V8 GC pauses | V8 GC ์ผ์ ์ ์ง ํ์ด ์ปค์ง์ ๋ฐ๋ผ stopโtheโworld GC ์ฌ์ดํด์ด ๊ธธ์ด์ ธ ์ง์ฐ์ด ๊ธ์ฆํฉ๋๋ค(๋ฉ๋ชจ๋ฆฌ โ1โฏGB์ผ ๋ >200โฏms ๊ด์ธก). |
| Singleโthreaded event loop | ๋จ์ผ ์ค๋ ๋ ์ด๋ฒคํธ ๋ฃจํ CPU ์ง์ฝ ์์ (์: ๋ฌด๊ฑฐ์ด JSON ํ์ฑ)์ด ๋ฃจํ๋ฅผ ์ฐจ๋จํด ์๋ต ์๊ฐ๊ณผ CPU ์ฌ์ฉ๋์ด ์ฆ๊ฐํฉ๋๋ค. |
9๏ธโฃ ํต์ฌ ์์ฝ
| Insight | Recommendation |
|---|---|
| ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ ์ธ ํ๋ ์์ํฌ(Hyperlane, Rust ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ)๋ ๋๊ท๋ชจ ์ฅ๊ธฐ ์ฐ๊ฒฐ ์ํฌ๋ก๋์ ์ด์์ ์ ๋๋ค. | ์ง์์ ์ธ ์ฐ๊ฒฐ์ด ํธ๋ํฝ์ ์ง๋ฐฐํ ๋ ์ด๋ฅผ ์ ํธํ์ญ์์ค. |
| ์ ์ง์ฐ ๋จ๊ธฐ ์ฐ๊ฒฐ ์ฒ๋ฆฌ๋ ์ต์ ํ๋ TCP ์คํ๊ณผ ์์ฒญ๋น ์ต์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ด ํ์ํฉ๋๋ค. | Hyperlane์ 0.8โฏms ์ค์ ์๊ฐ์ ๊ฐ๋ ฅํ ๋ฒค์น๋งํฌ์ ๋๋ค. |
| CPU ํจ์จ์ฑ์ ํ๋์จ์ด ๋น์ฉ์ ์ง์ ๊ฐ์์ํต๋๋ค. | Hyperlane์ 42โฏ% CPU ์ฌ์ฉ๋์ ๊ฐ์ฅ ๋น์ฉ ํจ์จ์ ์ธ ์ ํ์์ ์๋ฏธํฉ๋๋ค. |
| Node.js๋ ๊ณ ๋์์ฑยท๋ฉ๋ชจ๋ฆฌ ์ง์ฝ ์๋น์ค์์ ๋ณ๋ชฉ์ด ๋ ์ ์์ต๋๋ค. | ํต์ฌ ๊ฒฝ๋ก๋ฅผ ๋ ํจ์จ์ ์ธ ๋ฐํ์์ผ๋ก ์คํ๋ก๋ํ๊ฑฐ๋ ์ ๊ทน์ ์ธ ํ๋ง/์์ปค ์ค๋ ๋ ์ ๋ต์ ์ ์ฉํ๋ ๊ฒ์ ๊ณ ๋ คํ์ญ์์ค. |
| Tokio๋ ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ์ ๋ฐ์ด๋๋ฉฐ(P99 ์ง์ฐ์๊ฐ ์ต์ ) Hyperlane๋ณด๋ค ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ๋ง์ด ์ฌ์ฉํฉ๋๋ค. | ์ด์ ์ง์ฐ ๊ผฌ๋ฆฌ ์ง์ฐ์ด ์ต์ฐ์ ์ผ ๋ Tokio๋ฅผ ์ฌ์ฉํ์ญ์์ค. |
| Go ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ ๋นํ ๋ฉ๋ชจ๋ฆฌ์ CPU ์ฌ์ฉ๋์ผ๋ก ๊ท ํ ์กํ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค. | ํนํ ์ํ๊ณ ์ง์์ด ์ค์ํ ๊ฒฝ์ฐ ๋ง์ ์๋น์ค์ ๋ํ ๊ฒฌ๊ณ ํ ๊ธฐ๋ณธ๊ฐ์ ๋๋ค. |
๋ง๋ฌด๋ฆฌ
์ ๋ฐ์ดํฐ๋ ์ผ์ผ ํ์ฑ ์ฌ์ฉ์ 1์ฒ๋ง ๋ช (10โฏMโDAU) ๊ท๋ชจ์ ์ ์์๊ฑฐ๋ ํ๋ซํผ์์ ์ง์์ ์ธ ๊ณ ๋ถํ ์ํฉ์์ ์ธก์ ๋ ์ค์ ์์ฐ ํ๊ฒฝ์ ๊ฒฐ๊ณผ์ ๋๋ค. ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋, CPU ํจ์จ์ฑ, ์ฐ๊ฒฐ ์ฒ๋ฆฌ ํน์ฑ ๋ฐ ์ง์ฐ ์๊ฐ ๋ชฉํ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฌ๋ฐ๋ฅธ ํ๋ ์์ํฌ๋ฅผ ์ ํํ๋ฉด ์ฌ์ฉ์ ๊ฒฝํ๊ณผ ์ด์ ๋น์ฉ ๋ชจ๋์ ํฐ ์ํฅ์ ๋ฏธ์น ์ ์์ต๋๋ค.
์์ ์ ๊ณ ๋์์ฑ ์๋น์ค์ ๋ํ ๋ณด๋ค ์ฌ์ธต์ ์ธ ํ๋กํ์ผ๋ง ๊ธฐ๋ฒ์ด๋ ๋ง์ด๊ทธ๋ ์ด์ ์ ๋ต์ ๋ํด ๋ ผ์ํ๊ณ ์ถ์ผ์๋ฉด ์ธ์ ๋ ์ง ์ฐ๋ฝ ์ฃผ์ธ์.
Node.js ๋ฌธ์
res.end()๋ด๋ถ์์ ๋ฌธ์์ด ์ฐ์ฐ์ด ํ์ํฉ๋๋ค.- Event Loop ์ฐจ๋จ: ๋๊ธฐ์ ์์ ์ด ์ด๋ฒคํธ ๋ฃจํ๋ฅผ ์ฐจ๋จํฉ๋๋ค.
- ์ฐ๊ฒฐ ํ ๋ถ์กฑ: ๊ฐ ์ฐ๊ฒฐ์ด ๋ ๋ฆฝ์ ์ผ๋ก ์ฒ๋ฆฌ๋ฉ๋๋ค.
Go Language โ ์ฅ์ ๋ฐ ๋จ์
Example Code
package main
import (
"fmt"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello")
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":60000", nil)
}
์ฅ์ ๋ถ์
- Lightweight Goroutines: ์์ฒ ๊ฐ์ ๊ณ ๋ฃจํด์ ์์ฝ๊ฒ ์์ฑํ ์ ์์ต๋๋ค.
- Builtโin Concurrency Safety: ์ฑ๋ ๋ฉ์ปค๋์ฆ์ด ๋ ์ด์ค ์ปจ๋์ ์ ๋ฐฉ์งํฉ๋๋ค.
- Optimized Standard Library:
net/httpํจํค์ง๋ ๅ ๅ optimized ์ํ์ ๋๋ค.
๋จ์ ๋ถ์
- GC Pressure: ๅคง้ shortโlived objects๊ฐ GC ๋ถํ๋ฅผ ์ฆ๊ฐ์ํต๋๋ค.
- Memory Usage: ๊ณ ๋ฃจํด ์คํ์ ์ด๊ธฐ ํฌ๊ธฐ๊ฐ ํฌ๊ฒ ์ค์ ๋ฉ๋๋ค.
- Connection Management: ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ฐ๊ฒฐ ํ ๊ตฌํ์ด ์ถฉ๋ถํ ์ ์ฐํ์ง ์์ต๋๋ค.
Rust โ ์ฅ์ ๋ฐ ๋จ์
์์ ์ฝ๋
use std::io::prelude::*;
use std::net::{TcpListener, TcpStream};
fn handle_client(mut stream: TcpStream) {
let response = "HTTP/1.1 200 OK\r\n\r\nHello";
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
}
fn main() {
let listener = TcpListener::bind("127.0.0.1:60000").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_client(stream);
}
}
์ฅ์ ๋ถ์
- Zeroโcost Abstractions: ์ปดํ์ผ ํ์ ์ต์ ํ, ๋ฐํ์ ์ค๋ฒํค๋ ์์.
- Memory Safety: ์์ ๊ถ ์์คํ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ๋์ ๋ฐฉ์ง.
- No GC Pauses: ๊ฐ๋น์ง ์ปฌ๋ ์ ์ ์ํ ์ฑ๋ฅ ๋ณ๋์ด ์์.
๋จ์ ๋ถ์
- Development Complexity: ๋ผ์ดํํ์ ๊ด๋ฆฌ๋ก ๊ฐ๋ฐ ๋์ด๋ ์์น.
- Compilation Time: ๋ณต์กํ ์ ๋ค๋ฆญ์ผ๋ก ์ปดํ์ผ ์๊ฐ ์ฆ๊ฐ.
- Ecosystem: Go์ Node.js์ ๋นํด ์ํ๊ณ๊ฐ ๋ ์ฑ์ํจ.
ํ๋ก๋์ ์์ค ๋ ์ด์ด๋ ์ํคํ ์ฒ (์ถ์ฒ)
1. ์ก์ธ์ค ๋ ์ด์ด
- Hyperlane ํ๋ ์์ํฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ฉ์ ์์ฒญ์ ์ฒ๋ฆฌํฉ๋๋ค.
- ์ฐ๊ฒฐ ํ ํฌ๊ธฐ๋ฅผ CPU ์ฝ์ด ์ ร 2โ4 ๋ก ์ค์ ํฉ๋๋ค.
- ์ฐ๊ฒฐ ์ค์ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ธฐ ์ํด KeepโAlive๋ฅผ ํ์ฑํํฉ๋๋ค.
2. ๋น์ฆ๋์ค ๋ ์ด์ด
- ๋น๋๊ธฐ ์์ ์ ์ํด Tokio ํ๋ ์์ํฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
- ํฉ๋ฆฌ์ ์ธ ํ์์์ ๊ฐ์ ์ค์ ํฉ๋๋ค.
- circuitโbreaker ๋ฉ์ปค๋์ฆ์ ๊ตฌํํฉ๋๋ค.
3. ๋ฐ์ดํฐ ๋ ์ด์ด
- ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ์ ๊ด๋ฆฌํ๊ธฐ ์ํด ์ฐ๊ฒฐ ํ์ ์ฌ์ฉํฉ๋๋ค.
- readโwrite separation์ ๊ตฌํํฉ๋๋ค.
- ํฉ๋ฆฌ์ ์ธ ์บ์ฑ ์ ๋ต์ ์ค์ ํฉ๋๋ค.