Aller plus vite que Rust ?

S'il vous plaît quelqu'un corrige mon code ou quelque chose, car je suis très déçu de Rust. Ne tirez pas non plus sur le messager ici (n'hésitez pas à me tirer dessus si c'est la faute de mes mauvais codes).

Je sais que presque toutes les comparaisons de performances entre Go et Rust montrent que Rust fonctionne mieux, mais le fait-il toujours ? Cela ne semble pas le cas, et en fait, les résultats que je vais partager sont des performances assez médiocres de Rust et avec tout le battage médiatique, je suis très déçu.

Les résultats de Go — exécutés avecgo 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

Tous les tests de performances que j'ai trouvés sont avec une sorte de fausses données, les performances de Rust dans un environnement d'application réel ne sont-elles pas aussi bonnes que tout le monde le prétend? Est-ce que les caisses/bibliothèques sont utilisées ? Je ne suis pas sûr, alors jetons un coup d'œil…

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")
}

Que quelqu'un répare rapidement mon code Rust, car selon TOUT LE MONDE, cela ne devrait pas se produire. Je pensais que j'étais assez bon au moins avec Rust, et je n'ai pas écrit une seule ligne de Go dans ma vie auparavant, donc le fait que j'ai pu obtenir de meilleures performances avec une langue que je commence à peine à apprendre est décevant.

En guise de remarque, j'ai essayé ce test avec plusieurs paramètres différents; nombre de threads différent, nombre de connexions différent, durées différentes, etc., mais Rust n'a battu Go que dans un ensemble d'environ 15 tests.