Rust axum VS Java Spring boot 속도 테스트

rust 백엔드는 java 백엔드보다 빠를까? 라는 이야기로 간단하게 테스트를 해보았습니다.

• Rust는 axum 0.8.3을 사용하였습니다.
• Java는 Spring boot Web 3.4.4를 사용하였습니다.

open api를 활용하여 하고자 하였으나, 초당 건수 제한과 총 건수 제한으로 인하여 간단한 로직을 구성한 후, 테스트를 진행하였습니다.

 

test는 jemter를 사용하였습니다.

설정

Numbeer of Threads = 50
seconds = 60
Loop Count = Infinite
Duration : 180

• Spring boot

처리량 : 85527, tps : 473.2/sec
처리량 : 83539, tps : 462.6/sec
처리량 : 83999, tps : 465.0/sec

• Rust

처리량 : 109820, tsp : 609.1/sec
처리량 : 106814, tsp : 592.6/sec
처리량 : 106209, tsp : 589.0/sec

코드

• java

package Main;

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SearchController {

    public static class FibRequest {
        private int n;
        public int getN() {
            return n;
        }
        public void setN(int n) {
            this.n = n;
        }
    }

    private long fib(int n) {
        if (n < 2) {
            return n;
        }
        return fib(n - 1) + fib(n - 2);
    }

    @PostMapping("/")
    public String heavyFib(@RequestBody FibRequest request) {
        long result = fib(request.getN());
        return "Hello - Fibonacci(" + request.getN() + ") = " + result;
    }
}

• rust

use axum::{Router, extract::Json, routing::post};
use serde::Deserialize;

#[derive(Deserialize)]
struct Input {
    n: u64,
}

fn fib(n: u64) -> u64 {
    if n < 2 {
        n as u64
    } else {
        fib(n - 1) + fib(n - 2)
    }
}

async fn heavy_fib(Json(input): Json<Input>) -> String {
    let result = fib(input.n);
    format!("Hello - Fibonacci({}) = {}", input.n, result)
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", post(heavy_fib));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

단순한 피보나치 수열 재귀코드로 작성하여 테스트했을 뿐인데도, Spring boot랑 Rust axum이랑 속도차이가 발생했습니다.

 

만약 여기서 더 복잡한 연산을 수핸하는 로직의 경우, 차이가 더 심하게 발생할 것으로 예상됩니다.

번외

단순 피보나치 수열만 수행하는 코드를 rust랑 java 언어적 측면으로만 테스트해보았습니다.

• java

484.7087ms
475.8897ms
477.8727ms

• rust

386.3824ms
386.3958ms
391.9414ms

코드

• java

public class Main {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        for(int i = 1; i < 40; i++) {
            fib(i);
        }
        System.out.println(System.currentTimeMillis() - start);
    }

    private static long fib(int n) {
        if (n < 2) {
            return n;
        }
        return fib(n - 1) + fib(n - 2);
    }
}

• rust

use std::time::Instant;

fn fib(n: u64) -> u64 {
    if n < 2 {
        n as u64
    } else {
        fib(n - 1) + fib(n - 2)
    }
}

fn main() {
    let start = Instant::now();
    for i in 1..40 {
        fib(i);
    }

    let duration = start.elapsed();
    println!("코드 실행 시간: {:?}", duration)
}