ntex: Cleanups and optimizations (#10612)

fafhrd91 · web-flow · commit 7dcfdbd33f57 · 2026-01-23T10:20:37.000-08:00
diff --git a/frameworks/Rust/ntex/Cargo.toml b/frameworks/Rust/ntex/Cargo.toml
@@ -67,8 +67,8 @@ neon = ["ntex/neon-polling"]
 neon-uring = ["ntex/neon-uring"]
 
 [dependencies]
-ntex = "3.0.0-pre.11"
-ntex-bytes = { version = "1.2", features=["simd"] }
+ntex = "3.0.0-pre.13"
+ntex-bytes = { version = "1.4", features=["simd"] }
 mimalloc = { version = "0.1.25", default-features = false }
 snmalloc-rs = { version = "0.3.3", features = ["native-cpu"] }
 yarte = { version = "0.15", features = ["bytes-buf", "json"] }
diff --git a/frameworks/Rust/ntex/src/db.rs b/frameworks/Rust/ntex/src/db.rs
@@ -1,7 +1,5 @@
-use std::cell::Cell;
-
 use nanorand::{Rng, WyRand};
-use ntex::util::{Bytes, BytesVec};
+use ntex::util::Bytes;
 use smallvec::SmallVec;
 use tokio_postgres::{connect, Client, Statement};
 use yarte::TemplateBytesTrait;
@@ -29,11 +27,10 @@ pub struct FortunesTemplate<'a, 'b> {
 /// Postgres interface
 pub struct PgConnection {
     cl: Client,
+    rng: WyRand,
     fortune: Statement,
     world: Statement,
-    rng: WyRand,
     updates: Statement,
-    buf: Cell<Option<BytesVec>>,
 }
 
 impl PgConnection {
@@ -51,33 +48,30 @@ impl PgConnection {
 
         PgConnection {
             cl,
-            fortune,
             world,
             updates,
+            fortune,
             rng: WyRand::new(),
-            buf: Cell::new(Some(BytesVec::with_capacity(10 * 1024 * 1024))),
         }
     }
 }
 
 impl PgConnection {
     pub async fn get_world(&self) -> Bytes {
         let random_id = (self.rng.clone().generate::<u32>() % 10_000 + 1) as i32;
-
         let row = self.cl.query_one(&self.world, &[&random_id]).await.unwrap();
 
-        let mut body = self.buf.take().unwrap();
-        sonic_rs::to_writer(
-            utils::BVecWriter::new(&mut body),
-            &World {
-                id: row.get(0),
-                randomnumber: row.get(1),
-            },
-        )
-        .unwrap();
-        let result = body.take_bytes();
-        self.buf.set(Some(body));
-        result
+        utils::buffer(256, |body| {
+            sonic_rs::to_writer(
+                utils::BVecWriter(body),
+                &World {
+                    id: row.get(0),
+                    randomnumber: row.get(1),
+                },
+            )
+            .unwrap();
+            body.take()
+        })
     }
 
     pub async fn get_worlds(&self, num: usize) -> Bytes {
@@ -97,11 +91,10 @@ impl PgConnection {
             })
         }
 
-        let mut body = self.buf.take().unwrap();
-        sonic_rs::to_writer(utils::BVecWriter::new(&mut body), &worlds[..]).unwrap();
-        let result = body.take_bytes();
-        self.buf.set(Some(body));
-        result
+        utils::buffer(2 * 1024, |body| {
+            sonic_rs::to_writer(utils::BVecWriter(body), &worlds[..]).unwrap();
+            body.take()
+        })
     }
 
     pub async fn update(&self, num: usize) -> Bytes {
@@ -130,14 +123,12 @@ impl PgConnection {
         for query in queries {
             let _rand: i32 = query.await.unwrap().get(1);
         }
-
         update.await.unwrap();
 
-        let mut body = self.buf.take().unwrap();
-        sonic_rs::to_writer(utils::BVecWriter::new(&mut body), &worlds[..]).unwrap();
-        let result = body.take_bytes();
-        self.buf.set(Some(body));
-        result
+        utils::buffer(2 * 1024, |body| {
+            sonic_rs::to_writer(utils::BVecWriter(body), &worlds[..]).unwrap();
+            body.take()
+        })
     }
 
     pub async fn tell_fortune(&self) -> Bytes {
@@ -154,16 +145,13 @@ impl PgConnection {
         }));
         fortunes.sort_by(|it, next| it.message.cmp(&next.message));
 
-        let mut body = self.buf.take().unwrap();
-        utils::reserve(&mut body, 4 * 1024);
-        FortunesTemplate {
-            fortunes: &fortunes,
-        }
-        .write_call(&mut body);
-        fortunes.clear();
+        utils::buffer(4 * 1024, |body| {
+            FortunesTemplate {
+                fortunes: &fortunes,
+            }
+            .write_call(body);
 
-        let result = body.take_bytes();
-        self.buf.set(Some(body));
-        result
+            body.take()
+        })
     }
 }
