Implement timeout support in the runtime, update dependencies

Author: Others

Cargo.lock

@@ -5,9 +5,11 @@ authors = ["Gregor Peach <[email protected]>"]
 edition = "2018"
 
 [dependencies]
+flexi_logger = "0.14.4"
 llvm-alt = { git = "https://github.com/Others/llvm-rs.git"}
-structopt = "0.2"
-wasmparser = "0.29"
+log = "0.4.8"
+structopt = "0.3.2"
+wasmparser = "0.39.2"
 
 [profile.release]
 debug = true

Cargo.toml

@@ -0,0 +1,20 @@
+volatile char a[] = "123456";
+volatile char b[] = "123YF";
+
+
+__attribute__ ((used))
+int my_memcmp(volatile char *vl, volatile char *vr, unsigned long n)
+{
+        volatile char *l=vl, *r=vr;
+        for (; n && *l == *r; n--, l++, r++);
+        return n ? *l-*r : 0;
+}
+
+int main() {
+    int v = my_memcmp(a, b, 4);
+    if (v != 0) {
+        return 0;
+    } else {
+        return -1;
+    }
+}

code_benches/memcmp/memcmp.c

@@ -54,6 +54,8 @@ def __str__(self):
 # TODO: Fix sphinx, which doesn't work properly on OS X
 # TODO: Do ghostscript, which has a ton of files
 programs = [
+    Program("memcmp", [], 2 ** 14),
+
     # Real world program benchmarks
     Program("libjpeg", [], 2 ** 15,
             custom_arguments=["-Wno-incompatible-library-redeclaration", "-Wno-implicit-function-declaration", "-Wno-shift-negative-value"]),

code_benches/run.py

@@ -166,6 +166,27 @@ INLINE double f64_max(double a, double b) {
 }
 
 
+// this provides a way to add a timeout for wasm execution, and support for that
+// TODO: Add a way for silverfish to give us this value
+WEAK unsigned int wasm_execution_timeout_ms = 0;
+sigjmp_buf timeout_jump;
+#define JUMPING_BACK 0xBACC
+
+// Precondition: you've already loaded timeout_jump with where we should jump after the timeout
+void handle_sigalarm(int sig) {
+    // TODO: We use siglongjmp which resets signal stuff, so perhaps this call is unnessesary
+    signal(sig, SIG_IGN);
+    siglongjmp(timeout_jump, JUMPING_BACK);
+}
+
+void schedule_timeout() {
+    signal(SIGALRM, handle_sigalarm);
+    ualarm(wasm_execution_timeout_ms * 1000, 0);
+}
+
+void cancel_timeout() {
+    ualarm(0, 0);
+}
 
 // If we are using runtime globals, we need to populate them
 WEAK void populate_globals() {}
@@ -178,11 +199,25 @@ int main(int argc, char* argv[]) {
     alloc_linear_memory();
     populate_table();
 
+    // Setup the global values (if needed), and populate the linear memory
     switch_out_of_runtime();
     populate_globals();
     switch_into_runtime();
     populate_memory();
 
+    // In the case of a real timeout being compiled in, handle that
+    if (wasm_execution_timeout_ms) {
+        // Set the jumpoint to here, and save the signal mask
+        int res = sigsetjmp(timeout_jump, 1);
+        if (res != 0) {
+            assert(res == JUMPING_BACK);
+            printf("WE DECIDED TO GIVE UP\n");
+            return -JUMPING_BACK;
+        }
+        schedule_timeout();
+    }
+
+
     // What follows is a huge cludge
     // We want to pass the program arguments to the program, so we need to copy them into an array in linear memory
     // This is about as nice as you would expect...
@@ -213,5 +248,10 @@ int main(int argc, char* argv[]) {
     int ret =  wasmf_main(argc, page_offset);
     switch_into_runtime();
 
+    // Cancel any pending timeout
+    if (wasm_execution_timeout_ms) {
+        cancel_timeout();
+    }
+
     return ret;
 }

runtime/runtime.c

@@ -4,6 +4,8 @@
 #include <limits.h>
 #include <math.h>
 #include <printf.h>
+#include <setjmp.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -52,7 +54,6 @@ extern u32 memory_size;
 
 void alloc_linear_memory();
 void expand_memory();
-// Assumption: bounds_check < WASM_PAGE_SIZE
 INLINE char* get_memory_ptr_for_runtime(u32 offset, u32 bounds_check);
 
 static inline void* get_memory_ptr_void(u32 offset, u32 bounds_check) {
@@ -87,4 +88,3 @@ INLINE char* get_function_from_table(u32 idx, u32 type_id);
 
 // libc/* might need to do some setup for the libc setup
 void stub_init(i32 offset);
-

runtime/runtime.h

@@ -6,14 +6,14 @@ use llvm::Builder;
 use llvm::Context;
 use llvm::Value;
 
-use wasmparser::Type;
+use wasmparser::TypeOrFuncType;
 
 use super::type_conversions::llvm_type_to_zeroed_value;
 use super::type_conversions::wasm_type_to_zeroed_value;
 
 pub struct BreakoutTarget<'a> {
     pub bb: &'a BasicBlock,
-    result_type: Option<Type>,
+    result_type: Option<TypeOrFuncType>,
     jumps: Vec<JumpFrom<'a>>,
 }
 
@@ -26,15 +26,15 @@ pub struct JumpFrom<'a> {
 pub type WBreakoutTarget<'a> = Rc<RefCell<BreakoutTarget<'a>>>;
 
 impl<'a> BreakoutTarget<'a> {
-    pub fn new(bb: &'a BasicBlock, result_type: Option<Type>) -> BreakoutTarget<'a> {
+    pub fn new(bb: &'a BasicBlock, result_type: Option<TypeOrFuncType>) -> BreakoutTarget<'a> {
         BreakoutTarget {
             bb,
             result_type,
             jumps: Vec::new(),
         }
     }
 
-    pub fn new_wrapped(bb: &'a BasicBlock, result_type: Option<Type>) -> WBreakoutTarget<'a> {
+    pub fn new_wrapped(bb: &'a BasicBlock, result_type: Option<TypeOrFuncType>) -> WBreakoutTarget<'a> {
         let bt = Self::new(bb, result_type);
         Rc::new(RefCell::new(bt))
     }
@@ -112,7 +112,11 @@ impl<'a> BreakoutTarget<'a> {
             if vals.is_empty() {
                 // See above comment about unreachablity
                 // TODO: Figure out if we can instead produce an unreachable result
-                wasm_type_to_zeroed_value(ctx, ty)
+                if let TypeOrFuncType::Type(t) = ty {
+                    wasm_type_to_zeroed_value(ctx, t)
+                } else {
+                    panic!()
+                }
             } else if vals.len() == 1 {
                 vals[0].1
             } else {

src/codegen/breakout.rs

@@ -11,6 +11,7 @@ use super::block::compile_block;
 use super::breakout::BreakoutTarget;
 use super::type_conversions::wasm_type_to_zeroed_value;
 use super::ModuleCtx;
+use wasmparser::TypeOrFuncType;
 
 pub struct FunctionCtx<'a> {
     pub llvm_f: &'a Function,
@@ -53,7 +54,7 @@ pub fn compile_function(ctx: &ModuleCtx, f: &ImplementedFunction) {
     };
 
     let termination_block = llvm_f.append("exit");
-    let root_breakout_target = BreakoutTarget::new_wrapped(termination_block, f.get_return_type());
+    let root_breakout_target = BreakoutTarget::new_wrapped(termination_block, f.get_return_type().map(TypeOrFuncType::Type));
 
     // In WASM, a break out of the root block is the same as returning from the function
     // Thus the termination block needs to do that

src/codegen/function.rs

@@ -1,4 +1,6 @@
 extern crate llvm;
+#[macro_use]
+extern crate log;
 extern crate structopt;
 extern crate wasmparser;
 
@@ -43,7 +45,11 @@ pub struct Opt {
 }
 
 fn main() -> io::Result<()> {
+    let log_spec = "debug";
+    flexi_logger::Logger::with_str(log_spec).start().unwrap();
+
     let opt = Opt::from_args();
+    info!("running silverfish({:?}, {:?})", opt.input, opt.output);
 
     let input_path: &Path = &opt.input;
     let input_filename = input_path.file_name().and_then(|s| s.to_str()).unwrap();
@@ -56,11 +62,15 @@ fn main() -> io::Result<()> {
     let mut parser = Parser::new(&wasm_bytes);
     let module = WasmModule::from_wasm_parser(input_filename, &mut parser);
 
+    // Get diagnostics
+    module.log_diagnostics();
+
     let output_path = opt
         .output
         .clone()
         .unwrap_or_else(|| "output.bc".to_string());
     process_to_llvm(&opt, module, &output_path)?;
 
+    info!("silverfish finished successfully");
     Ok(())
 }

src/main.rs

@@ -1,6 +1,6 @@
 use std::str;
 
-use wasmparser::CustomSectionKind;
+use wasmparser::{CustomSectionKind, TypeOrFuncType};
 use wasmparser::ExternalKind;
 use wasmparser::FuncType;
 use wasmparser::ImportSectionEntryType;
@@ -63,6 +63,32 @@ impl Global {
             },
         }
     }
+
+    pub fn in_memory_size(&self) -> usize {
+        let typ = match self {
+            Global::Imported {
+                content_type,
+                ..
+            } => content_type,
+            Global::InModule {
+                content_type,
+                ..
+            } => content_type
+        };
+
+        match typ {
+            Type::I32 => 4,
+            Type::I64 => 8,
+            Type::F32 => 4,
+            Type::F64 => 8,
+            Type::V128 => 16,
+            Type::AnyFunc => 4,
+            Type::AnyRef => 8,
+            Type::Func => 4,
+            Type::EmptyBlockType => 0,
+            Type::Null => 0,
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -217,8 +243,8 @@ pub struct TableInitializer {
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Instruction {
-    BlockStart { produced_type: Option<Type> },
-    LoopStart { produced_type: Option<Type> },
+    BlockStart { produced_type: Option<TypeOrFuncType> },
+    LoopStart { produced_type: Option<TypeOrFuncType> },
     End,
 
     Br { depth: u32 },
@@ -418,15 +444,15 @@ impl<'a> From<&'a Operator<'a>> for Instruction {
     fn from(o: &Operator<'a>) -> Self {
         match *o {
             Operator::Block { ty } => {
-                let produced_type = if ty == Type::EmptyBlockType {
+                let produced_type = if ty == TypeOrFuncType::Type(Type::EmptyBlockType) {
                     None
                 } else {
                     Some(ty)
                 };
                 Instruction::BlockStart { produced_type }
             }
             Operator::Loop { ty } => {
-                let produced_type = if ty == Type::EmptyBlockType {
+                let produced_type = if ty == TypeOrFuncType::Type(Type::EmptyBlockType) {
                     None
                 } else {
                     Some(ty)
@@ -801,6 +827,25 @@ impl WasmModule {
         m
     }
 
+    pub fn log_diagnostics(&self) {
+        let global_variable_memory_use: usize = self.globals.iter().map(|g| g.in_memory_size()).sum();
+        info!("Globals taking up {} bytes", global_variable_memory_use);
+
+        let mut data_initializer_memory_use = 0;
+        for initializer in &self.data_initializers {
+            for body_bytes in &initializer.body {
+                data_initializer_memory_use += body_bytes.len();
+            }
+        }
+        info!("Data initializers taking up {} bytes", data_initializer_memory_use);
+
+        let mut function_table_entries = 0;
+        for initializer in &self.table_initializers {
+            function_table_entries += initializer.function_indexes.len();
+        }
+        info!("Function table entries {} (ignoring fragmentation)", function_table_entries);
+    }
+
     fn implement_function(&mut self, mut f: ImplementedFunction) {
         for existing_function in &mut self.functions {
             if let Some((ty, ty_index)) = existing_function.declared_but_unimplemented() {