Make the contract caches thread-compatible. (#729)

src/bin/cairo-native-stress/main.rs

@@ -13,14 +13,6 @@
 //!
 //! For documentation on the specific cache used, see `NaiveAotCache`.
 
-use std::alloc::System;
-use std::fmt::{Debug, Display};
-use std::fs::{create_dir_all, read_dir, OpenOptions};
-use std::hash::Hash;
-use std::io;
-use std::path::{Path, PathBuf};
-use std::{collections::HashMap, fs, rc::Rc, time::Instant};
-
 use cairo_lang_sierra::ids::FunctionId;
 use cairo_lang_sierra::program::{GenericArg, Program};
 use cairo_lang_sierra::program_registry::ProgramRegistry;
@@ -36,6 +28,14 @@ use clap::Parser;
 use libloading::Library;
 use num_bigint::BigInt;
 use stats_alloc::{Region, StatsAlloc, INSTRUMENTED_SYSTEM};
+use std::alloc::System;
+use std::fmt::{Debug, Display};
+use std::fs::{create_dir_all, read_dir, OpenOptions};
+use std::hash::Hash;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::{collections::HashMap, fs, time::Instant};
 use tracing::{debug, info, info_span, warn};
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
@@ -246,7 +246,7 @@ where
     K: PartialEq + Eq + Hash + Display,
 {
     context: &'a NativeContext,
-    cache: HashMap<K, Rc<AotNativeExecutor>>,
+    cache: HashMap<K, Arc<AotNativeExecutor>>,
 }
 
 impl<'a, K> NaiveAotCache<'a, K>
@@ -260,7 +260,7 @@ where
         }
     }
 
-    pub fn get(&self, key: &K) -> Option<Rc<AotNativeExecutor>> {
+    pub fn get(&self, key: &K) -> Option<Arc<AotNativeExecutor>> {
         self.cache.get(key).cloned()
     }
 
@@ -272,7 +272,7 @@ where
         key: K,
         program: &Program,
         opt_level: OptLevel,
-    ) -> Rc<AotNativeExecutor> {
+    ) -> Arc<AotNativeExecutor> {
         let native_module = self
             .context
             .compile(program, None)
@@ -303,7 +303,7 @@ where
         };
 
         let executor = AotNativeExecutor::new(shared_library, registry, metadata);
-        let executor = Rc::new(executor);
+        let executor = Arc::new(executor);
 
         self.cache.insert(key, executor.clone());
 

src/cache/aot.rs

@@ -8,15 +8,15 @@ use std::{
     collections::HashMap,
     fmt::{self, Debug},
     hash::Hash,
-    rc::Rc,
+    sync::Arc,
 };
 
 pub struct AotProgramCache<'a, K>
 where
     K: PartialEq + Eq + Hash,
 {
     context: &'a NativeContext,
-    cache: HashMap<K, Rc<AotNativeExecutor>>,
+    cache: HashMap<K, Arc<AotNativeExecutor>>,
 }
 
 impl<'a, K> AotProgramCache<'a, K>
@@ -30,7 +30,7 @@ where
         }
     }
 
-    pub fn get(&self, key: &K) -> Option<Rc<AotNativeExecutor>> {
+    pub fn get(&self, key: &K) -> Option<Arc<AotNativeExecutor>> {
         self.cache.get(key).cloned()
     }
 
@@ -39,7 +39,7 @@ where
         key: K,
         program: &Program,
         opt_level: OptLevel,
-    ) -> Rc<AotNativeExecutor> {
+    ) -> Arc<AotNativeExecutor> {
         let NativeModule {
             module,
             registry,
@@ -65,7 +65,7 @@ where
             metadata.get::<GasMetadata>().cloned().unwrap(),
         );
 
-        let executor = Rc::new(executor);
+        let executor = Arc::new(executor);
         self.cache.insert(key, executor.clone());
 
         executor

src/cache/jit.rs

@@ -4,7 +4,7 @@ use std::{
     collections::HashMap,
     fmt::{self, Debug},
     hash::Hash,
-    rc::Rc,
+    sync::Arc,
 };
 
 /// A Cache for programs with the same context.
@@ -16,7 +16,7 @@ where
     // Since we already hold a reference to the Context, it doesn't make sense to use thread-safe
     // reference counting. Using a Arc<RwLock<T>> here is useless because NativeExecutor is neither
     // Send nor Sync.
-    cache: HashMap<K, Rc<JitNativeExecutor<'a>>>,
+    cache: HashMap<K, Arc<JitNativeExecutor<'a>>>,
 }
 
 impl<'a, K> JitProgramCache<'a, K>
@@ -35,7 +35,7 @@ where
         self.context
     }
 
-    pub fn get(&self, key: &K) -> Option<Rc<JitNativeExecutor<'a>>> {
+    pub fn get(&self, key: &K) -> Option<Arc<JitNativeExecutor<'a>>> {
         self.cache.get(key).cloned()
     }
 
@@ -44,11 +44,11 @@ where
         key: K,
         program: &Program,
         opt_level: OptLevel,
-    ) -> Rc<JitNativeExecutor<'a>> {
+    ) -> Arc<JitNativeExecutor<'a>> {
         let module = self.context.compile(program, None).expect("should compile");
         let executor = JitNativeExecutor::from_native_module(module, opt_level);
 
-        let executor = Rc::new(executor);
+        let executor = Arc::new(executor);
         self.cache.insert(key, executor.clone());
 
         executor

src/executor.rs

@@ -28,7 +28,7 @@ use std::{
     alloc::Layout,
     arch::global_asm,
     ptr::{addr_of_mut, null_mut, NonNull},
-    rc::Rc,
+    sync::Arc,
 };
 
 mod aot;
@@ -56,8 +56,8 @@ extern "C" {
 /// The cairo native executor, either AOT or JIT based.
 #[derive(Debug, Clone)]
 pub enum NativeExecutor<'m> {
-    Aot(Rc<AotNativeExecutor>),
-    Jit(Rc<JitNativeExecutor<'m>>),
+    Aot(Arc<AotNativeExecutor>),
+    Jit(Arc<JitNativeExecutor<'m>>),
 }
 
 impl<'a> NativeExecutor<'a> {
@@ -123,13 +123,13 @@ impl<'a> NativeExecutor<'a> {
 
 impl<'m> From<AotNativeExecutor> for NativeExecutor<'m> {
     fn from(value: AotNativeExecutor) -> Self {
-        Self::Aot(Rc::new(value))
+        Self::Aot(Arc::new(value))
     }
 }
 
 impl<'m> From<JitNativeExecutor<'m>> for NativeExecutor<'m> {
     fn from(value: JitNativeExecutor<'m>) -> Self {
-        Self::Jit(Rc::new(value))
+        Self::Jit(Arc::new(value))
     }
 }
 

src/executor/aot.rs

@@ -31,6 +31,9 @@ pub struct AotNativeExecutor {
     gas_metadata: GasMetadata,
 }
 
+unsafe impl Send for AotNativeExecutor {}
+unsafe impl Sync for AotNativeExecutor {}
+
 impl AotNativeExecutor {
     pub fn new(
         library: Library,

src/executor/jit.rs

@@ -28,6 +28,9 @@ pub struct JitNativeExecutor<'m> {
     gas_metadata: GasMetadata,
 }
 
+unsafe impl<'a> Send for JitNativeExecutor<'a> {}
+unsafe impl<'a> Sync for JitNativeExecutor<'a> {}
+
 impl std::fmt::Debug for JitNativeExecutor<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("JitNativeExecutor")