Merge pull request #174 from QueryaHub/perf-unify-dependencies-148

perf(cache): unify dependency arrays into contiguous Arc<[DependencyEntry]> (#148)

Author: ZhuchkaTriplesix

src/dispatch.rs

@@ -665,12 +665,7 @@ pub async fn run_rsgi(
         jwt_validation,
         read_json_body,
         read_form_body,
-        dep_names,
-        dep_factories,
-        dep_is_async,
-        dep_wants_request,
-        dep_factory_params,
-        dep_factory_varkw,
+        dependencies,
         handler_param_names,
         handler_varkw,
         body_model,
@@ -688,12 +683,7 @@ pub async fn run_rsgi(
             e.extra.jwt_validation.clone(),
             e.read_json_body,
             e.read_form_body,
-            Arc::clone(&e.extra.dep_names),
-            Arc::clone(&e.extra.dep_factories),
-            Arc::clone(&e.extra.dep_is_async),
-            Arc::clone(&e.extra.dep_wants_request),
-            Arc::clone(&e.extra.dep_factory_params),
-            Arc::clone(&e.extra.dep_factory_varkw),
+            Arc::clone(&e.extra.dependencies),
             Arc::clone(&e.extra.handler_param_names),
             e.handler_varkw,
             e.body_model.clone(),
@@ -923,7 +913,7 @@ pub async fn run_rsgi(
     } else {
         (HashMap::new(), vec![])
     };
-    let need_req_ctx = dep_wants_request.iter().any(|&x| x);
+    let need_req_ctx = dependencies.iter().any(|d| d.wants_request);
     let request_ctx: Option<Py<PyAny>> = if need_req_ctx {
         match Python::with_gil(|py| -> PyResult<Py<PyAny>> {
             let s = scope.bind(py);
@@ -939,26 +929,23 @@ pub async fn run_rsgi(
     } else {
         None
     };
-    let mut dep_out: Vec<PyObject> = Vec::with_capacity(dep_factories.len());
-    for (i, fact) in dep_factories.iter().enumerate() {
-        let wants_request = dep_wants_request.get(i) == Some(&true);
-        let factory_params = dep_factory_params.get(i);
-        let factory_varkw = dep_factory_varkw.get(i).copied().unwrap_or(false);
-        let o = if dep_is_async.get(i) == Some(&true) {
+    let mut dep_out: Vec<PyObject> = Vec::with_capacity(dependencies.len());
+    for (i, dep) in dependencies.iter().enumerate() {
+        let o = if dep.is_async {
             let r = match Python::with_gil(|py| -> PyResult<PyObject> {
                 let kw = PyDict::new(py);
-                if wants_request {
+                if dep.wants_request {
                     if let Some(ref rc) = request_ctx {
                         kw.set_item("request", rc.bind(py))?;
                     }
                 }
-                for j in 0..i {
-                    let name = &dep_names[j];
-                    if factory_varkw || factory_params.is_none_or(|p| p.contains(name)) {
+                for (j, prev_dep) in dependencies[..i].iter().enumerate() {
+                    let name = &prev_dep.name;
+                    if dep.factory_varkw || dep.factory_params.contains(name) {
                         kw.set_item(name.as_str(), dep_out[j].bind(py))?;
                     }
                 }
-                let f = fact.bind(py);
+                let f = dep.factory.bind(py);
                 if kw.is_empty() {
                     Ok(f.call0()?.unbind())
                 } else {
@@ -1012,18 +999,18 @@ pub async fn run_rsgi(
         } else {
             match Python::with_gil(|py| -> PyResult<PyObject> {
                 let kw = PyDict::new(py);
-                if wants_request {
+                if dep.wants_request {
                     if let Some(ref rc) = request_ctx {
                         kw.set_item("request", rc.bind(py))?;
                     }
                 }
-                for j in 0..i {
-                    let name = &dep_names[j];
-                    if factory_varkw || factory_params.is_none_or(|p| p.contains(name)) {
+                for (j, prev_dep) in dependencies[..i].iter().enumerate() {
+                    let name = &prev_dep.name;
+                    if dep.factory_varkw || dep.factory_params.contains(name) {
                         kw.set_item(name.as_str(), dep_out[j].bind(py))?;
                     }
                 }
-                let f = fact.bind(py);
+                let f = dep.factory.bind(py);
                 if kw.is_empty() {
                     Ok(f.call0()?.unbind())
                 } else {
@@ -1098,8 +1085,8 @@ pub async fn run_rsgi(
         read_form_body && (handler_varkw || handler_param_names.contains("files"));
     let should_pass_protocol = handler_varkw || handler_param_names.contains("protocol");
     let should_pass_body = !read_form_body && !body_bytes.is_empty() && body_json.is_none();
-    let has_dep_kwargs = dep_names.iter().enumerate().any(|(i, name)| {
-        dep_out.get(i).is_some() && (handler_varkw || handler_param_names.contains(name))
+    let has_dep_kwargs = dependencies.iter().enumerate().any(|(i, dep)| {
+        dep_out.get(i).is_some() && (handler_varkw || handler_param_names.contains(&dep.name))
     });
     let should_use_kwargs = !param_map.is_empty()
         || !query_map.is_empty()
@@ -1132,10 +1119,10 @@ pub async fn run_rsgi(
             }
             kwargs.set_item("query", qd)?;
         }
-        for (i, name) in dep_names.iter().enumerate() {
+        for (i, dep) in dependencies.iter().enumerate() {
             if let Some(oo) = dep_out.get(i) {
-                if handler_varkw || handler_param_names.contains(name) {
-                    kwargs.set_item(name, oo.bind(py))?;
+                if handler_varkw || handler_param_names.contains(&dep.name) {
+                    kwargs.set_item(&dep.name, oo.bind(py))?;
                 }
             }
         }

src/lib.rs

@@ -53,15 +53,6 @@ pub mod microbench {
     }
 }
 
-type ParsedDependencies = (
-    Vec<String>,
-    Vec<Py<PyAny>>,
-    Vec<bool>,
-    Vec<bool>,
-    Vec<HashSet<String>>,
-    Vec<bool>,
-);
-
 /// Parameter names the route handler accepts, plus whether it has `**kwargs`.
 fn handler_signature_kinds(
     py: Python<'_>,
@@ -94,16 +85,15 @@ fn parse_algorithm(s: &str) -> PyResult<jsonwebtoken::Algorithm> {
     })
 }
 
-fn parse_dependencies(py: Python<'_>, dep_list: &Bound<PyList>) -> PyResult<ParsedDependencies> {
+fn parse_dependencies(
+    py: Python<'_>,
+    dep_list: &Bound<PyList>,
+) -> PyResult<Vec<state::DependencyEntry>> {
     let inspect = py.import("inspect")?;
     let iscoro = inspect.getattr("iscoroutinefunction")?;
     let n = dep_list.len();
-    let mut names = Vec::with_capacity(n);
-    let mut facts = Vec::with_capacity(n);
-    let mut asy = Vec::with_capacity(n);
-    let mut want_req = Vec::with_capacity(n);
-    let mut factory_params = Vec::with_capacity(n);
-    let mut factory_varkw = Vec::with_capacity(n);
+    let mut names = HashSet::with_capacity(n);
+    let mut out = Vec::with_capacity(n);
     for i in 0..n {
         let it = dep_list.get_item(i)?;
         let tup = it.downcast::<PyTuple>()?;
@@ -113,24 +103,26 @@ fn parse_dependencies(py: Python<'_>, dep_list: &Bound<PyList>) -> PyResult<Pars
             ));
         }
         let name: String = tup.get_item(0)?.extract()?;
-        if names.contains(&name) {
+        if !names.insert(name.clone()) {
             return Err(pyo3::exceptions::PyValueError::new_err(
                 "duplicate dependency name",
             ));
         }
         let f: Py<PyAny> = tup.get_item(1)?.unbind();
-        let is_a: bool = iscoro.call1((f.clone_ref(py),))?.extract()?;
+        let is_async: bool = iscoro.call1((f.clone_ref(py),))?.extract()?;
         let f_b = f.bind(py);
-        let has_req: bool = dependency_wants_request(py, f_b)?;
-        let (params, varkw) = handler_signature_kinds(py, f_b)?;
-        names.push(name);
-        facts.push(f);
-        asy.push(is_a);
-        want_req.push(has_req);
-        factory_params.push(params);
-        factory_varkw.push(varkw);
+        let wants_request: bool = dependency_wants_request(py, f_b)?;
+        let (factory_params, factory_varkw) = handler_signature_kinds(py, f_b)?;
+        out.push(state::DependencyEntry {
+            name,
+            factory: f,
+            is_async,
+            wants_request,
+            factory_params,
+            factory_varkw,
+        });
     }
-    Ok((names, facts, asy, want_req, factory_params, factory_varkw))
+    Ok(out)
 }
 
 /// True if the factory declares a `request` parameter (for the request context dict).
@@ -362,17 +354,10 @@ impl App {
         } else {
             (None, None)
         };
-        let (
-            dep_names,
-            dep_factories,
-            dep_is_async,
-            dep_wants_request,
-            dep_factory_params,
-            dep_factory_varkw,
-        ) = if let Some(d) = dependencies {
+        let dependencies = if let Some(d) = dependencies {
             parse_dependencies(py, &d)?
         } else {
-            (vec![], vec![], vec![], vec![], vec![], vec![])
+            vec![]
         };
         let op_id: String = handler
             .bind(py)
@@ -383,7 +368,7 @@ impl App {
             && !require_jwt
             && !read_json_body
             && !read_form_body
-            && dep_factories.is_empty()
+            && dependencies.is_empty()
             && !handler_varkw
             && handler_param_names.is_empty();
         let mut st = self.state.write();
@@ -394,12 +379,7 @@ impl App {
             jwt_cookie,
             jwt_decoding_key,
             jwt_validation,
-            dep_names: Arc::<[String]>::from(dep_names),
-            dep_factories: Arc::<[Py<PyAny>]>::from(dep_factories),
-            dep_is_async: Arc::<[bool]>::from(dep_is_async),
-            dep_wants_request: Arc::<[bool]>::from(dep_wants_request),
-            dep_factory_params: Arc::<[HashSet<String>]>::from(dep_factory_params),
-            dep_factory_varkw: Arc::<[bool]>::from(dep_factory_varkw),
+            dependencies: Arc::<[state::DependencyEntry]>::from(dependencies),
             handler_param_names: Arc::new(handler_param_names),
             body_param_name: body_param_name.unwrap_or_else(|| "json".to_string()),
         });

src/state.rs

@@ -36,19 +36,25 @@ pub struct WebsocketRoute {
     pub is_async: bool,
 }
 
+/// A single route dependency definition.
+#[derive(Clone)]
+pub struct DependencyEntry {
+    pub name: String,
+    pub factory: Py<PyAny>,
+    pub is_async: bool,
+    pub wants_request: bool,
+    pub factory_params: HashSet<String>,
+    pub factory_varkw: bool,
+}
+
 /// Auxiliary / cold metadata for a route.
 #[derive(Clone)]
 pub struct RouteExtra {
     pub path_template: String,
     pub jwt_cookie: Option<String>,
     pub jwt_decoding_key: Option<Arc<jsonwebtoken::DecodingKey>>,
     pub jwt_validation: Option<Arc<jsonwebtoken::Validation>>,
-    pub dep_names: Arc<[String]>,
-    pub dep_factories: Arc<[Py<PyAny>]>,
-    pub dep_is_async: Arc<[bool]>,
-    pub dep_wants_request: Arc<[bool]>,
-    pub dep_factory_params: Arc<[HashSet<String>]>,
-    pub dep_factory_varkw: Arc<[bool]>,
+    pub dependencies: Arc<[DependencyEntry]>,
     pub handler_param_names: Arc<HashSet<String>>,
     pub body_param_name: String,
 }