diff --git a/frameworks/Rust/ntex/src/main.rs b/frameworks/Rust/ntex/src/main.rs
@@ -2,7 +2,7 @@
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 use ntex::http::header::{CONTENT_TYPE, SERVER};
-use ntex::{http, util::BytesVec, web};
+use ntex::{http, web};
 use sonic_rs::Serialize;
 
 mod utils;
@@ -14,16 +14,19 @@ pub struct Message {
 
 #[web::get("/json")]
 async fn json() -> web::HttpResponse {
-    let mut body = BytesVec::with_capacity(utils::SIZE);
-    sonic_rs::to_writer(
-        utils::BVecWriter(&mut body),
-        &Message {
-            message: "Hello, World!",
-        },
-    )
-    .unwrap();
-
-    let mut response = web::HttpResponse::with_body(http::StatusCode::OK, body.freeze().into());
+    let body = utils::buffer(256, |buf| {
+        sonic_rs::to_writer(
+            utils::BVecWriter(buf),
+            &Message {
+                message: "Hello, World!",
+            },
+        )
+        .unwrap();
+
+        buf.take()
+    });
+
+    let mut response = web::HttpResponse::with_body(http::StatusCode::OK, body.into());
     response.headers_mut().insert(SERVER, utils::HDR_SERVER);
     response
         .headers_mut()
diff --git a/frameworks/Rust/ntex/src/main_plt.rs b/frameworks/Rust/ntex/src/main_plt.rs
@@ -35,7 +35,7 @@ impl Future for App {
             match ready!(this.io.poll_recv(&this.codec, cx)) {
                 Ok((req, _)) => {
                     let _ = this.io.with_write_buf(|buf| {
-                        utils::reserve(buf, 2 * 1024);
+                        this.io.cfg().write_buf().resize(buf);
                         match req.path() {
                             "/json" => {
                                 buf.extend_from_slice(JSON);
diff --git a/frameworks/Rust/ntex/src/utils.rs b/frameworks/Rust/ntex/src/utils.rs
@@ -1,9 +1,9 @@
 #![allow(dead_code)]
-use std::{cmp, io, io::Write, mem::MaybeUninit, slice::from_raw_parts_mut};
+use std::{cell::Cell, cmp, io, io::Write, mem::MaybeUninit, slice::from_raw_parts_mut};
 
 use atoi::FromRadix10;
 use ntex::http::{header::HeaderValue, HttpServiceConfig, KeepAlive};
-use ntex::util::{BufMut, Bytes, BytesVec};
+use ntex::util::{BufMut, Bytes, BytesMut};
 use ntex::{io::IoConfig, time::Seconds, SharedCfg};
 use sonic_rs::writer::WriteExt;
 
@@ -15,7 +15,7 @@ pub const HDR_HTML_CONTENT_TYPE: HeaderValue =
 pub const BODY_PLAIN_TEXT: Bytes = Bytes::from_static(b"Hello, World!");
 
 const HW: usize = 128 * 1024;
-pub const SIZE: usize = 27;
+pub const SIZE: usize = 23;
 
 pub fn config() -> SharedCfg {
     thread_local! {
@@ -58,22 +58,28 @@ pub fn get_query_param(query: Option<&str>) -> usize {
     cmp::min(500, cmp::max(1, q) as usize)
 }
 
-pub fn reserve(buf: &mut BytesVec, lw: usize) {
-    let remaining = buf.remaining_mut();
-    if remaining < lw {
-        buf.reserve(HW);
+pub fn buffer<F, R>(lw: usize, f: F) -> R
+where
+    F: FnOnce(&mut BytesMut) -> R,
+{
+    thread_local! {
+        static BUF: Cell<Option<BytesMut>> = Cell::new(Some(BytesMut::new()));
     }
-}
-
-pub struct BVecWriter<'a>(pub &'a mut BytesVec);
+    BUF.with(|buf| {
+        let mut b = buf.take().unwrap();
+        let remaining = b.remaining_mut();
+        if remaining < lw {
+            b.reserve_capacity(HW);
+        }
 
-impl<'a> BVecWriter<'a> {
-    pub fn new(buf: &'a mut BytesVec) -> BVecWriter<'a> {
-        reserve(buf, 2048);
-        Self(buf)
-    }
+        let result = f(&mut b);
+        buf.set(Some(b));
+        result
+    })
 }
 
+pub struct BVecWriter<'a>(pub &'a mut BytesMut);
+
 impl Write for BVecWriter<'_> {
     fn write(&mut self, src: &[u8]) -> Result<usize, io::Error> {
         self.0.extend_from_slice(src);
