Make Runtime library statically linked (weld-project#229)

The current weld runtime library is dynamically loaded as a separate library. This is quite cumbersome when you use weld from java or python, such applications typically have less control over installing and loading native libraries.

This PR tries to address this by statically linking the runtime library. This was not done before because the symbols needed by the generated code are removed during linking (because they appear not to be). This was especially problematic for the executables produced, the repl and the integration tests. This problem is fixed in two ways:
- All the runtime functions (symbols) are exported in `runtime.rs` source file. This is needed to export the symbols in the library. This is very similar to approach take before weld-project@7a42598 was merged.
- We add `-export_dynamic` to the link options, and we make sure that the static library only uses one object file. Both steps are needed to make integration tests and the repl working  again. The downside to this approach is that the executables (not the libraries) almost double in size because all symbols are exported. In the future we could try to put executables on a diet by passing an explicit exported symbol list to the linker.

I have also removed the `run_named` related functionality because this is not needed anymore.

The PR has been tested on Mac and Linux.

Author: hvanhovell

.cargo/config

@@ -0,0 +1,5 @@
+[target.x86_64-apple-darwin]
+rustflags = [ "-C", "link-args=-Wl,-export_dynamic" ]
+
+[target.x86_64-unknown-linux-gnu]
+rustflags = [ "-C", "link-args=-Wl,-export-dynamic" ]

build.rs

@@ -46,6 +46,6 @@ fn main() {
     println!("cargo:rustc-link-lib=dylib=stdc++");
 
     // Link the weldrt C++ library
-    println!("cargo:rustc-link-lib=dylib=weldrt");
+    println!("cargo:rustc-link-lib=static=weldrt");
     println!("cargo:rustc-link-search=native={}/weld_rt/cpp", project_dir);
 }

tests/integration_tests.rs

@@ -2196,6 +2196,42 @@ fn predicate_if_iff_annotated() {
     check_result_and_free(ret_value, expected);
 }
 
+fn nested_for_loops() {
+    #[derive(Clone)]
+    #[allow(dead_code)]
+    struct Row {
+        x: i64,
+        y: i32,
+    }
+
+    let code = "|ys:vec[i64]|result(for(ys, appender[{i64, i32}], |b0, i0, y0| for(ys, b0, |b1, i1, y1| if (y1 > y0, merge(b0, {y0, i32(y1)}), b0))))";
+    let conf = default_conf();
+
+    // Input data.
+    let ys = vec![1i64, 3i64, 4i64];
+    let ref input_data = WeldVec {
+        data: ys.as_ptr() as *const i64,
+        len: ys.len() as i64,
+    };
+
+    let ret_value = compile_and_run(code, conf, input_data);
+    let data = unsafe { weld_value_data(ret_value) as *const WeldVec<Row> };
+    let result = unsafe { (*data).clone() };
+
+    assert_eq!(result.len, 3i64);
+    let row = unsafe { (*result.data.offset(0)).clone() };
+    assert_eq!(row.x, 1i64);
+    assert_eq!(row.y, 3);
+    let row = unsafe { (*result.data.offset(1)).clone() };
+    assert_eq!(row.x, 1i64);
+    assert_eq!(row.y, 4);
+    let row = unsafe { (*result.data.offset(2)).clone() };
+    assert_eq!(row.x, 3i64);
+    assert_eq!(row.y, 4);
+
+    unsafe { free_value_and_module(ret_value) };
+}
+
 fn main() {
     let args: Vec<String> = env::args().collect();
     let tests: Vec<(&str, fn())> =
@@ -2278,7 +2314,8 @@ fn main() {
              ("outofmemory_error_test", outofmemory_error_test),
              ("simple_float_mod", simple_float_mod),
              ("simple_int_mod", simple_int_mod),
-             ("predicate_if_iff_annotated", predicate_if_iff_annotated)];
+             ("predicate_if_iff_annotated", predicate_if_iff_annotated),
+             ("nested_for_loops", nested_for_loops)];
 
     println!("");
     println!("running tests");

weld/easy_ll/mod.rs

@@ -79,12 +79,6 @@ impl CompiledModule {
     pub fn run(&self, arg: i64) -> i64 {
         (self.run_function.unwrap())(arg)
     }
-
-    /// Call a named function in the module. The function must take and return i64.
-    pub fn run_named(&self, function_name: &str, arg: i64) -> Result<i64, LlvmError> {
-        let func = unsafe { find_function(self.engine.unwrap(), function_name)? };
-        Ok(func(arg))
-    }
 }
 
 impl Drop for CompiledModule {

weld/lib.rs

@@ -40,6 +40,7 @@ pub mod parser;
 pub mod partial_types;
 pub mod pretty_print;
 pub mod program;
+pub mod runtime;
 pub mod sir;
 pub mod tokenizer;
 pub mod transforms;
@@ -197,8 +198,7 @@ pub unsafe extern "C" fn weld_value_free(obj: *mut WeldValue) {
     }
     let value = &mut *obj;
     if let Some(run_id) = value.run_id {
-        let module = &mut *value.module.unwrap();
-        module.run_named("run_dispose", run_id).unwrap();
+        runtime::weld_run_dispose(run_id);
     }
     Box::from_raw(obj);
 }
@@ -213,8 +213,7 @@ pub unsafe extern "C" fn weld_value_memory_usage(obj: *mut WeldValue) -> libc::i
     }
     let value = &mut *obj;
     if let Some(run_id) = value.run_id {
-        let module = &mut *value.module.unwrap();
-        return module.run_named("run_memory_usage", run_id).unwrap_or(-1) as libc::int64_t;
+        return runtime::weld_run_memory_usage(run_id);
     } else {
         return -1 as libc::int64_t;
     }
