wip

Author: fafhrd91

frameworks/Rust/ntex/Cargo.toml

@@ -67,7 +67,7 @@ neon = ["ntex/neon-polling"]
 neon-uring = ["ntex/neon-uring"]
 
 [dependencies]
-ntex = "3.0.0-pre.10"
+ntex = "3.0.0-pre.11"
 ntex-bytes = { version = "1.2", features=["simd"] }
 mimalloc = { version = "0.1.25", default-features = false }
 snmalloc-rs = { version = "0.3.3", features = ["native-cpu"] }

frameworks/Rust/ntex/src/db.rs

@@ -1,7 +1,7 @@
 use std::cell::Cell;
 
 use nanorand::{Rng, WyRand};
-use ntex::util::{Bytes, BytesVec, BufMut};
+use ntex::util::{Bytes, BytesVec};
 use smallvec::SmallVec;
 use tokio_postgres::{connect, Client, Statement};
 use yarte::TemplateBytesTrait;
@@ -155,11 +155,7 @@ impl PgConnection {
         fortunes.sort_by(|it, next| it.message.cmp(&next.message));
 
         let mut body = self.buf.take().unwrap();
-        let remaining = body.remaining_mut();
-        if remaining < 4 * 1024 {
-            body.reserve(128 * 1024);
-        }
-
+        utils::reserve(&mut body, 4 * 1024);
         FortunesTemplate {
             fortunes: &fortunes,
         }

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::BytesMut, web};
+use ntex::{http, util::BytesVec, web};
 use sonic_rs::Serialize;
 
 mod utils;
@@ -14,16 +14,16 @@ pub struct Message {
 
 #[web::get("/json")]
 async fn json() -> web::HttpResponse {
-    let mut body = BytesMut::with_capacity(utils::SIZE);
+    let mut body = BytesVec::with_capacity(utils::SIZE);
     sonic_rs::to_writer(
-        utils::BytesWriter(&mut body),
+        utils::BVecWriter(&mut body),
         &Message {
             message: "Hello, World!",
         },
     )
     .unwrap();
 
-    let mut response = web::HttpResponse::with_body(http::StatusCode::OK, body.into());
+    let mut response = web::HttpResponse::with_body(http::StatusCode::OK, body.freeze().into());
     response.headers_mut().insert(SERVER, utils::HDR_SERVER);
     response
         .headers_mut()

frameworks/Rust/ntex/src/main_plt.rs

@@ -3,7 +3,7 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 use std::{future::Future, io, pin::Pin, task::ready, task::Context, task::Poll};
 
-use ntex::{fn_service, http::h1, io::Io, io::RecvError};
+use ntex::{fn_service, http::h1, http::DateService, io::Io, io::RecvError};
 use sonic_rs::Serialize;
 
 mod utils;
@@ -35,32 +35,30 @@ impl Future for App {
             match ready!(this.io.poll_recv(&this.codec, cx)) {
                 Ok((req, _)) => {
                     let _ = this.io.with_write_buf(|buf| {
-                        buf.with_bytes_mut(|buf| {
-                            utils::reserve(buf, 2 * 1024);
-                            match req.path() {
-                                "/json" => {
-                                    buf.extend_from_slice(JSON);
-                                    this.codec.set_date_header(buf);
+                        utils::reserve(buf, 2 * 1024);
+                        match req.path() {
+                            "/json" => {
+                                buf.extend_from_slice(JSON);
+                                DateService.bset_date_header(buf);
 
-                                    sonic_rs::to_writer(
-                                        utils::BytesWriter(buf),
-                                        &Message {
-                                            message: "Hello, World!",
-                                        },
-                                    )
-                                    .unwrap();
-                                }
-                                "/plaintext" => {
-                                    buf.extend_from_slice(PLAIN);
-                                    this.codec.set_date_header(buf);
-                                    buf.extend_from_slice(BODY);
-                                }
-                                _ => {
-                                    buf.extend_from_slice(HTTPNFOUND);
-                                    buf.extend_from_slice(HDR_SERVER);
-                                }
+                                sonic_rs::to_writer(
+                                    utils::BVecWriter(buf),
+                                    &Message {
+                                        message: "Hello, World!",
+                                    },
+                                )
+                                .unwrap();
                             }
-                        })
+                            "/plaintext" => {
+                                buf.extend_from_slice(PLAIN);
+                                DateService.bset_date_header(buf);
+                                buf.extend_from_slice(BODY);
+                            }
+                            _ => {
+                                buf.extend_from_slice(HTTPNFOUND);
+                                buf.extend_from_slice(HDR_SERVER);
+                            }
+                        }
                     });
                 }
                 Err(RecvError::WriteBackpressure) => {

frameworks/Rust/ntex/src/utils.rs

@@ -3,7 +3,7 @@ use std::{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, BytesMut, BytesVec};
+use ntex::util::{BufMut, Bytes, BytesVec};
 use ntex::{io::IoConfig, time::Seconds, SharedCfg};
 use sonic_rs::writer::WriteExt;
 
@@ -58,55 +58,18 @@ pub fn get_query_param(query: Option<&str>) -> usize {
     cmp::min(500, cmp::max(1, q) as usize)
 }
 
-pub fn reserve(buf: &mut BytesMut, lw: usize) {
+pub fn reserve(buf: &mut BytesVec, lw: usize) {
     let remaining = buf.remaining_mut();
     if remaining < lw {
         buf.reserve(HW);
     }
 }
 
-pub struct BytesWriter<'a>(pub &'a mut BytesMut);
-
-impl Write for BytesWriter<'_> {
-    fn write(&mut self, src: &[u8]) -> Result<usize, io::Error> {
-        self.0.extend_from_slice(src);
-        Ok(src.len())
-    }
-
-    fn flush(&mut self) -> Result<(), io::Error> {
-        Ok(())
-    }
-}
-
-impl WriteExt for BytesWriter<'_> {
-    #[inline(always)]
-    fn reserve_with(&mut self, additional: usize) -> Result<&mut [MaybeUninit<u8>], io::Error> {
-        self.0.reserve(additional);
-
-        unsafe {
-            let ptr = self.0.as_mut_ptr().add(self.0.len()) as *mut MaybeUninit<u8>;
-            Ok(from_raw_parts_mut(ptr, additional))
-        }
-    }
-
-    #[inline(always)]
-    unsafe fn flush_len(&mut self, additional: usize) -> io::Result<()> {
-        unsafe {
-            let new_len = self.0.len() + additional;
-            self.0.set_len(new_len);
-        }
-        Ok(())
-    }
-}
-
-pub struct BVecWriter<'a>(&'a mut BytesVec);
+pub struct BVecWriter<'a>(pub &'a mut BytesVec);
 
 impl<'a> BVecWriter<'a> {
     pub fn new(buf: &'a mut BytesVec) -> BVecWriter<'a> {
-        let remaining = buf.remaining_mut();
-        if remaining < 2048 {
-            buf.reserve(HW);
-        }
+        reserve(buf, 2048);
         Self(buf)
     }
 }