Add example for parallel sort

Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 readme = "README.md"
 repository = "https://github.com/STEllAR-GROUP/hpx-rs"
 description = """
-Bindings to hpx for interoperating with stellar-group hpx library for 
+Bindings to hpx for interoperating with stellar-group hpx library for
 concurrency and parallelism.
 """
 categories = ["api-bindings"]
@@ -17,4 +17,4 @@ publish = false
 hpx-sys = { path = "hpx-sys", version = "0.1.0" }
 
 [workspace]
-members = []
+members = [ "hpx-examples"]

hpx-examples/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "hpx-examples"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+hpx-sys = { path = "../hpx-sys", version = "0.1.0" }

hpx-examples/src/main.rs

@@ -0,0 +1,19 @@
+#![feature(vec_into_raw_parts)]
+#![feature(random)]
+use core::array::from_fn;
+use std::{env, process, random};
+
+fn hpx_main(_: Vec<String>) -> i32 {
+    let numbers: &[i32; 16384] = &from_fn(|_| random::random::<i32>());
+    let list: &mut Vec<i32> = &mut Vec::<i32>::from(numbers);
+    println!("{:#?}", list);
+    // Sort the array in parallel.
+    hpx_sys::ffi::hpx_sort_comp(list, |a, b| a < b);
+    println!("{:#?}", list);
+    hpx_sys::ffi::finalize();
+    return 0;
+}
+fn main() {
+    let args = env::args().collect::<Vec<String>>();
+    process::exit(hpx_sys::init(hpx_main, args));
+}

hpx-sys/src/lib.rs

@@ -1,6 +1,7 @@
 #![doc(html_root_url = "https://github.com/STEllAR-GROUP/hpx-rs")]
 #![allow(bad_style, non_camel_case_types, unused_extern_crates)]
 #![allow(dead_code, unused_imports)]
+#![feature(vec_into_raw_parts)]
 
 #[cxx::bridge]
 pub mod ffi {
@@ -39,9 +40,45 @@ pub mod ffi {
 // Wrapper for the above Bindings.
 // reffer to tests to understand how to use them. [NOTE: Not all bindings have wrapper.]
 // ================================================================================================
-use std::ffi::CString;
+use std::env::Args;
+use std::ffi::{CString, CStr};
 use std::os::raw::c_char;
 
+static mut FUNC_HOLDER: Option<fn (Vec<String>) -> i32> = None;
+
+// Convert arguments from *mut *mut c_char to Vec<String>
+// and call the saved Rust version of the function.
+fn c_init(argc: i32, argv: *mut *mut c_char) -> i32 {
+    let mut vec_args: Vec<String> = Vec::new();
+
+    for i in 0..argc {
+        // SAFETY: We get the argv from a conversion from Vec<String>.
+        // The conversion, which is safe, perserves the arguments.
+        // Therefore, no null pointers.
+
+        let c_str: &CStr = unsafe { CStr::from_ptr(*argv.offset(i as isize)) };
+        let string = c_str.to_string_lossy().into_owned();
+        vec_args.push(string.to_string());
+    }
+
+    unsafe { FUNC_HOLDER.unwrap()(vec_args) }
+}
+
+pub fn init(func: fn(Vec<String>) -> i32, func_args: Vec<String>) -> i32
+{
+    unsafe { FUNC_HOLDER = Some(func) };
+    let str_args: Vec<&str> = func_args
+        .iter()
+        .map(|s| s.as_str())
+        .collect::<Vec<&str>>();
+    let (argc, rust_argv) = create_c_args(&str_args);
+    let argv = rust_argv.into_raw_parts().0;
+
+    unsafe {
+        return self::ffi::init(c_init, argc, argv);
+    }
+}
+
 pub fn create_c_args(args: &[&str]) -> (i32, Vec<*mut c_char>) {
     let c_args: Vec<CString> = args.iter().map(|s| CString::new(*s).unwrap()).collect();
     let ptrs: Vec<*mut c_char> = c_args.iter().map(|s| s.as_ptr() as *mut c_char).collect();