Add support for benchmarking D's std.regex

This commit adds support for benchmarking the runtime version of the D
programming language's std.regex using the dmd and ldc compilers.

Closes #430

Author: mrmonday

bench/Cargo.toml

@@ -47,6 +47,8 @@ re-pcre1 = ["libpcre-sys"]
 re-pcre2 = []
 re-onig = ["onig"]
 re-re2 = []
+re-dphobos-dmd = []
+re-dphobos-ldc = []
 re-rust = []
 re-rust-bytes = []
 re-tcl = []

bench/build.rs

@@ -12,6 +12,7 @@ extern crate cc;
 extern crate pkg_config;
 
 use std::env;
+use std::process;
 
 fn main() {
     if env::var("CARGO_FEATURE_RE_PCRE2").is_ok() {
@@ -30,4 +31,69 @@ fn main() {
     if env::var("CARGO_FEATURE_RE_TCL").is_ok() {
         pkg_config::probe_library("tcl").unwrap();
     }
+
+    if env::var("CARGO_FEATURE_RE_DPHOBOS_DMD").is_ok() {
+        process::Command::new("dmd")
+                    .arg("--version")
+                    .stdout(process::Stdio::null())
+                    .stderr(process::Stdio::null())
+                    .spawn()
+                    .unwrap();
+
+        let out_dir = env::var("OUT_DIR").unwrap();
+        let out_file = &format!("-of={}/libdphobos-dmd.a", out_dir);
+
+        let res = process::Command::new("dmd")
+            .arg("-w")
+            .arg("-lib")
+            .arg("-O")
+            .arg("-release")
+            .arg("-inline")
+            .arg("src/ffi/d_phobos.d")
+            .arg(out_file)
+            .output()
+            .expect("unable to compile dphobos-regex (dmd)");
+
+        if !res.status.success() {
+            println!("{}", String::from_utf8_lossy(&res.stderr));
+        }
+        assert!(res.status.success());
+
+        println!("cargo:rustc-link-search=native={}", out_dir);
+        println!("cargo:rustc-link-lib=dphobos-dmd");
+        println!("cargo:rustc-link-lib=phobos2");
+    }
+
+    if env::var("CARGO_FEATURE_RE_DPHOBOS_LDC").is_ok() {
+        process::Command::new("ldc")
+                    .arg("--version")
+                    .stdout(process::Stdio::null())
+                    .stderr(process::Stdio::null())
+                    .spawn()
+                    .unwrap();
+
+        let out_dir = env::var("OUT_DIR").unwrap();
+        let out_file = &format!("-of={}/libdphobos-ldc.a", out_dir);
+
+        let res = process::Command::new("ldc")
+            .arg("-w")
+            .arg("-lib")
+            .arg("-O3")
+            .arg("-release")
+            .arg("-mcpu=native")
+            .arg("src/ffi/d_phobos.d")
+            .arg(out_file)
+            .output()
+            .expect("unable to compile dphobos-regex (ldc)");
+
+        if !res.status.success() {
+            println!("{}", String::from_utf8_lossy(&res.stderr));
+        }
+        assert!(res.status.success());
+
+        println!("cargo:rustc-link-search=native={}", out_dir);
+        println!("cargo:rustc-link-lib=dphobos-ldc");
+        println!("cargo:rustc-link-lib=druntime-ldc");
+        println!("cargo:rustc-link-lib=phobos2-ldc");
+    }
 }

bench/compile

@@ -5,5 +5,5 @@ export RUSTFLAGS="-C target-cpu=native"
 
 exec cargo build \
   --release \
-  --features 're-onig re-pcre1 re-pcre2 re-re2 re-rust re-rust-bytes re-tcl' \
+  --features 're-onig re-pcre1 re-pcre2 re-rust re-rust-bytes re-tcl re-dphobos-dmd re-dphobos-ldc' \
   "$@"

bench/run

@@ -1,7 +1,7 @@
 #!/bin/bash
 
 usage() {
-  echo "Usage: $(basename $0) [rust | rust-bytes | pcre1 | pcre2 | re2 | onig | tcl ]" >&2
+  echo "Usage: $(basename $0) [dphobos-dmd | dphobos-ldc | rust | rust-bytes | pcre1 | pcre2 | re2 | onig | tcl ]" >&2
   exit 1
 }
 
@@ -16,6 +16,12 @@ export RUSTFLAGS="-C target-cpu=native"
 which="$1"
 shift
 case $which in
+  dphobos-dmd)
+    exec cargo bench --bench bench --features re-dphobos-dmd "$@"
+    ;;
+  dphobos-ldc)
+    exec cargo bench --bench bench --features re-dphobos-ldc "$@"
+    ;;
   rust)
     exec cargo bench --bench bench --features re-rust "$@"
     ;;

