[xitca-web] add sync bench. (#8661)

* [xitca-web] add sync bench.

* fix wasm build.

* add url encode deserialize impl.

* update axum.

* update dep. reduce loc.

* remove toolchain patch.

* fix wasm build.

Author: fakeshadow

frameworks/Rust/xitca-web/Cargo.lock

@@ -23,23 +23,32 @@ name = "xitca-web-axum"
 path = "./src/main_axum.rs"
 required-features = ["axum", "io-uring", "pg-sync", "template"]
 
+[[bin]]
+name = "xitca-web-sync"
+path = "./src/main_sync.rs"
+required-features = ["pg-orm", "template", "web-codegen"]
+
 [features]
 # pg optional
 pg = ["xitca-postgres/single-thread"]
 # pg send/sync optional
 pg-sync = ["xitca-postgres"]
 # pg io_uring optional
 pg-iou = ["pg", "xitca-postgres/io-uring"]
+# pg orm optional
+pg-orm = ["diesel"]
 # http router optional
 router = ["xitca-http/router"]
 # web optional
 web = ["xitca-web"]
+# web codegen optional
+web-codegen = ["xitca-web/codegen", "xitca-web/urlencoded"]
 # template optional
 template = ["sailfish"]
 # io-uring optional
 io-uring = ["xitca-http/io-uring", "xitca-server/io-uring"]
 # axum optional
-axum = ["dep:axum", "http-body", "pin-project-lite", "tower", "tower-http"]
+axum = ["dep:axum", "http-body", "tower", "tower-http", "xitca-web/tower-http-compat" ]
 
 [dependencies]
 xitca-http = "0.1"
@@ -58,20 +67,21 @@ xitca-web = { version = "0.1", features = ["json"], optional = true }
 # raw-pg optional
 xitca-postgres = { version = "0.1", optional = true }
 
+# orm optional
+diesel = { version = "2", features = ["postgres", "r2d2"], optional = true }
+
 # template optional
 sailfish = { version = "0.8", default-features = false, features = ["derive", "perf-inline"], optional = true }
 
 # axum optional
-axum = { version = "0.6", optional = true }
-http-body = { version = "0.4", optional = true }
-pin-project-lite = { version = "0.2", optional = true }
+axum = { version = "0.7", optional = true }
+http-body = { version = "1", optional = true }
 tower = { version = "0.4", optional = true }
-tower-http = { version = "0.4", features = ["set-header"], optional = true }
+tower-http = { version = "0.5", features = ["set-header"], optional = true }
 
 # stuff can not be used or not needed in wasi target
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 futures-core = { version = "0.3", default-features = false }
-mimalloc = { version = "0.1", default-features = false }
 nanorand = { version = "0.7", default-features = false, features = ["tls"] }
 tokio = "1"
 
@@ -82,13 +92,5 @@ codegen-units = 1
 panic = "abort"
 
 [patch.crates-io]
-xitca-http = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-xitca-io = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-xitca-postgres = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-xitca-router = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-xitca-server = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-xitca-service = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-xitca-unsafe-collection = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-xitca-web = { git = "https://github.com/HFQR/xitca-web.git", rev = "263ea4e01f8f840dfdb3b82ba804d7b0912d5e7f" }
-
+xitca-postgres = { git = "https://github.com/HFQR/xitca-web.git", rev = "d79f510197e0f36534fe22b7a467c55dbd683681" }
 mio = { git = "https://github.com/fakeshadow/mio.git", rev = "52b72d372bfe5807755b7f5e3e1edf282954d6ba" }

frameworks/Rust/xitca-web/Cargo.toml

@@ -85,6 +85,28 @@
         "display_name": "axum [xitca]",
         "notes": "",
         "versus": ""
+      },
+      "sync": {
+        "json_url": "/json",
+        "plaintext_url": "/plaintext",
+        "db_url": "/db",
+        "fortune_url": "/fortunes",
+        "query_url": "/queries?q=",
+        "update_url": "/updates?q=",
+        "port": 8080,
+        "approach": "realistic",
+        "classification": "micro",
+        "database": "postgres",
+        "framework": "xitca-web [sync]",
+        "language": "rust",
+        "orm": "full",
+        "platform": "none",
+        "webserver": "xitca-server",
+        "os": "linux",
+        "database_os": "linux",
+        "display_name": "xitca-web [sync]",
+        "notes": "",
+        "versus": ""
       }
     }
   ]

