Issue #417: Retain whether or not a module was compiled with --count-instructions. (#421)

Author: fst-crenshaw

lucet-module/src/module_data.rs

@@ -58,6 +58,7 @@ pub struct ModuleFeatures {
     pub bmi2: bool,
     pub lzcnt: bool,
     pub popcnt: bool,
+    pub instruction_count: bool,
     _hidden: (),
 }
 
@@ -73,6 +74,7 @@ impl ModuleFeatures {
             bmi2: false,
             lzcnt: false,
             popcnt: false,
+            instruction_count: false,
             _hidden: (),
         }
     }

lucet-runtime/lucet-runtime-internals/src/instance.rs

@@ -730,8 +730,11 @@ impl Instance {
     }
 
     #[inline]
-    pub fn get_instruction_count(&self) -> u64 {
-        self.get_instance_implicits().instruction_count
+    pub fn get_instruction_count(&self) -> Option<u64> {
+        if self.module.is_instruction_count_instrumented() {
+            return Some(self.get_instance_implicits().instruction_count);
+        }
+        None
     }
 
     #[inline]

lucet-runtime/lucet-runtime-internals/src/module.rs

@@ -38,6 +38,11 @@ pub trait Module: ModuleInternal {
 }
 
 pub trait ModuleInternal: Send + Sync {
+    /// Determine whether this module has been instrumented with additional
+    /// instructions that monitor the number of wasm operations executed
+    /// during runtime.
+    fn is_instruction_count_instrumented(&self) -> bool;
+
     fn heap_spec(&self) -> Option<&HeapSpec>;
 
     /// Get the WebAssembly globals of the module.

lucet-runtime/lucet-runtime-internals/src/module/dl.rs

@@ -203,6 +203,10 @@ impl DlModule {
 impl Module for DlModule {}
 
 impl ModuleInternal for DlModule {
+    fn is_instruction_count_instrumented(&self) -> bool {
+        self.module.module_data.features().instruction_count
+    }
+
     fn heap_spec(&self) -> Option<&HeapSpec> {
         self.module.module_data.heap_spec()
     }

lucet-runtime/lucet-runtime-internals/src/module/mock.rs

@@ -260,6 +260,10 @@ unsafe impl Sync for MockModule {}
 impl Module for MockModule {}
 
 impl ModuleInternal for MockModule {
+    fn is_instruction_count_instrumented(&self) -> bool {
+        self.module_data.features().instruction_count
+    }
+
     fn heap_spec(&self) -> Option<&HeapSpec> {
         self.module_data.heap_spec()
     }

lucet-runtime/tests/instruction_counting.rs

@@ -7,10 +7,13 @@ use std::path::Path;
 use std::sync::Arc;
 use tempfile::TempDir;
 
-pub fn wasm_test<P: AsRef<Path>>(wasm_file: P) -> Result<Arc<DlModule>, Error> {
+pub fn wasm_test<P: AsRef<Path>>(
+    wasm_file: P,
+    icount_option: bool,
+) -> Result<Arc<DlModule>, Error> {
     let workdir = TempDir::new().expect("create working directory");
 
-    let native_build = Lucetc::new(wasm_file).with_count_instructions(true);
+    let native_build = Lucetc::new(wasm_file).with_count_instructions(icount_option);
 
     let so_file = workdir.path().join("out.so");
 
@@ -21,9 +24,8 @@ pub fn wasm_test<P: AsRef<Path>>(wasm_file: P) -> Result<Arc<DlModule>, Error> {
     Ok(dlmodule)
 }
 
-#[test]
-pub fn check_instruction_counts() {
-    let files: Vec<DirEntry> = std::fs::read_dir("./tests/instruction_counting")
+pub fn get_instruction_count_test_files() -> Vec<DirEntry> {
+    std::fs::read_dir("./tests/instruction_counting")
         .expect("can iterate test files")
         .map(|ent| {
             let ent = ent.expect("can get test files");
@@ -33,7 +35,12 @@ pub fn check_instruction_counts() {
             );
             ent
         })
-        .collect();
+        .collect()
+}
+
+#[test]
+pub fn check_instruction_count_off() {
+    let files: Vec<DirEntry> = get_instruction_count_test_files();
 
     assert!(
         files.len() > 0,
@@ -42,7 +49,8 @@ pub fn check_instruction_counts() {
 
     files.par_iter().for_each(|ent| {
         let wasm_path = ent.path();
-        let module = wasm_test(&wasm_path).expect("can load module");
+        let do_not_instrument = false;
+        let module = wasm_test(&wasm_path, do_not_instrument).expect("can load module");
 
         let region = MmapRegion::create(1, &Limits::default()).expect("region can be created");
 
@@ -53,6 +61,37 @@ pub fn check_instruction_counts() {
         inst.run("test_function", &[]).expect("instance runs");
 
         let instruction_count = inst.get_instruction_count();
+        if instruction_count.is_some() {
+            panic!("instruction count instrumentation was not expected from instance");
+        }
+    });
+}
+
+#[test]
+pub fn check_instruction_count() {
+    let files: Vec<DirEntry> = get_instruction_count_test_files();
+
+    assert!(
+        files.len() > 0,
+        "there are no test cases in the `instruction_counting` directory"
+    );
+
+    files.par_iter().for_each(|ent| {
+        let wasm_path = ent.path();
+        let do_instrument = true;
+        let module = wasm_test(&wasm_path, do_instrument).expect("can load instrumented module");
+
+        let region = MmapRegion::create(1, &Limits::default()).expect("region can be created");
+
+        let mut inst = region
+            .new_instance(module)
+            .expect("instance can be created");
+
+        inst.run("test_function", &[]).expect("instance runs");
+
+        let instruction_count = inst
+            .get_instruction_count()
+            .expect("instruction count expected from instance");
 
         assert_eq!(
             instruction_count,

lucetc/src/compiler.rs

@@ -131,8 +131,9 @@ impl<'a> Compiler<'a> {
     }
 
     pub fn module_features(&self) -> ModuleFeatures {
-        // This will grow in the future to encompass other options describing the compiled module.
-        (&self.cpu_features).into()
+        let mut mf: ModuleFeatures = (&self.cpu_features).into();
+        mf.instruction_count = self.count_instructions;
+        mf
     }
 
     pub fn module_data(&self) -> Result<ModuleData<'_>, Error> {