lazy_static rhai Engine

benches/benchmark.rs

@@ -1,10 +1,9 @@
 #![feature(test)]
-use casbin::prelude::*;
-
 extern crate test;
-
 use test::Bencher;
 
+use casbin::prelude::*;
+
 fn await_future<F, T>(future: F) -> T
 where
     F: std::future::Future<Output = T>,
@@ -479,3 +478,52 @@ fn b_benchmark_cached_priority_model(b: &mut Bencher) {
 
     b.iter(|| await_future(e.enforce(&["alice", "data1", "read"])).unwrap());
 }
+
+#[allow(dead_code)]
+mod task {
+    use std::future::Future;
+    use std::pin::Pin;
+    use std::ptr;
+    use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+
+    const RAW_WAKER: RawWaker = RawWaker::new(ptr::null(), &VTABLE);
+    const VTABLE: RawWakerVTable = RawWakerVTable::new(clone, wake, wake_by_ref, drop);
+
+    unsafe fn clone(_: *const ()) -> RawWaker {
+        RAW_WAKER
+    }
+
+    unsafe fn wake(_: *const ()) {}
+
+    unsafe fn wake_by_ref(_: *const ()) {}
+
+    unsafe fn drop(_: *const ()) {}
+
+    pub fn create() -> Waker {
+        // Safety: The waker points to a vtable with functions that do nothing. Doing
+        // nothing is always safe.
+        unsafe { Waker::from_raw(RAW_WAKER) }
+    }
+
+    /// Using this tests only the code that is polled.
+    ///
+    /// `block_on` creates no runtime overhead so a more accurate benchmark of just the code
+    /// can be collected.
+    pub fn block_on<F, T>(mut future: F) -> T
+    where
+        F: Future<Output = T>,
+    {
+        // Safety: since we own the future no one can move any part of it but us, and we won't.
+        let mut fut = unsafe { Pin::new_unchecked(&mut future) };
+        let waker = create();
+        let mut ctx = Context::from_waker(&waker);
+        loop {
+            if let Poll::Ready(res) = fut.as_mut().poll(&mut ctx) {
+                return res;
+            }
+            // TODO since criterion is single threaded simply looping seems ok
+            // burning cpu for a simpler function seems fair
+            // possible `std::sync::atomic::spin_loop_hint` here.
+        }
+    }
+}

src/enforcer.rs

@@ -12,6 +12,7 @@ use crate::{
 };
 
 use async_trait::async_trait;
+use lazy_static::lazy_static;
 use rhai::{Array, Engine, RegisterFn, Scope};
 
 use std::{
@@ -223,11 +224,15 @@ impl CoreApi for Enforcer {
     /// fn main() {}
     /// ```
     async fn enforce<S: AsRef<str> + Send + Sync>(&mut self, rvals: &[S]) -> Result<bool> {
+        lazy_static! {
+            static ref ENGINE: Arc<RwLock<Engine<'static>>> = Arc::new(RwLock::new(Engine::new()));
+        }
+
         if !self.enabled {
             return Ok(true);
         }
 
-        let mut engine = Engine::new();
+        let mut engine = ENGINE.write().unwrap();
         let mut scope: Scope = Scope::new();
 
         let r_ast = get_or_err!(self, "r", ModelError::R, "request");