cairo-native 0.9.0-rc.6

A compiler to convert Cairo's IR Sierra code to MLIR and execute it.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::error::Result;
use crate::{context::NativeContext, executor::JitNativeExecutor, OptLevel};
use cairo_lang_sierra::program::Program;
use std::{
    collections::HashMap,
    fmt::{self, Debug},
    hash::Hash,
    sync::Arc,
};

/// A Cache for programs with the same context.
pub struct JitProgramCache<'a, K>
where
    K: Eq + Hash + PartialEq,
{
    context: &'a NativeContext,
    // 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, Arc<JitNativeExecutor<'a>>>,
}

impl<'a, K> JitProgramCache<'a, K>
where
    K: Eq + Hash + PartialEq,
{
    pub fn new(context: &'a NativeContext) -> Self {
        Self {
            context,
            cache: Default::default(),
        }
    }

    // Return the native context.
    pub const fn context(&self) -> &'a NativeContext {
        self.context
    }

    pub fn get(&self, key: &K) -> Option<Arc<JitNativeExecutor<'a>>> {
        self.cache.get(key).cloned()
    }

    pub fn compile_and_insert(
        &mut self,
        key: K,
        program: &Program,
        opt_level: OptLevel,
    ) -> Result<Arc<JitNativeExecutor<'a>>> {
        let module = self
            .context
            .compile(program, false, Some(Default::default()), None)?;
        let executor = JitNativeExecutor::from_native_module(module, opt_level)?;

        let executor = Arc::new(executor);
        self.cache.insert(key, executor.clone());

        Ok(executor)
    }
}

impl<K> Debug for JitProgramCache<'_, K>
where
    K: Eq + Hash + PartialEq,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("JitProgramCache")
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::utils::testing::get_compiled_program;
    use std::time::Instant;

    #[test]
    fn test_cache() {
        let (_, program1) =
            get_compiled_program("test_data_artifacts/programs/libfuncs/felt252_add");

        let (_, program2) =
            get_compiled_program("test_data_artifacts/programs/libfuncs/felt252_sub");

        let context = NativeContext::new();
        let mut cache: JitProgramCache<&'static str> = JitProgramCache::new(&context);

        let start = Instant::now();
        cache
            .compile_and_insert("program1", &program1, Default::default())
            .unwrap();
        let diff_1 = Instant::now().duration_since(start);

        let start = Instant::now();
        cache.get(&"program1").expect("exists");
        let diff_2 = Instant::now().duration_since(start);

        assert!(diff_2 < diff_1);

        let start = Instant::now();
        cache
            .compile_and_insert("program2", &program2, Default::default())
            .unwrap();
        let diff_1 = Instant::now().duration_since(start);

        let start = Instant::now();
        cache.get(&"program2").expect("exists");
        let diff_2 = Instant::now().duration_since(start);

        assert!(diff_2 < diff_1);
    }
}