๐ฅ_๊ณ ๋์์ฑ_ํ๋ ์์ํฌ_์ ํ_๊ธฐ์ _๊ฒฐ์ [20260101032811]
Source: Dev.to
๐ ํ๋ก๋์ ํ๊ฒฝ ์ฑ๋ฅ ๋ถ์
์๋ง์ ํ๋ก๋์
๋ฌธ์ ๋ฅผ ๊ฒช์ด์จ ์๋์ด ์์ง๋์ด๋ก์, ๊ณ ๋์์ฑ ์ํฌ๋ก๋์ ์ ํฉํ ๊ธฐ์ ์คํ์ ์ ํํ๋ ๊ฒ์ด ์ผ๋ง๋ ์ค์ํ์ง ์ ์๊ณ ์์ต๋๋ค.
์ต๊ทผ ์ ์์๊ฑฐ๋ ํ๋ซํผ์ ์ฌ๊ตฌ์ถํ๋ฉด์ (โ1์ฒ๋ง ์ผ์ผ ํ์ฑ ์ฌ์ฉ์) 6๊ฐ์ ๊ฐ์ ์คํธ๋ ์ค ํ
์คํธ ๋ฐ ๋ชจ๋ํฐ๋ง ๋ฐ์ดํฐ๋ฅผ ์์งํ์ต๋๋ค. ์๋๋ ๊ทธ ๋ถ์์ ์ ๋ฆฌํ ๋ฒ์ ์
๋๋ค.
๐ก ์ค์ ํ๋ก๋์ ํ๊ฒฝ ๊ณผ์
| ์๋๋ฆฌ์ค | ์ค๋ช |
|---|---|
| ๐ ํ๋์ ์ธ์ผ | Doubleโฏ11๊ณผ ๊ฐ์ ์ด๋ฒคํธ ๋์ ์ ํ ์์ธ ํ์ด์ง๋ ์ด๋น ์์ญ๋ง ๊ฑด์ ์์ฒญ์ ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค. ์ด๋ ๋์ ์ฒ๋ฆฌ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ํฐ ๋ถ๋ด์ ์ค๋๋ค. |
| ๐ณ ๊ฒฐ์ ์์คํ | ์๋ง์ ๋จ๊ธฐ ์ฐ๊ฒฐ์ ์ฒ๋ฆฌํ๋ฉฐ, ๊ฐ ์ฐ๊ฒฐ์ ๋น ๋ฅธ ์๋ต์ด ํ์ํฉ๋๋ค. ์ด๋ ์ฐ๊ฒฐ ๊ด๋ฆฌ ํจ์จ์ฑ๊ณผ ๋น๋๊ธฐ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ ์ํํฉ๋๋ค. |
| ๐ ์ค์๊ฐ ํต๊ณ | ์ฌ์ฉ์ ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ง์์ ์ผ๋ก ์ง๊ณํ์ฌ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋๊ณผ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ์๋ฐ์ ๊ฐํฉ๋๋ค. |
๐ ํ๋ก๋์ ํ๊ฒฝ ์ฑ๋ฅ ๋ฐ์ดํฐ ๋น๊ต
๐ KeepโAlive ํ์ฑํ (LongโConnection ์๋๋ฆฌ์ค)
์ฅ๊ธฐ ์ฐ๊ฒฐ ํธ๋ํฝ์ ์ ์ฒด ๋ถํ์ **>โฏ70โฏ%**๋ฅผ ์ฐจ์งํฉ๋๋ค.
wrk โ ์ ํ ์์ธ ํ์ด์ง ๋ถํ ํ ์คํธ
| Framework | QPS | AvgโฏLatency | P99โฏLatency | Memory | 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 | 837.62โฏยตs | 186โฏMB | 65โฏ% |
ab โ ๊ฒฐ์ ์์ฒญ ๋ถํ ํ ์คํธ
| Framework | QPS | AvgโฏLatency | ErrorโฏRate | Throughput | ConnโฏSetup |
|---|---|---|---|---|---|
| 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 |
๐ KeepโAlive ๋นํ์ฑํ (ShortโConnection ์๋๋ฆฌ์ค)
๋จ๊ธฐ ์ฐ๊ฒฐ ํธ๋ํฝ์ ์ ์ฒด ๋ถํ์ **โโฏ30โฏ%**๋ฅผ ์ฐจ์งํ์ง๋ง ๊ฒฐ์ , ๋ก๊ทธ์ธ ๋ฑ์ ํ์์ ์ ๋๋ค.
wrk โ ๋ก๊ทธ์ธ ์์ฒญ ํ ์คํธ
| Framework | QPS | AvgโฏLatency | ConnโฏSetup | Memory | ErrorโฏRate |
|---|---|---|---|---|---|
| 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โฏ% |
ab โ ๊ฒฐ์ ์ฝ๋ฐฑ ํ ์คํธ
| Framework | QPS | AvgโฏLatency | ErrorโฏRate | Throughput | ConnโฏReuse |
|---|---|---|---|---|---|
| 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โฏ% |
๐ฏ ์ฌ์ธต ๊ธฐ์ ๋ถ์
๐ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋น๊ต
-
Hyperlane Framework
- ๊ฐ์ฒด ํ + ์ ๋ก ๋ณต์ฌ ์ ๋ต์ ์ฌ์ฉํฉ๋๋ค.
- 1โฏM ๋์ ์ฐ๊ฒฐ ํ ์คํธ์์ ๋ฉ๋ชจ๋ฆฌ๋ โโฏ96โฏMB๋ฅผ ์ ์งํ์ผ๋ฉฐ, ๊ฒฝ์์ฌ๋ณด๋ค ํจ์ฌ ๋ฎ์์ต๋๋ค.
-
Node.js
- V8์ ๊ฐ๋น์ง ์ปฌ๋ ํฐ๊ฐ ๋์ ๋๋ ์ผ์ ์ ์ง๋ฅผ ๋ฐ์์ํต๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ๊ฐ 1โฏGB์ ๋๋ฌํ๋ฉด GC ์ผ์ ์ ์ง๊ฐ 200โฏms๋ฅผ ์ด๊ณผํ์ฌ ์ฌ๊ฐํ ์ง์ฐ ์คํ์ดํฌ๋ฅผ ์ ๋ฐํฉ๋๋ค.
โก ์ฐ๊ฒฐ ๊ด๋ฆฌ ํจ์จ์ฑ
-
์งง์ ์ฐ๊ฒฐ ์๋๋ฆฌ์ค
- Hyperlane์ ์ฐ๊ฒฐ ์ค์ ์๊ฐ: 0.8โฏms.
- Rust std lib: 39.09โฏms โ ํฐ ์ฐจ์ด๋ก, Hyperlane์ ๊ณต๊ฒฉ์ ์ธ TCP ์ต์ ํ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-
๊ธด ์ฐ๊ฒฐ ์๋๋ฆฌ์ค
- Tokio๋ ๊ฐ์ฅ ๋ฎ์ P99 ์ง์ฐ ์๊ฐ (5.96โฏms)์ ๋ฌ์ฑํ์ผ๋ฉฐ, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๋ ๋์ง๋ง ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ์ด ๋ฐ์ด๋จ์ ๋ํ๋ ๋๋ค.
๐ง CPU ์ฌ์ฉ ํจ์จ์ฑ
- Hyperlane Framework๋ ์ผ๊ด๋๊ฒ ๊ฐ์ฅ ๋ฎ์ CPU ์ฌ์ฉ๋ฅ (โโฏ42โฏ%)์ ๋ณด์ด๋ฉฐ ์ต๊ณ ์์ค์ ์ฒ๋ฆฌ๋์ ์ ๊ณตํ๋ฏ๋ก ์ถ๊ฐ ์๋น์ค๋ ํ์ฅ์ ์ํ ์ฌ์ ๊ณต๊ฐ์ด ๋ ๋ง์ต๋๋ค.
๐ ์ฃผ์ ๋ด์ฉ
| ์ธ์ฌ์ดํธ | ๊ถ์ฅ ์ฌํญ |
|---|---|
| Memory footprint matters โ Hyperlaneโs pool/zeroโcopy design yields the smallest RAM usage under massive concurrency. | ๊ณ ํธ๋ํฝ ์๋น์ค์์๋ ๋ช ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฌ์ฉ ๋ฉ์ปค๋์ฆ์ ๊ฐ์ถ ํ๋ ์์ํฌ๋ฅผ ์ ํธํ์ธ์. |
| Connection handling is a firstโorder factor โ Fast TCP setup and efficient keepโalive reuse directly improve latency. | ์ํฌ๋ก๋ ํจํด์ ๋ฐ๋ผ Hyperlane(๋จ๊ธฐ ์ฐ๊ฒฐ) ๋๋ Tokio(์ฅ๊ธฐ ์ฐ๊ฒฐ)๋ฅผ ์ฌ์ฉํ์ธ์. |
| CPU efficiency translates to cost savings โ Lower CPU % at the same QPS means you can run fewer instances or handle more traffic per node. | CPU ํ๋กํ์ผ์ ์ด๊ธฐ์ ํ๊ฐํ์ธ์; Hyperlane์ด ๊ฐ์ฅ ๊ท ํ ์กํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ฌ์ค๋๋ค. |
| Node.js may need extra tuning โ GC pauses become a bottleneck at high memory usage. | ๋ ์ดํด์๊ฐ ์ค์ํ ๊ฒฝ๋ก์์๋ ๋์ ๋ฐํ์์ ๊ณ ๋ คํ๊ฑฐ๋, aggressive GC ํ๋ ๋ฐ ๋ฉ๋ชจ๋ฆฌ ์ ํ์ ์ ์ฉํ์ธ์. |
๋ชจ๋ ์์น๋ ๋ด๋ถ wrk ๋ฐ ab ์คํธ๋ ์คโํ ์คํธ ์ค์ํธ์์ ์ป์ ๊ฒ์ผ๋ก, ํ๋ก๋์ ๊ณผ ์ ์ฌํ ํ๋์จ์ด์ ๋คํธ์ํฌ ํ๊ฒฝ์์ ์คํ๋์์ต๋๋ค.
Node.js CPU ๋ฌธ์
Node.js ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ 65โฏ% CPU๊น์ง ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ์ด๋ ์ฃผ๋ก V8 ์์ง์ ์ธํฐํ๋ฆฌํฐ ์ค๋ฒํค๋์ ๊ฐ๋น์ง ์ปฌ๋ ์ ๋๋ฌธ์ ๋๋ค. ๊ณ ๋์์ฑ ์๋๋ฆฌ์ค์์๋ ์ด๋ก ์ธํด ์๋ฒ ๋ถํ๊ฐ ๊ณผ๋ํ๊ฒ ์ฆ๊ฐํฉ๋๋ค.
๐ป ์ฝ๋ ๊ตฌํ ์ธ๋ถ ๋ถ์
๐ข Node.js ๊ตฌํ์์์ ์ฑ๋ฅ ๋ณ๋ชฉ ํ์
const http = require('http');
const server = http.createServer((req, res) => {
// This simple handler function actually has multiple performance issues
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Hello');
});
server.listen(60000, '127.0.0.1');
๋ฌธ์ ๋ถ์
| ๋ฌธ์ | ์ค๋ช |
|---|---|
| ๋น๋ฒํ ๋ฉ๋ชจ๋ฆฌ ํ ๋น | ๊ฐ ์์ฒญ๋ง๋ค ์๋ก์ด ์๋ต ๊ฐ์ฒด๊ฐ ์์ฑ๋ฉ๋๋ค |
| ๋ฌธ์์ด ์ฐ๊ฒฐ ์ค๋ฒํค๋ | res.end()๊ฐ ๋ด๋ถ ๋ฌธ์์ด ์ฐ์ฐ์ ์ํํฉ๋๋ค |
| ์ด๋ฒคํธ ๋ฃจํ ์ฐจ๋จ | ๋๊ธฐ์ ์์ ์ด ์ด๋ฒคํธ ๋ฃจํ๋ฅผ ์ฐจ๋จํฉ๋๋ค |
| ์ฐ๊ฒฐ ํ ๋ถ์กฑ | ๊ฐ ์ฐ๊ฒฐ์ด ๋ ๋ฆฝ์ ์ผ๋ก ์ฒ๋ฆฌ๋ฉ๋๋ค |
๐น Go ๊ตฌํ์ ๋์์ฑ ์ฅ์
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)
}
์ฅ์ ๋ถ์
- ๊ฒฝ๋ Goroutine โ ์์ฒ ๊ฐ์ Goroutine์ ์์ฝ๊ฒ ์์ฑํ ์ ์์ต๋๋ค
- ๋ด์ฅ๋ ๋์์ฑ ์์ ์ฑ โ ์ฑ๋์ ์ฌ์ฉํ๋ฉด ๊ฒฝ์ ์กฐ๊ฑด์ ๋ฐฉ์งํ ์ ์์ต๋๋ค
- ์ต์ ํ๋ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ โ
net/http๋ ๋งค์ฐ ์ต์ ํ๋์ด ์์ต๋๋ค
๋จ์ ๋ถ์
- GC ์๋ ฅ โ ๋ค์์ ๋จ๋ช ๊ฐ์ฒด๊ฐ ๊ฐ๋น์ง ์ปฌ๋ ์ ๋ถ๋ด์ ์ฆ๊ฐ์ํต๋๋ค
- ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ โ Goroutine ์คํ์ ๋น๊ต์ ํฐ ํฌ๊ธฐ๋ก ์์ํฉ๋๋ค
- ์ฐ๊ฒฐ ๊ด๋ฆฌ โ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ฐ๊ฒฐ ํ ๊ตฌํ์ด ํฌ๊ฒ ์ ์ฐํ์ง ์์ต๋๋ค
๐ 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_all(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);
}
}
์ฅ์ ๋ถ์
- ์ ๋ก ๋น์ฉ ์ถ์ํ โ ์ปดํ์ผ ์ ์ต์ ํ๊ฐ ์ด๋ฃจ์ด์ง๋ฉฐ ๋ฐํ์ ์ค๋ฒํค๋๊ฐ ์์ต๋๋ค
- ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ โ ์์ ๊ถ ์์คํ ์ด ๋ฉ๋ชจ๋ฆฌ ๋์์ ๋ฐ์ดํฐ ๋ ์ด์ค๋ฅผ ๋ฐฉ์งํฉ๋๋ค
- GC ์ผ์์ ์ง ์์ โ ๊ฐ๋น์ง ์ปฌ๋ ์ ์ผ๋ก ์ธํ ์ฑ๋ฅ ๋ณ๋์ด ์์ต๋๋ค
๋จ์ ๋ถ์
- ๊ฐ๋ฐ ๋ณต์ก์ฑ โ ์๋ช ๊ด๋ฆฌ๊ฐ ์ด๋ณด์์๊ฒ ์ด๋ ค์ธ ์ ์์ต๋๋ค
- ์ปดํ์ผ ์๊ฐ โ ์ ๋ค๋ฆญ์ ๋ง์ด ์ฌ์ฉํ๋ฉด ๋น๋ ์๊ฐ์ด ๋์ด๋ ์ ์์ต๋๋ค
- ์ํ๊ณ ์ฑ์๋ โ ์ผ๋ถ ์์ญ์์ Go์ Node.js์ ๋นํด ์์ง ๋ค์ฒ์ ธ ์์ต๋๋ค
๐ฏ ํ๋ก๋์ ํ๊ฒฝ ๋ฐฐํฌ ๊ถ์ฅ ์ฌํญ
๐ช ์ ์์๊ฑฐ๋ ์์คํ ์ํคํ ์ฒ ๊ถ์ฅ ์ฌํญ
์ด์ ๊ฒฝํ์ ๋ฐํ์ผ๋ก ๊ณ์ธตํ ์ํคํ ์ฒ๋ฅผ ๊ถ์ฅํฉ๋๋ค:
Access Layer
- ์ฌ์ฉ์ ์์ฒญ์ ์ฒ๋ฆฌํ๊ธฐ ์ํด Hyperlane ํ๋ ์์ํฌ ์ฌ์ฉ
- ์ฐ๊ฒฐ ํ ํฌ๊ธฐ๋ฅผ CPU ์ฝ์ด ์์ 2โ4โฏร ๋ก ์ค์
- ์ฐ๊ฒฐ ์ค์ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ธฐ ์ํด KeepโAlive ํ์ฑํ
Business Layer
- ๋น๋๊ธฐ ์์ ์ ์ํด Tokio ํ๋ ์์ํฌ ์ฌ์ฉ
- ํฉ๋ฆฌ์ ์ธ ํ์์์ ๊ฐ ์ค์
- ์ํทโ๋ธ๋ ์ด์ปค ๋ฉ์ปค๋์ฆ ๊ตฌํ
Data Layer
- ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ๊ทผ์ ์ํ ์ฐ๊ฒฐ ํ ์ฌ์ฉ
- ์ฝ๊ธฐโ์ฐ๊ธฐ ๋ถ๋ฆฌ ๊ตฌํ
- ์ ์ ํ ์บ์ ์ ๋ต ์ ์ฉ
๐ณ ๊ฒฐ์ ์์คํ ์ต์ ํ ๊ถ์ฅ ์ฌํญ
๊ฒฐ์ ์์คํ ์ ๊ทนํ์ ์ฑ๋ฅ๊ณผ ์ ๋ขฐ์ฑ์ ์๊ตฌํฉ๋๋ค:
Connection Management
- Hyperlane์ ๋จ๊ธฐ ์ฐ๊ฒฐ ์ต์ ํ ํ์ฉ
- TCP Fast Open ํ์ฑํ
- ์ฐ๊ฒฐ ์ฌ์ฌ์ฉ ๊ตฌํ
Error Handling
- ์ฌ์๋ ๋ฉ์ปค๋์ฆ ์ถ๊ฐ
- ํฉ๋ฆฌ์ ์ธ ํ์์์ ๊ฐ ๊ตฌ์ฑ
- ์์ธ ์ค๋ฅ ๋ก๊ทธ ๊ธฐ๋ก
Monitoring & Alerts
- QPS์ ์ง์ฐ ์๊ฐ์ ์ค์๊ฐ์ผ๋ก ๋ชจ๋ํฐ๋ง
- ํฉ๋ฆฌ์ ์ธ ์๋ฆผ ์๊ณ๊ฐ ์ค์
- ์๋ ์ค์ผ์ผ๋ง ํ์ฑํ
๐ ์ค์๊ฐ ํต๊ณ ์์คํ ๊ถ์ฅ ์ฌํญ
์ค์๊ฐ ๋ถ์์ ๋ฐฉ๋ํ ๋ฐ์ดํฐ ์์ ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค:
Data Processing
- Tokio์ ๋น๋๊ธฐ ๊ธฐ๋ฅ ์ฌ์ฉ
- ๋ฐฐ์น ์ฒ๋ฆฌ ๊ตฌํ
- ๋ฒํผ ํฌ๊ธฐ๋ฅผ ์ ์ ํ ์กฐ์
Memory Management
- ํ ๋น์ ์ค์ด๊ธฐ ์ํด ๊ฐ์ฒด ํ ์ฑํ
- ๋ฐ์ดํฐ ์ค๋ฉ ์ ์ฉ
- ์ ์ ํ GC ์ ๋ต ์ ํ(ํด๋น๋๋ ๊ฒฝ์ฐ)
Performance Monitoring
- ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ง์์ ์ผ๋ก ์ถ์
- GC ๋ก๊ทธ ๋ถ์(GC ๊ธฐ๋ฐ ๋ฐํ์์ ๊ฒฝ์ฐ)
- ํซ ์ฝ๋ ๊ฒฝ๋ก ์ต์ ํ
๐ฎ ๋ฏธ๋ ๊ธฐ์ ํธ๋ ๋
๐ ์ฑ๋ฅ ์ต์ ํ ๋ฐฉํฅ
ํฅํ ์์ ์ ๋ค์์ ์ด์ ์ ๋ง์ถ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค:
-
ํ๋์จ์ด ๊ฐ์
- GPU ๊ธฐ๋ฐ ๋ฐ์ดํฐ ์ฒ๋ฆฌ
- ๊ณ ์ฑ๋ฅ ๋คํธ์ํน์ ์ํ DPDK
- ์ ๋ก ์นดํผ ๋ฐ์ดํฐ ์ ์ก
-
์๊ณ ๋ฆฌ์ฆ ์ต์ ํ
- ํฅ์๋ ์์ ์ค์ผ์ค๋ง ์๊ณ ๋ฆฌ์ฆ
- ๊ณ ๊ธ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์ ๋ต
- ์ง๋ฅํ ์ฐ๊ฒฐ ๊ด๋ฆฌ
-
์ํคํ ์ฒ ์งํ
- ๋ง์ดํฌ๋ก์๋น์ค๋ก์ ์ ํ
- ์๋น์ค ๋ฉ์ ๋์
- ์ฃ์ง ์ปดํจํ ํตํฉ
๐ง ๊ฐ๋ฐ ๊ฒฝํ ๊ฐ์
์ฑ๋ฅ์ด ์ค์ํ์ง๋ง, ๊ฐ๋ฐ์ ์์ฐ์ฑ๋ ์ค์ํฉ๋๋ค:
-
ํด์ฒด์ธ ๊ฐ์
- ํฅ์๋ ๋๋ฒ๊น ๋๊ตฌ
- ํซ ๋ฆฌ๋ก๋ฉ ์ง์
- ๋ ๋น ๋ฅธ ์ปดํ์ผ
-
ํ๋ ์์ํฌ ๋จ์ํ
- ๋ณด์ผ๋ฌํ๋ ์ดํธ ๊ฐ์
- ํฉ๋ฆฌ์ ์ธ ๊ธฐ๋ณธ๊ฐ ์ ๊ณต
- โ๊ตฌ์ฑ๋ณด๋ค ๊ด๋กโ ์ฑํ
-
๋ฌธ์ โ ์ต์ ์ํ๋ฅผ ์ ์งํ๊ณ , ํฌ๊ด์ ์ด๋ฉฐ, ํ์ํ๊ธฐ ์ฝ๊ฒ ์ ์งํ์ญ์์ค.
๊ฐ์
- ์์ธํ ์ฑ๋ฅ ํ๋ ๊ฐ์ด๋ ์ ๊ณต
- ๋ชจ๋ฒ ์ฌ๋ก ์์ ๊ตฌํ
- ํ๋ฐํ ์ปค๋ฎค๋ํฐ ๊ตฌ์ถ
๐ฏ ์์ฝ
ํ๋ก๋์ ํ๊ฒฝ์ ๋ํ ์ฌ์ธต ํ ์คํธ๋ฅผ ํตํด ๊ณ ๋์์ฑ ์๋๋ฆฌ์ค์์ ์น ํ๋ ์์ํฌ์ ์ฑ๋ฅ์ ๋ค์ ์ธ์ํ๊ฒ ๋์์ต๋๋ค.
- Hyperlane ํ๋ ์์ํฌ๋ ์ค์ ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ CPU ์ฌ์ฉ ํจ์จ์ฑ์์ ๋ ํนํ ์ฅ์ ์ ๊ฐ์ง๊ณ ์์ด, ๋ฆฌ์์ค์ ๋ฏผ๊ฐํ ์๋๋ฆฌ์ค์ ํนํ ์ ํฉํฉ๋๋ค.
- Tokio ํ๋ ์์ํฌ๋ ์ฐ๊ฒฐ ๊ด๋ฆฌ์ ์ง์ฐ ์๊ฐ ์ ์ด์ ๋ฐ์ด๋๋ฉฐ, ์๊ฒฉํ ์ง์ฐ ์๊ฐ ์๊ตฌ์ฌํญ์ด ์๋ ์๋๋ฆฌ์ค์ ์ ํฉํฉ๋๋ค.
ํ๋ ์์ํฌ๋ฅผ ์ ํํ ๋๋ ์ฑ๋ฅ, ๊ฐ๋ฐ ํจ์จ์ฑ, ํ ์ญ๋ ๋ฑ ์ฌ๋ฌ ์์๋ฅผ ์ข ํฉ์ ์ผ๋ก ๊ณ ๋ คํด์ผ ํฉ๋๋ค. โ์ต๊ณ ์โ ํ๋ ์์ํฌ๋ ์์ผ๋ฉฐ, ๊ฐ์ฅ ์ ํฉํ ํ๋ ์์ํฌ๋ง ์กด์ฌํฉ๋๋ค. ์ ๊ฒฝํ์ด ์ฌ๋ฌ๋ถ์ด ๊ธฐ์ ์ ํ์ ๋ณด๋ค ํ๋ช ํ๊ฒ ํ๋ ๋ฐ ๋์์ด ๋๊ธธ ๋ฐ๋๋๋ค.