Actix: unify and optimize platform benchmarks (#3806)

* merge raw benchmarks

* optimize platform benchmarks

Author: fafhrd91

frameworks/Rust/actix/Cargo.lock

@@ -11,10 +11,6 @@ path = "src/main.rs"
 name = "actix-raw"
 path = "src/main_raw.rs"
 
-[[bin]]
-name = "actix-raw-db"
-path = "src/main_raw_db.rs"
-
 [[bin]]
 name = "actix-diesel"
 path = "src/main_diesel.rs"

frameworks/Rust/actix/Cargo.toml

@@ -23,22 +23,6 @@
       "fortune_url": "/fortune",
       "json_url": "/json",
       "plaintext_url": "/plaintext",
-      "port": 8080,
-      "approach": "Realistic",
-      "classification": "Platform",
-      "database": "Postgres",
-      "framework": "actix",
-      "language": "Rust",
-      "orm": "Raw",
-      "platform": "None",
-      "webserver": "actix-web",
-      "os": "Linux",
-      "database_os": "Linux",
-      "display_name": "Actix [raw]",
-      "notes": "",
-      "versus": ""
-    },
-    "raw-db": {
       "db_url": "/db",
       "query_url": "/queries?q=",
       "update_url": "/updates?q=",
@@ -53,7 +37,7 @@
       "webserver": "actix-web",
       "os": "Linux",
       "database_os": "Linux",
-      "display_name": "Actix [pg-raw]",
+      "display_name": "Actix [raw]",
       "notes": "",
       "versus": ""
     },

frameworks/Rust/actix/actix-raw-db.dockerfile