bench/src/bench.rs

@@ -37,6 +37,9 @@ pub use ffi::pcre1::Regex;
 pub use ffi::pcre2::Regex;
 #[cfg(feature = "re-re2")]
 pub use ffi::re2::Regex;
+#[cfg(any(feature = "re-dphobos-dmd",
+          feature = "re-dphobos-ldc"))]
+pub use ffi::d_phobos::Regex;
 #[cfg(feature = "re-rust")]
 pub use regex::Regex;
 #[cfg(feature = "re-rust-bytes")]
@@ -89,6 +92,8 @@ macro_rules! text {
     feature = "re-pcre1",
     feature = "re-pcre2",
     feature = "re-re2",
+    feature = "re-dphobos-ldc",
+    feature = "re-dphobos-dmd",
     feature = "re-rust",
   ))]
 macro_rules! text {
@@ -105,6 +110,8 @@ type Text = Vec<u8>;
     feature = "re-pcre1",
     feature = "re-pcre2",
     feature = "re-re2",
+    feature = "re-dphobos-ldc",
+    feature = "re-dphobos-dmd",
     feature = "re-rust",
   ))]
 type Text = String;

bench/src/ffi/d_phobos.d

@@ -0,0 +1,56 @@
+module d_phobos;
+
+import core.memory;
+import core.stdc.stdlib : malloc, free;
+
+import std.regex;
+import std.string;
+import std.typecons;
+
+import std.stdio;
+
+auto rustRegexToD(string regex) {
+    auto flags = "g";
+    if (regex.startsWith("(?i)")) {
+        flags = "gi";
+        regex = regex[4..$];
+    } else if (regex.startsWith("(?m)")) {
+        flags = "gm";
+        regex = regex[4..$];
+    }
+
+    return tuple(regex.dup, flags);
+}
+
+extern(C):
+
+void* d_phobos_regex_new(string s) {
+    auto r = cast(Regex!char*)malloc(Regex!char.sizeof);
+
+    *r = regex(rustRegexToD(s).expand);
+
+    return r;
+}
+
+void d_phobos_regex_free(void* r) {
+    free(r);
+}
+
+bool d_phobos_regex_is_match(void* r, string s) {
+    auto regex = *cast(Regex!char*)r;
+    return !matchFirst(s, regex).empty;
+}
+
+bool d_phobos_regex_find_at(void* r, string s, size_t start, out size_t match_start, out size_t match_end) {
+    auto regex = *cast(Regex!char*)r;
+    auto match = matchFirst(s[start..$], regex);
+
+    if (match.empty) {
+        return false;
+    }
+
+    match_start = match.pre().ptr - s.ptr;
+    match_end = match.post().ptr - s.ptr;
+    return true;
+}
+

bench/src/ffi/d_phobos.rs