frameworks/Rust/xitca-web/benchmark_config.json

@@ -1,11 +1,11 @@
 use std::{collections::HashMap, fmt::Write, future::IntoFuture};
 
-use xitca_postgres::{statement::Statement, AsyncIterator, Postgres};
+use xitca_postgres::{statement::Statement, AsyncLendingIterator, Postgres};
 use xitca_unsafe_collection::no_hash::NoHashBuilder;
 
 use super::{
     ser::{Fortune, Fortunes, World},
-    util::{HandleResult, Rand},
+    util::{HandleResult, Rand, DB_URL},
 };
 
 pub struct Client {
@@ -29,8 +29,8 @@ impl Drop for Client {
     }
 }
 
-pub async fn create(config: &str) -> HandleResult<Client> {
-    let (client, driver) = Postgres::new(config.to_string()).connect().await?;
+pub async fn create() -> HandleResult<Client> {
+    let (client, driver) = Postgres::new(DB_URL.to_string()).connect().await?;
 
     tokio::spawn(tokio::task::unconstrained(driver.into_future()));
 
@@ -91,11 +91,10 @@ impl Client {
         self.client
             .query_raw(&self.world, [id])
             .await?
-            .next()
-            .await
-            .ok_or_else(|| format!("World {id} does not exist"))?
+            .try_next()
+            .await?
             .map(|row| World::new(row.get_raw(0), row.get_raw(1)))
-            .map_err(Into::into)
+            .ok_or_else(|| format!("World does not exist").into())
     }
 
     pub async fn get_worlds(&self, num: u16) -> HandleResult<Vec<World>> {
@@ -110,8 +109,8 @@ impl Client {
         worlds.reserve(num as usize);
 
         let mut res = pipe.run().await?;
-        while let Some(mut item) = res.next().await.transpose()? {
-            while let Some(row) = item.next().await.transpose()? {
+        while let Some(mut item) = res.try_next().await? {
+            while let Some(row) = item.try_next().await? {
                 worlds.push(World::new(row.get_raw(0), row.get_raw(1)))
             }
         }
@@ -146,8 +145,8 @@ impl Client {
         let mut r_ids = params.into_iter().skip(1).step_by(2);
 
         let mut res = pipe.run().await?;
-        while let Some(mut item) = res.next().await.transpose()? {
-            while let Some(row) = item.next().await.transpose()? {
+        while let Some(mut item) = res.try_next().await? {
+            while let Some(row) = item.try_next().await? {
                 let r_id = r_ids.next().unwrap();
                 worlds.push(World::new(row.get_raw(0), r_id))
             }
@@ -161,7 +160,7 @@ impl Client {
         items.push(Fortune::new(0, "Additional fortune added at request time."));
 
         let mut stream = self.client.query_raw::<[i32; 0]>(&self.fortune, []).await?;
-        while let Some(row) = stream.next().await.transpose()? {
+        while let Some(row) = stream.try_next().await? {
             items.push(Fortune::new(row.get_raw(0), row.get_raw::<String>(1)));
         }
         items.sort_by(|it, next| it.message.cmp(&next.message));

frameworks/Rust/xitca-web/rust-toolchain.toml

@@ -0,0 +1,121 @@
+use std::sync::{Arc, Mutex};
+
+use diesel::{prelude::*, r2d2};
+
+use crate::{
+    ser::{Fortune, Fortunes, World},
+    util::{Error, HandleResult, Rand, DB_URL},
+};
+
+pub type Pool = Arc<_Pool>;
+
+pub struct _Pool {
+    pool: r2d2::Pool<r2d2::ConnectionManager<PgConnection>>,
+    rng: Mutex<Rand>,
+}
+
+pub fn create() -> std::io::Result<Arc<_Pool>> {
+    r2d2::Builder::new()
+        .max_size(256)
+        .min_idle(Some(256))
+        .test_on_check_out(false)
+        .idle_timeout(None)
+        .max_lifetime(None)
+        .build(r2d2::ConnectionManager::new(DB_URL))
+        .map_err(std::io::Error::other)
+        .map(|pool| {
+            Arc::new(_Pool {
+                pool,
+                rng: Mutex::new(Rand::default()),
+            })
+        })
+}
+
+#[cold]
+#[inline(never)]
+fn not_found() -> Error {
+    format!("world not found").into()
+}
+
+impl _Pool {
+    pub fn get_world(&self) -> HandleResult<World> {
+        use crate::schema::world::dsl::*;
+
+        let w_id = self.rng.lock().unwrap().gen_id();
+        let mut conn = self.pool.get()?;
+        world
+            .filter(id.eq(w_id))
+            .load(&mut conn)?
+            .pop()
+            .ok_or_else(not_found)
+    }
+
+    pub fn get_worlds(&self, num: u16) -> HandleResult<Vec<World>> {
+        use crate::schema::world::dsl::*;
+
+        let mut conn = self.pool.get()?;
+        (0..num)
+            .map(|_| {
+                let w_id = self.rng.lock().unwrap().gen_id();
+                world
+                    .filter(id.eq(w_id))
+                    .load::<World>(&mut conn)?
+                    .pop()
+                    .ok_or_else(not_found)
+            })
+            .collect()
+    }
+
+    pub fn update(&self, num: u16) -> HandleResult<Vec<World>> {
+        use crate::schema::world::dsl::*;
+
+        let mut worlds = {
+            let mut conn = self.pool.get()?;
+            let worlds = (0..num)
+                .map(|_| {
+                    let mut rng = self.rng.lock().unwrap();
+                    let w_id = rng.gen_id();
+                    let r_id = rng.gen_id();
+                    drop(rng);
+                    world
+                        .filter(id.eq(w_id))
+                        .load::<World>(&mut conn)?
+                        .pop()
+                        .map(|mut w| {
+                            w.randomnumber = r_id;
+                            w
+                        })
+                        .ok_or_else(not_found)
+                })
+                .collect::<HandleResult<Vec<_>>>()?;
+
+            worlds.iter().try_for_each(|w| {
+                diesel::update(world)
+                    .filter(id.eq(w.id))
+                    .set(randomnumber.eq(w.randomnumber))
+                    .execute(&mut conn)
+                    .map(|_| ())
+            })?;
+
+            worlds
+        };
+
+        worlds.sort_by_key(|w| w.id);
+
+        Ok(worlds)
+    }
+
+    pub fn tell_fortune(&self) -> HandleResult<Fortunes> {
+        use crate::schema::fortune::dsl::*;
+
+        let mut items = {
+            let mut conn = self.pool.get()?;
+            fortune.load::<Fortune>(&mut conn)?
+        };
+
+        items.push(Fortune::new(0, "Additional fortune added at request time."));
+        items.sort_by(|it, next| it.message.cmp(&next.message));
+
+        Ok(Fortunes::new(items))
+    }
+}

frameworks/Rust/xitca-web/src/db.rs

@@ -1,6 +1,3 @@
-#[global_allocator]
-static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
-
 mod db;
 mod ser;
 mod util;
@@ -20,14 +17,12 @@ use xitca_http::{
 };
 use xitca_service::{fn_service, Service, ServiceExt};
 
-use self::{
-    ser::{json_response, Message},
-    util::{context_mw, HandleResult, QueryParse, SERVER_HEADER_VALUE},
-};
+use ser::{json_response, Message};
+use util::{context_mw, HandleResult, QueryParse, SERVER_HEADER_VALUE};
 
-type Response = http::Response<Once<Bytes>>;
 type Request = http::Request<RequestExt<RequestBody>>;
-type Ctx<'a> = self::util::Ctx<'a, Request>;
+type Response = http::Response<Once<Bytes>>;
+type Ctx<'a> = util::Ctx<'a, Request>;
 
 fn main() -> std::io::Result<()> {
     let service = Router::new()
@@ -40,7 +35,6 @@ fn main() -> std::io::Result<()> {
         .enclosed_fn(middleware_fn)
         .enclosed(context_mw())
         .enclosed(HttpServiceBuilder::h1().io_uring());
-
     xitca_server::Builder::new()
         .bind("xitca-web", "0.0.0.0:8080", service)?
         .build()