Ir mais rápido que Rust?

Por favor, alguém corrija meu código ou algo assim, porque estou muito desapontado com Rust. Não atire no mensageiro aqui também (sinta-se à vontade para atirar em mim se for culpa do meu código ruim).

Eu sei que quase todas as comparações de desempenho entre Go e Rust mostram Rust com melhor desempenho, mas sempre? Não parece, e na verdade os resultados que vou compartilhar são um desempenho muito ruim de Rust e com todo o hype, estou muito desapontado.

Os resultados do Go — correram comgo build && ./go_test

wrk -t 25 -c 100 -d 60s --timeout 8s http://127.0.0.1:8080/test_top25
Running 1m test @ http://127.0.0.1:8080/test_top25
  25 threads and 100 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     2.37s   399.13ms   4.75s    81.81%
    Req/Sec     2.76      3.37    30.00     86.68%
  2474 requests in 1.00m, 378.22MB read
Requests/sec:     41.18
Transfer/sec:      6.30MB

wrk -t 25 -c 100 -d 60s --timeout 8s http://127.0.0.1:8000/test_top25
Running 1m test @ http://127.0.0.1:8000/test_top25
  25 threads and 100 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     3.30s   560.20ms   6.08s    76.31%
    Req/Sec     2.75      3.88    30.00     84.61%
  1769 requests in 1.00m, 272.14MB read
Requests/sec:     29.43
Transfer/sec:      4.53MB

Todos os testes de desempenho que encontrei são com algum tipo de dados falsos, o desempenho do Rust em uma configuração de aplicativo do mundo real não é tão bom quanto todo mundo faz parecer? São as caixas/bibliotecas que estão sendo usadas? Não tenho certeza, então vamos dar uma olhada...

use actix_web::{web, App, HttpResponse, HttpServer};
use sqlx::postgres::PgPoolOptions;
use sqlx::types::JsonValue;

#[derive(sqlx::FromRow, serde::Serialize)]
struct Snapshot {
    Resource: serde_json::Value
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let pool = PgPoolOptions::new()
        .max_connections(25)
        .min_connections(25)
        .connect("<postgres_url>").await
        .expect("Failed to create pool.");

    HttpServer::new(move || {
        App::new()
            .wrap(actix_web::middleware::Compress::default())
            .app_data(web::Data::new(pool.clone()))
            .route("/test_top25", web::get().to(|pool: web::Data<sqlx::PgPool>| async move {
                let rows = sqlx::query_as::<_, Snapshot>("SELECT <query> LIMIT 25")
                    .fetch_all(&**pool).await.unwrap();
                HttpResponse::Ok().json(serde_json::json!({ "message": rows }))
            }))
    })
    .client_request_timeout(std::time::Duration::from_secs(60))
    .bind(("0.0.0.0", 8000))?
    .run().await
}

package main

import (
 "context"
 "fmt"
 "net/http"

 "github.com/gin-gonic/gin"
 "github.com/jackc/pgx/v5"
 "github.com/jackc/pgx/v5/pgxpool"
)

func setupRouter() *gin.Engine {
 r := gin.Default()

 psqlInfo := "<postgres_url>"

 config, err := pgxpool.ParseConfig(psqlInfo)
 config.MaxConns = 25
 config.MinConns = 25

 pool, err := pgxpool.NewWithConfig(context.Background(), config)

 r.GET("/test_top25", func(c *gin.Context) {
  res, err := pool.Query(context.Background(), "SELECT <query> LIMIT 25")

  rows, err := pgx.CollectRows(res, pgx.RowTo[any])

  c.JSON(http.StatusOK, gin.H{
   "message": rows,
  })
 })

 return r
}

func main() {
 r := setupRouter()
 r.Run(":8080")
}

Alguém rápido, conserte meu código Rust, porque de acordo com TODOS, isso não deveria estar acontecendo. Eu pensei que era bastante decente, pelo menos com Rust, e não escrevi uma linha de Go na minha vida antes, então o fato de ter conseguido obter melhor desempenho de um idioma que mal estou começando a aprender é decepcionante.

Como observação, tentei este teste com vários parâmetros diferentes; contagem de threads diferente, número diferente de conexões, intervalos de tempo diferentes, etc., mas Rust venceu apenas Go em um conjunto de cerca de 15 testes.