DEV Community

loading...
Cover image for Rust vs Go - Load testing  webserv (>400k req/s)

Rust vs Go - Load testing webserv (>400k req/s)

martichou profile image Martin André ・2 min read

TLDR: Go can reach 270k req/s where Rust can hit 400k req/s.

Go server

Let's go straight to buisness with a minimal server sample using httprouter.

package main

import (
    "fmt"
    "net/http"

    "github.com/julienschmidt/httprouter"
)

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    fmt.Fprint(w, "Welcome!")
}

func main() {
    router := httprouter.New()
    router.GET("/", Index)

    http.ListenAndServe(":8080", router)
}
Enter fullscreen mode Exit fullscreen mode

Rust

For the Rust server we'll use Actix as our framework of choice, down below is the minimal sample.

use actix_web::{web, Responder, middleware, App, HttpServer};

async fn health_check() -> impl Responder {
    "Welcome!"
}

fn routes(cfg: &mut web::ServiceConfig) {
    cfg.route("/health", web::get().to(health_check));
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let serv = HttpServer::new(move || {
        App::new()
            .wrap(middleware::Compress::default())
            .configure(routes)
    });
    serv.bind("127.0.0.1:8080")?
        .run()
        .await
}
Enter fullscreen mode Exit fullscreen mode

Benchmark

To put a big load on both our servers, we're going to use wrk.

the benchmarks are performed on a i7-8750H (6c, 12threads)

wrk -t12 -c1000 -d15s http://127.0.0.1:8080/
Enter fullscreen mode Exit fullscreen mode

Results

Rust:

Running 15s test @ http://127.0.0.1:8080/
  12 threads and 1000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     3.73ms    4.70ms  57.76ms   85.86%
    Req/Sec    33.66k     5.80k   69.35k    71.65%
  6039978 requests in 15.10s, 714.26MB read
Requests/sec: 400095.92
Transfer/sec:     47.31MB
Enter fullscreen mode Exit fullscreen mode

Go:

Running 15s test @ http://127.0.0.1:8080/
  12 threads and 1000 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     5.03ms    6.11ms 102.78ms   86.66%
    Req/Sec    22.81k     4.77k   53.73k    71.19%
  4087276 requests in 15.10s, 487.24MB read
Requests/sec: 270691.36
Transfer/sec:     32.27MB
Enter fullscreen mode Exit fullscreen mode

The results speak for themselves... 400.000 vs 270.000 for Rust and Go respectively.

Conclusion

While Go might be easier to write and faster to compile compared to Rust, it's still slower compared to its competitors.

If you're hesitating, let me give you this advice: use rust if you want speed, else go with Go.

Cover image from dzone.

Discussion (4)

pic
Editor guide
Collapse
pranaypratyush profile image
Pranay Pratyush

Seems a bit unfair to pit net/http to actix. try fasthttp instead.

Collapse
soulsbane profile image
Paul Crane

Am I missing something? The Rust version uses async/await while the Go version does not use the equivalent(go routines).

Collapse
stevepryde profile image
Steve Pryde

Are you sure? It seems to me that the ListenAndServe() method spawns goroutines to handle incoming requests.

We should expect a performance difference for such a simple example. However most real world web apps are not so simple and differences in db queries etc could easily outweigh the choice of language.

I think Rust is almost always going to be faster than Go if both are equally optimised simply because it is somewhat closer to the metal. But how does the effort and expertise required to achieve such optimisation compare with each language? However I don't think rust should be seen as Go's primary competitor. Rather I think we should compare with Java, node.js, python, ruby, and C#. I expect Go would be quite competitive with all of those.

Let's also remember other factors like ease of maintaining a large codebase and hiring pool.

That said, I prefer Rust for its safety guarantees. The ease with which you can end up with data races or null pointers in Go just makes me nervous. I do see its appeal though. Simplicity is a worthy design goal.

Collapse
soulsbane profile image
Paul Crane • Edited

You are right. I meant my comment to come off as more a question than a statement but I kinda failed there. I was on my phone and couldn't check the source code for the Go version. But you answered my question most thoroughly though. Thanks for the reply and article!