@@ -114,7 +114,8 @@ impl Handler<UpdateWorld> for PgConnection {
         worlds.sort_by_key(|w| w.id);
 
         update.pop();
-        update.push_str(" ORDER BY 1) AS temp(id, randomnumber) WHERE temp.id = world.id");
+        update
+            .push_str(" ORDER BY 1) AS temp(id, randomnumber) WHERE temp.id = world.id");
         self.conn.execute(&update, &[]).unwrap();
 
         Ok(worlds)

frameworks/Rust/actix/benchmark_config.json

@@ -14,7 +14,7 @@ extern crate rand;
 #[macro_use]
 extern crate diesel;
 
-use std::io;
+use std::{cmp, mem};
 
 use actix::prelude::*;
 use actix_web::server::{self, HttpHandler, HttpHandlerTask, HttpServer, Writer};
@@ -27,8 +27,8 @@ mod db_pg;
 mod models;
 mod utils;
 
-use db_pg::{PgConnection, TellFortune};
-use utils::{Message, Writer as JsonWriter};
+use db_pg::{PgConnection, RandomWorld, RandomWorlds, TellFortune, UpdateWorld};
+use utils::{Message, StackWriter, Writer as JsonWriter};
 
 const HTTPOK: &[u8] = b"HTTP/1.1 200 OK\r\n";
 const HDR_SERVER: &[u8] = b"Server: Actix\r\n";
@@ -48,9 +48,45 @@ impl HttpHandler for App {
             match path.len() {
                 10 if path == "/plaintext" => return Ok(Box::new(Plaintext)),
                 5 if path == "/json" => return Ok(Box::new(Json)),
+                3 if path == "/db" => {
+                    return Ok(Box::new(World {
+                        fut: self.db.send(RandomWorld),
+                    }))
+                }
                 8 if path == "/fortune" => {
-                    let fut = Box::new(self.db.send(TellFortune));
-                    return Ok(Box::new(Fortune { fut }));
+                    return Ok(Box::new(Fortune {
+                        fut: self.db.send(TellFortune),
+                    }));
+                }
+                8 if path == "/queries" => {
+                    let q = req
+                        .query()
+                        .get("q")
+                        .map(|q| {
+                            cmp::min(
+                                500,
+                                cmp::max(1, q.parse::<u16>().ok().unwrap_or(1)),
+                            )
+                        })
+                        .unwrap_or(1);
+                    return Ok(Box::new(Queries {
+                        fut: self.db.send(RandomWorlds(q)),
+                    }));
+                }
+                8 if path == "/updates" => {
+                    let q = req
+                        .query()
+                        .get("q")
+                        .map(|q| {
+                            cmp::min(
+                                500,
+                                cmp::max(1, q.parse::<u16>().ok().unwrap_or(1)),
+                            )
+                        })
+                        .unwrap_or(1);
+                    return Ok(Box::new(Updates {
+                        fut: self.db.send(UpdateWorld(q)),
+                    }));
                 }
                 _ => (),
             }
@@ -96,9 +132,7 @@ impl HttpHandlerTask for Json {
 }
 
 struct Fortune {
-    fut: Box<
-        Future<Item = io::Result<Vec<models::Fortune>>, Error = actix::MailboxError>,
-    >,
+    fut: actix::dev::Request<Syn, PgConnection, TellFortune>,
 }
 
 #[derive(Template)]
@@ -111,17 +145,118 @@ impl HttpHandlerTask for Fortune {
     fn poll_io(&mut self, io: &mut Writer) -> Poll<bool, Error> {
         match self.fut.poll() {
             Ok(Async::Ready(Ok(rows))) => {
-                let tmpl = FortuneTemplate { items: &rows };
-                let body = tmpl.render().unwrap();
+                let mut body: [u8; 2048] = unsafe { mem::uninitialized() };
+                let len = {
+                    let mut writer = StackWriter(&mut body, 0);
+                    let tmpl = FortuneTemplate { items: &rows };
+                    tmpl.render_into(&mut writer).unwrap();
+                    writer.1
+                };
 
                 let mut bytes = io.buffer();
-                bytes.reserve(196 + body.len());
+                bytes.reserve(196 + len);
                 bytes.extend_from_slice(HTTPOK);
                 bytes.extend_from_slice(HDR_SERVER);
                 bytes.extend_from_slice(HDR_CTHTML);
-                server::write_content_length(body.len(), &mut bytes);
+                server::write_content_length(len, &mut bytes);
+                io.set_date(bytes);
+                bytes.extend_from_slice(&body[..len]);
+                Ok(Async::Ready(true))
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Ok(Async::Ready(Err(e))) => Err(e.into()),
+            Err(e) => Err(e.into()),
+        }
+    }
+}
+
+struct World {
+    fut: actix::dev::Request<Syn, PgConnection, RandomWorld>,
+}
+
+impl HttpHandlerTask for World {
+    fn poll_io(&mut self, io: &mut Writer) -> Poll<bool, Error> {
+        match self.fut.poll() {
+            Ok(Async::Ready(Ok(row))) => {
+                let mut body: [u8; 48] = unsafe { mem::uninitialized() };
+                let len = {
+                    let mut writer = StackWriter(&mut body, 0);
+                    serde_json::to_writer(&mut writer, &row).unwrap();
+                    writer.1
+                };
+
+                let mut bytes = io.buffer();
+                bytes.reserve(196);
+                bytes.extend_from_slice(HTTPOK);
+                bytes.extend_from_slice(HDR_SERVER);
+                bytes.extend_from_slice(HDR_CTJSON);
+                server::write_content_length(len, &mut bytes);
+                io.set_date(bytes);
+                bytes.extend_from_slice(&body[..len]);
+                Ok(Async::Ready(true))
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Ok(Async::Ready(Err(e))) => Err(e.into()),
+            Err(e) => Err(e.into()),
+        }
+    }
+}
+
+struct Queries {
+    fut: actix::dev::Request<Syn, PgConnection, RandomWorlds>,
+}
+
+impl HttpHandlerTask for Queries {
+    fn poll_io(&mut self, io: &mut Writer) -> Poll<bool, Error> {
+        match self.fut.poll() {
+            Ok(Async::Ready(Ok(worlds))) => {
+                let mut body: [u8; 24576] = unsafe { mem::uninitialized() };
+                let len = {
+                    let mut writer = StackWriter(&mut body, 0);
+                    serde_json::to_writer(&mut writer, &worlds).unwrap();
+                    writer.1
+                };
+
+                let mut bytes = io.buffer();
+                bytes.reserve(196 + len);
+                bytes.extend_from_slice(HTTPOK);
+                bytes.extend_from_slice(HDR_SERVER);
+                bytes.extend_from_slice(HDR_CTJSON);
+                server::write_content_length(len, &mut bytes);
+                io.set_date(bytes);
+                bytes.extend_from_slice(&body[..len]);
+                Ok(Async::Ready(true))
+            }
+            Ok(Async::NotReady) => Ok(Async::NotReady),
+            Ok(Async::Ready(Err(e))) => Err(e.into()),
+            Err(e) => Err(e.into()),
+        }
+    }
+}
+
+struct Updates {
+    fut: actix::dev::Request<Syn, PgConnection, UpdateWorld>,
+}
+
+impl HttpHandlerTask for Updates {
+    fn poll_io(&mut self, io: &mut Writer) -> Poll<bool, Error> {
+        match self.fut.poll() {
+            Ok(Async::Ready(Ok(worlds))) => {
+                let mut body: [u8; 24576] = unsafe { mem::uninitialized() };
+                let len = {
+                    let mut writer = StackWriter(&mut body, 0);
+                    serde_json::to_writer(&mut writer, &worlds).unwrap();
+                    writer.1
+                };
+
+                let mut bytes = io.buffer();
+                bytes.reserve(196 + len);
+                bytes.extend_from_slice(HTTPOK);
+                bytes.extend_from_slice(HDR_SERVER);
+                bytes.extend_from_slice(HDR_CTJSON);
+                server::write_content_length(len, &mut bytes);
                 io.set_date(bytes);
-                bytes.extend_from_slice(body.as_ref());
+                bytes.extend_from_slice(&body[..len]);
                 Ok(Async::Ready(true))
             }
             Ok(Async::NotReady) => Ok(Async::NotReady),