@@ -0,0 +1,115 @@
+#![allow(non_camel_case_types)]
+
+use libc::{c_uchar, c_void};
+
+/// Regex wraps a D regular expression
+pub struct Regex {
+    re: *mut d_regex,
+}
+
+unsafe impl Send for Regex {}
+
+impl Drop for Regex {
+    fn drop(&mut self) {
+        unsafe {
+            d_phobos_regex_free(self.re);
+            rt_term();
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Error(());
+
+impl Regex {
+    pub fn new(pattern: &str) -> Result<Regex, Error> {
+        unsafe {
+            rt_init();
+
+            Ok(Regex { re: d_phobos_regex_new(pattern.into()) })
+        }
+    }
+
+    pub fn is_match(&self, text: &str) -> bool {
+        unsafe {
+            d_phobos_regex_is_match(self.re, text.into())
+        }
+    }
+
+    pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> FindMatches<'r, 't> {
+        FindMatches {
+            re: self,
+            text: text,
+            last_end: 0,
+            last_match: None,
+        }
+    }
+
+    fn find_at(&self, text: &str, start: usize) -> Option<(usize, usize)> {
+        let (mut s, mut e): (usize, usize) = (0, 0);
+        let matched = unsafe {
+            d_phobos_regex_find_at(
+                self.re,
+                text.into(),
+                start,
+                &mut s,
+                &mut e,
+            )
+        };
+        if matched {
+            Some((s, e))
+        } else {
+            None
+        }
+    }
+}
+
+pub struct FindMatches<'r, 't> {
+    re: &'r Regex,
+    text: &'t str,
+    last_end: usize,
+    last_match: Option<usize>,
+}
+
+impl<'r, 't> Iterator for FindMatches<'r, 't> {
+    type Item = (usize, usize);
+
+    fn next(&mut self) -> Option<(usize, usize)> {
+        match self.re.find_at(self.text, self.last_end) {
+            None => None,
+            Some((s, e)) => {
+                self.last_end = e;
+                Some((s, e))
+            }
+        }
+    }
+}
+
+type d_regex = c_void;
+
+#[repr(C)]
+struct d_string {
+    len: usize,
+    text: *const c_uchar,
+}
+
+impl<'a> From<&'a str> for d_string {
+    fn from(s: &'a str) -> d_string {
+        d_string { len: s.len(), text: s.as_ptr() }
+    }
+}
+
+extern {
+    fn rt_init() -> i32;
+    fn rt_term() -> i32;
+    fn d_phobos_regex_new(s: d_string) -> *mut d_regex;
+    fn d_phobos_regex_free(r: *mut d_regex);
+    fn d_phobos_regex_is_match(r: *mut d_regex, s: d_string) -> bool;
+    fn d_phobos_regex_find_at(r: *mut d_regex,
+                              s: d_string,
+                              start: usize,
+                              match_start: *mut usize,
+                              match_end: *mut usize)
+        -> bool;
+}
+

bench/src/ffi/mod.rs

@@ -12,6 +12,9 @@
 // of conditional compilation and such.
 #![allow(dead_code)]
 
+#[cfg(any(feature = "re-dphobos-dmd",
+          feature = "re-dphobos-ldc"))]
+pub mod d_phobos;
 #[cfg(feature = "re-onig")]
 pub mod onig;
 #[cfg(feature = "re-pcre1")]

bench/src/sherlock.rs

@@ -88,10 +88,14 @@ sherlock!(the_whitespace, r"the\s+\w+", 5410);
 
 // How fast can we match everything? This essentially defeats any clever prefix
 // tricks and just executes the DFA across the entire input.
+#[cfg(not(feature = "re-dphobos-dmd"))]
+#[cfg(not(feature = "re-dphobos-ldc"))]
 #[cfg(not(feature = "re-pcre1"))]
 #[cfg(not(feature = "re-pcre2"))]
 #[cfg(not(feature = "re-tcl"))]
 sherlock!(everything_greedy, r".*", 13053);
+#[cfg(not(feature = "re-dphobos-dmd"))]
+#[cfg(not(feature = "re-dphobos-ldc"))]
 #[cfg(not(feature = "re-onig"))]
 #[cfg(not(feature = "re-pcre1"))]
 #[cfg(not(feature = "re-pcre2"))]
@@ -148,10 +152,19 @@ sherlock!(quotes, r#"["'][^"']{0,30}[?!.]["']"#, 767);
 // Finds all occurrences of Sherlock Holmes at the beginning or end of a line.
 // The empty assertions defeat any detection of prefix literals, so it's the
 // lazy DFA the entire way.
+#[cfg(not(any(feature = "re-dphobos-dmd",
+              feature = "re-dphobos-ldc")))]
 sherlock!(
     line_boundary_sherlock_holmes,
     r"(?m)^Sherlock Holmes|Sherlock Holmes$",
     34);
+// D matches both \r\n and \n as EOL
+#[cfg(any(feature = "re-dphobos-dmd",
+          feature = "re-dphobos-ldc"))]
+sherlock!(
+    line_boundary_sherlock_holmes,
+    r"(?m)^Sherlock Holmes|Sherlock Holmes$",
+    37);
 
 // All words ending in `n`. This uses Unicode word boundaries, which the DFA
 // can speculatively handle. Since this benchmark is on mostly ASCII text, it