@@ -242,17 +241,6 @@ pub unsafe extern "C" fn weld_module_compile(code: *const c_char,
     let code = CStr::from_ptr(code);
     let code = code.to_str().unwrap().trim();
 
-    // Let LLVM find symbols in libweldrt; it's okay to call this multiple times
-    let libweldrt = if cfg!(target_os="macos") {
-        "libweldrt.dylib"
-    } else if cfg!(target_os="windows") {
-        "libweltrt.dll"
-    } else {
-        "libweldrt.so"
-    };
-    easy_ll::load_library(libweldrt).unwrap();
-    info!("Loaded libweldrt in LLVM");
-
     info!("Started parsing program");
     let parsed = parser::parse_program(code);
     info!("Done parsing program");

weld/llvm.rs

@@ -17,6 +17,7 @@ use super::macro_processor;
 use super::passes::*;
 use super::pretty_print::*;
 use super::program::Program;
+use super::runtime::*;
 use super::sir;
 use super::sir::*;
 use super::sir::Statement::*;
@@ -92,7 +93,9 @@ pub fn compile_program(program: &Program, opt_passes: &Vec<Pass>, llvm_opt_level
     debug!("Done compiling LLVM");
 
     debug!("Started runtime_init call");
-    module.run_named("runtime_init", 0).unwrap();
+    unsafe {
+        weld_runtime_init();
+    }
     debug!("Done runtime_init call");
 
     Ok(module)

weld/resources/prelude.ll

@@ -43,16 +43,13 @@ declare float @erff(float)
 declare double @erf(double)
 
 ; Weld runtime functions
-declare void    @weld_runtime_init()
 
 declare i64     @weld_run_begin(void (%work_t*)*, i8*, i64, i32)
 declare i8*     @weld_run_get_result(i64)
-declare void    @weld_run_dispose(i64)
 
 declare i8*     @weld_run_malloc(i64, i64)
 declare i8*     @weld_run_realloc(i64, i8*, i64)
 declare void    @weld_run_free(i64, i8*)
-declare i64     @weld_run_memory_usage(i64)
 
 declare void    @weld_run_set_errno(i64, i64)
 declare i64     @weld_run_get_errno(i64)
@@ -74,21 +71,6 @@ declare i8*     @weld_rt_new_merger(i64, i32)
 declare i8*     @weld_rt_get_merger_at_index(i8*, i64, i32)
 declare void    @weld_rt_free_merger(i8*)
 
-define i64 @run_dispose(i64 %run_id) {
-    call void @weld_run_dispose(i64 %run_id)
-    ret i64 0
-}
-
-define i64 @runtime_init(i64 %unused) {
-    call void @weld_runtime_init()
-    ret i64 0
-}
-
-define i64 @run_memory_usage(i64 %run_id) {
-    %res = call i64 @weld_run_memory_usage(i64 %run_id)
-    ret i64 %res
-}
-
 ; Parallel runtime structures
 ; work_t struct in runtime.h
 %work_t = type { i8*, i64, i64, i64, i32, i64*, i64*, i32, i64, void (%work_t*)*, %work_t*, i32, i32, i32 }

weld/runtime.rs

@@ -0,0 +1,70 @@
+use libc::{c_void, int64_t, int32_t, size_t};
+
+#[allow(non_camel_case_types)]
+type work_t = c_void;
+
+#[allow(non_camel_case_types)]
+type vec_piece = c_void;
+
+#[repr(C)]
+pub struct vec_output {
+    data: *mut c_void,
+    size: i64,
+}
+
+#[link(name="weldrt", kind="static")]
+extern "C" {
+    #[no_mangle]
+    pub fn weld_runtime_init();
+    #[no_mangle]
+    pub fn weld_rt_thread_id() -> int32_t;
+    #[no_mangle]
+    pub fn weld_rt_abort_thread();
+    #[no_mangle]
+    pub fn weld_rt_get_nworkers() -> int32_t;
+    #[no_mangle]
+    pub fn weld_rt_get_run_id() -> int64_t;
+    #[no_mangle]
+    pub fn weld_rt_start_loop(w: *mut work_t,
+                              body_data: *mut c_void,
+                              cont_data: *mut c_void,
+                              body: extern "C" fn(*mut work_t),
+                              cont: extern "C" fn(*mut work_t),
+                              lower: int64_t,
+                              upper: int64_t,
+                              grain_size: int32_t);
+    #[no_mangle]
+    pub fn weld_rt_set_result(res: *mut c_void);
+    #[no_mangle]
+    pub fn weld_rt_new_vb(elem_size: int64_t, starting_cap: int64_t, fixed_size: int32_t) -> *mut c_void;
+    #[no_mangle]
+    pub fn weld_rt_new_vb_piece(v: *mut c_void, w: *mut work_t);
+    #[no_mangle]
+    pub fn weld_rt_cur_vb_piece(v: *mut c_void, my_id: int32_t) -> *mut vec_piece;
+    #[no_mangle]
+    pub fn weld_rt_result_vb(v: *mut c_void) -> vec_output;
+    #[no_mangle]
+    pub fn weld_rt_new_merger(size: int64_t, nworkers: int32_t) -> *mut c_void;
+    #[no_mangle]
+    pub fn weld_rt_get_merger_at_index(m: *mut c_void, size: int64_t, i: int32_t) -> *mut c_void;
+    #[no_mangle]
+    pub fn weld_rt_free_merger(m: *mut c_void);
+    #[no_mangle]
+    pub fn weld_run_begin(run: extern "C" fn(*mut work_t), mem_limit: int64_t, n_workers: int32_t) -> int64_t;
+    #[no_mangle]
+    pub fn weld_run_get_result(run_id: int64_t) -> *mut c_void;
+    #[no_mangle]
+    pub fn weld_run_dispose(run_id: int64_t);
+    #[no_mangle]
+    pub fn weld_run_malloc(run_id: int64_t, size: size_t) -> *mut c_void;
+    #[no_mangle]
+    pub fn weld_run_realloc(run_id: int64_t, data: *mut c_void, size: size_t) -> *mut c_void;
+    #[no_mangle]
+    pub fn weld_run_free(run_id: int64_t, data: *mut c_void);
+    #[no_mangle]
+    pub fn weld_run_memory_usage(run_id: int64_t) -> int64_t;
+    #[no_mangle]
+    pub fn weld_run_get_errno(run_id: int64_t) -> int64_t;
+    #[no_mangle]
+    pub fn weld_run_set_errno(run_id: int64_t, err: int64_t);
+}

weld_rt/cpp/Makefile

@@ -5,16 +5,16 @@ CFLAGS = -O3 -std=c++11 -Wall -fno-use-cxa-atexit -fPIC
 ifeq (${OS}, Darwin)
   # OS X
   CLANG ?= clang++-${LLVM_VERSION}
-	DYLIB = libweldrt.dylib
+	LIB = libweldrt.a
 else ifeq (${OS}, Linux)
   # Linux
   CLANG ?= clang++-${LLVM_VERSION}
-	DYLIB = libweldrt.so
+	LIB = libweldrt.a
 else
   $(error Unsupported platform: ${OS})
 endif
 
-all: ${DYLIB} inline.bc
+all: ${LIB} inline.bc
 
 inline.o: inline.cpp
 	${CLANG} ${CFLAGS} -c $< -o $@
@@ -31,15 +31,13 @@ merger.o: merger.cpp
 runtime.o: runtime.cpp
 	${CLANG} ${CFLAGS} -c $< -o $@
 
-${DYLIB}: vb.o merger.o runtime.o inline.o
-	${CLANG} -shared -o $@ $^
-	mkdir -p ../../target/release
-	cp ${DYLIB} ../../target/release
-	mkdir -p ../../target/debug
-	cp ${DYLIB} ../../target/debug
+weldrt.o: vb.o merger.o runtime.o inline.o
+	ld -r $^ -o $@
+
+${LIB}: weldrt.o
+	ar rcs $@ $^
 
 clean:
-	rm -f *.bc *.o ${DYLIB}
+	rm -f *.bc *.o ${LIB}
 
 .phony: all
-