Merge pull request #98 from KodrAus/feat/no-cpp

Convert simd wrapper to C

build.rs

@@ -10,8 +10,6 @@ mod build {
             .output()
             .unwrap_or_else(|e| { panic!("Failed to make simdcomp: {}", e) });
         gcc::Config::new()
-                    .cpp(true)
-                    .flag("-std=c++11")
                     .flag("-O3")
                     .flag("-mssse3")
                     .include("./cpp/simdcomp/include")
@@ -22,9 +20,8 @@ mod build {
                     .object("cpp/simdcomp/simdcomputil.o")
                     .object("cpp/simdcomp/simdpackedselect.o")
                     .object("cpp/simdcomp/simdfor.o")
-                    .file("cpp/simdcomp_wrapper.cpp")
+                    .file("cpp/simdcomp_wrapper.c")
                     .compile("libsimdcomp.a");
-        println!("cargo:rustc-flags=-l dylib=stdc++");
     }
 }
 

cpp/simdcomp_wrapper.c

@@ -0,0 +1,42 @@
+#include "simdcomp.h"
+#include "simdcomputil.h"
+
+// assumes datain has a size of 128 uint32
+// and that buffer is large enough to host the data.
+size_t compress_sorted(
+        const uint32_t* datain,
+        uint8_t* output,
+        const uint32_t offset) {
+    const uint32_t b = simdmaxbitsd1(offset, datain);
+    *output++ = b;
+    simdpackwithoutmaskd1(offset, datain, (__m128i *) output,  b);
+    return 1 + b * sizeof(__m128i);
+}
+
+// assumes datain has a size of 128 uint32
+// and that buffer is large enough to host the data.
+size_t uncompress_sorted(
+        const uint8_t* compressed_data, 
+        uint32_t* output, 
+        uint32_t offset) {
+    const uint32_t b = *compressed_data++;
+    simdunpackd1(offset, (__m128i *)compressed_data, output, b);
+    return 1 + b * sizeof(__m128i);
+}
+
+size_t compress_unsorted(
+        const uint32_t* datain,
+        uint8_t* output) {
+    const uint32_t b = maxbits(datain);
+    *output++ = b;
+    simdpackwithoutmask(datain, (__m128i *) output,  b);
+    return 1 + b * sizeof(__m128i);
+}
+
+size_t uncompress_unsorted(
+        const uint8_t* compressed_data, 
+        uint32_t* output) {
+    const uint32_t b = *compressed_data++;
+    simdunpack((__m128i *)compressed_data, output, b);
+    return 1 + b * sizeof(__m128i);
+}

cpp/simdcomp_wrapper.cpp

@@ -1,48 +0,0 @@
-#include <stdio.h>
-#include <time.h>
-#include <stdlib.h>
-#include "simdcomp.h"
-#include "simdcomputil.h"
-
-extern "C" {
-    
-    // assumes datain has a size of 128 uint32
-    // and that buffer is large enough to host the data.
-    size_t compress_sorted_cpp(
-            const uint32_t* datain,
-            uint8_t* output,
-            const uint32_t offset) {
-        const uint32_t b = simdmaxbitsd1(offset, datain);
-        *output++ = b;
-        simdpackwithoutmaskd1(offset, datain, (__m128i *) output,  b);
-        return 1 + b * sizeof(__m128i);;
-    }
-
-    // assumes datain has a size of 128 uint32
-    // and that buffer is large enough to host the data.
-    size_t uncompress_sorted_cpp(
-            const uint8_t* compressed_data, 
-            uint32_t* output, 
-            uint32_t offset) {
-        const uint32_t b = *compressed_data++;
-        simdunpackd1(offset, (__m128i *)compressed_data, output, b);
-        return 1 + b * sizeof(__m128i);
-    }
-
-    size_t compress_unsorted_cpp(
-            const uint32_t* datain,
-            uint8_t* output) {
-        const uint32_t b = maxbits(datain);
-        *output++ = b;
-        simdpackwithoutmask(datain, (__m128i *) output,  b);
-        return 1 + b * sizeof(__m128i);;
-    }
-
-    size_t uncompress_unsorted_cpp(
-            const uint8_t* compressed_data, 
-            uint32_t* output) {
-        const uint32_t b = *compressed_data++;
-        simdunpack((__m128i *)compressed_data, output, b);
-        return 1 + b * sizeof(__m128i);
-    }
-}

src/compression/compression_simd.rs

@@ -1,44 +1,46 @@
-
 use super::NUM_DOCS_PER_BLOCK;
 
-use libc::size_t;
-
 const COMPRESSED_BLOCK_MAX_SIZE: usize = NUM_DOCS_PER_BLOCK * 4 + 1; 
 
-extern {
-    fn compress_sorted_cpp(
-        data: *const u32,
-        output: *mut u8,
-        offset: u32) -> size_t;
+mod simdcomp {
+    use libc::size_t;
 
-    fn uncompress_sorted_cpp(
-        compressed_data: *const u8,
-        output: *mut u32,
-        offset: u32) -> size_t;
-        
-    fn compress_unsorted_cpp(
-        data: *const u32,
-        output: *mut u8) -> size_t;
+    #[link(name = "simdcomp")]
+    extern {
+        pub fn compress_sorted(
+            data: *const u32,
+            output: *mut u8,
+            offset: u32) -> size_t;
 
-    fn uncompress_unsorted_cpp(
-        compressed_data: *const u8,
-        output: *mut u32) -> size_t;
+        pub fn uncompress_sorted(
+            compressed_data: *const u8,
+            output: *mut u32,
+            offset: u32) -> size_t;
+            
+        pub fn compress_unsorted(
+            data: *const u32,
+            output: *mut u8) -> size_t;
+
+        pub fn uncompress_unsorted(
+            compressed_data: *const u8,
+            output: *mut u32) -> size_t;
+    }
 }
 
 fn compress_sorted(vals: &[u32], output: &mut [u8], offset: u32) -> usize {
-    unsafe { compress_sorted_cpp(vals.as_ptr(), output.as_mut_ptr(), offset) }
+    unsafe { simdcomp::compress_sorted(vals.as_ptr(), output.as_mut_ptr(), offset) }
 }
 
 fn uncompress_sorted(compressed_data: &[u8], output: &mut [u32], offset: u32) -> usize {
-    unsafe { uncompress_sorted_cpp(compressed_data.as_ptr(), output.as_mut_ptr(), offset) }
+    unsafe { simdcomp::uncompress_sorted(compressed_data.as_ptr(), output.as_mut_ptr(), offset) }
 }
 
 fn compress_unsorted(vals: &[u32], output: &mut [u8]) -> usize {
-    unsafe { compress_unsorted_cpp(vals.as_ptr(), output.as_mut_ptr()) }
+    unsafe { simdcomp::compress_unsorted(vals.as_ptr(), output.as_mut_ptr()) }
 }
 
 fn uncompress_unsorted(compressed_data: &[u8], output: &mut [u32]) -> usize {
-    unsafe { uncompress_unsorted_cpp(compressed_data.as_ptr(), output.as_mut_ptr()) }
+    unsafe { simdcomp::uncompress_unsorted(compressed_data.as_ptr(), output.as_mut_ptr()) }
 }