Add pmap/pfilter for data parallelism

Add Rayon
Add pmap and pfilter native functions
Add helper functions (abs, even?, odd?, positive?, negative?)

Author: 0xhenrique

Cargo.lock

@@ -4,12 +4,12 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-# Cranelift JIT compilation
 cranelift = "0.116"
 cranelift-jit = "0.116"
 cranelift-module = "0.116"
 cranelift-native = "0.116"
 cranelift-codegen = "0.116"
+rayon = "1.10"
 
 [dev-dependencies]
 

Cargo.toml

@@ -0,0 +1,70 @@
+(println "Testing parallel map and filter...")
+
+;; Note: pmap and pfilter currently only support native functions
+;; We'll use built-in functions like abs, even?, odd?, etc.
+
+;; Test 1: pmap with abs
+(println "\n=== Test 1: pmap with abs ===")
+(def nums (list -5 3 -2 8 -1 10))
+(println "Input:" nums)
+(def absolutes (pmap abs nums))
+(println "Absolute values:" absolutes)
+
+;; Test 2: pfilter - even numbers
+(println "\n=== Test 2: pfilter - even numbers ===")
+(def nums2 (list 1 2 3 4 5 6 7 8 9 10))
+(println "Input:" nums2)
+(def evens (pfilter even? nums2))
+(println "Evens:" evens)
+
+;; Test 3: pfilter - odd numbers
+(println "\n=== Test 3: pfilter - odd numbers ===")
+(def nums3 (list 1 2 3 4 5 6 7 8 9 10))
+(println "Input:" nums3)
+(def odds (pfilter odd? nums3))
+(println "Odds:" odds)
+
+;; Test 4: pfilter - positive numbers
+(println "\n=== Test 4: pfilter - positive numbers ===")
+(def mixed (list -5 -2 0 1 3 -1 7 10))
+(println "Input:" mixed)
+(def positives (pfilter positive? mixed))
+(println "Positives:" positives)
+
+;; Test 5: pfilter - negative numbers
+(println "\n=== Test 5: pfilter - negative numbers ===")
+(println "Input:" mixed)
+(def negatives (pfilter negative? mixed))
+(println "Negatives:" negatives)
+
+;; Test 6: Combine pmap and pfilter
+(println "\n=== Test 6: Combined - filter evens then abs ===")
+(def nums4 (list -8 -6 -4 -2 0 1 2 3 4 5))
+(println "Input:" nums4)
+(def evens4 (pfilter even? nums4))
+(println "After pfilter (evens):" evens4)
+(def absolutes4 (pmap abs evens4))
+(println "After pmap (abs):" absolutes4)
+
+;; Test 7: Large list performance test
+(println "\n=== Test 7: Performance test (100 elements) ===")
+;; Create a list of 100 numbers (mix of positive and negative)
+(def large-list (list -50 -49 -48 -47 -46 -45 -44 -43 -42 -41 -40 -39 -38 -37 -36 -35 -34 -33 -32 -31 -30 -29 -28 -27 -26 -25 -24 -23 -22 -21 -20 -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50))
+(println "Processing 100 elements with pmap abs...")
+(def large-abs (pmap abs large-list))
+(println "First 3 results:" (car large-abs) (car (cdr large-abs)) (car (cdr (cdr large-abs))))
+(println "Length of result:" (length large-abs))
+
+(println "\n=== Test 8: pfilter on large list ===")
+(println "Filtering 100 elements for evens...")
+(def large-evens (pfilter even? large-list))
+(println "Number of evens:" (length large-evens))
+(println "First 3 evens:" (car large-evens) (car (cdr large-evens)) (car (cdr (cdr large-evens))))
+
+(println "\n=== Test 9: pfilter then pmap on large list ===")
+(def large-positives (pfilter positive? large-list))
+(println "Number of positives:" (length large-positives))
+(def large-positives-abs (pmap abs large-positives))
+(println "After pmap abs, first 3:" (car large-positives-abs) (car (cdr large-positives-abs)) (car (cdr (cdr large-positives-abs))))
+
+(println "\n=== All parallel tests passed! ===")

lisp/test_parallel.lisp

@@ -1516,6 +1516,58 @@ pub fn standard_vm() -> VM {
         Ok(Value::bool(!args[0].is_truthy()))
     }));
 
+    // Math helper functions
+    vm.define_global("abs", native("abs", |args| {
+        if args.len() != 1 { return Err("abs expects 1 argument".to_string()); }
+        if let Some(i) = args[0].as_int() {
+            Ok(Value::int(i.abs()))
+        } else if let Some(f) = args[0].as_float() {
+            Ok(Value::float(f.abs()))
+        } else {
+            Err("abs expects a number".to_string())
+        }
+    }));
+
+    vm.define_global("even?", native("even?", |args| {
+        if args.len() != 1 { return Err("even? expects 1 argument".to_string()); }
+        if let Some(i) = args[0].as_int() {
+            Ok(Value::bool(i % 2 == 0))
+        } else {
+            Err("even? expects an integer".to_string())
+        }
+    }));
+
+    vm.define_global("odd?", native("odd?", |args| {
+        if args.len() != 1 { return Err("odd? expects 1 argument".to_string()); }
+        if let Some(i) = args[0].as_int() {
+            Ok(Value::bool(i % 2 != 0))
+        } else {
+            Err("odd? expects an integer".to_string())
+        }
+    }));
+
+    vm.define_global("positive?", native("positive?", |args| {
+        if args.len() != 1 { return Err("positive? expects 1 argument".to_string()); }
+        if let Some(i) = args[0].as_int() {
+            Ok(Value::bool(i > 0))
+        } else if let Some(f) = args[0].as_float() {
+            Ok(Value::bool(f > 0.0))
+        } else {
+            Err("positive? expects a number".to_string())
+        }
+    }));
+
+    vm.define_global("negative?", native("negative?", |args| {
+        if args.len() != 1 { return Err("negative? expects 1 argument".to_string()); }
+        if let Some(i) = args[0].as_int() {
+            Ok(Value::bool(i < 0))
+        } else if let Some(f) = args[0].as_float() {
+            Ok(Value::bool(f < 0.0))
+        } else {
+            Err("negative? expects a number".to_string())
+        }
+    }));
+
     // List operations
     vm.define_global("list", native("list", |args| Ok(Value::list(args.to_vec()))));
 
@@ -2242,6 +2294,100 @@ pub fn standard_vm() -> VM {
         }
     }));
 
+    vm.define_global("pmap", native("pmap", |args| {
+        use rayon::prelude::*;
+
+        if args.len() != 2 {
+            return Err("pmap expects 2 arguments (function list)".to_string());
+        }
+
+        // Get the function
+        let func = &args[0];
+
+        // Get the list
+        let items = args[1].as_list()
+            .ok_or_else(|| "pmap expects a list as second argument".to_string())?;
+
+        // Check if function is a native function
+        let native_func = func.as_native_function()
+            .ok_or_else(|| "pmap currently only supports native functions".to_string())?;
+
+        // Convert items to SharedValue for thread-safe processing
+        let shared_items: Result<Vec<_>, String> = items.iter()
+            .map(|v| v.make_shared())
+            .collect();
+        let shared_items = shared_items?;
+
+        // Process in parallel using Rayon
+        let results: Result<Vec<_>, String> = shared_items
+            .par_iter()
+            .map(|shared_val| {
+                // Convert back to Rc-based Value for function call
+                let val = Value::from_shared(shared_val);
+
+                // Apply function
+                (native_func.func)(&[val])
+            })
+            .collect();
+
+        let results = results?;
+
+        // Return as list
+        Ok(Value::list(results))
+    }));
+
+    vm.define_global("pfilter", native("pfilter", |args| {
+        use rayon::prelude::*;
+
+        if args.len() != 2 {
+            return Err("pfilter expects 2 arguments (predicate list)".to_string());
+        }
+
+        // Get the predicate function
+        let pred = &args[0];
+
+        // Get the list
+        let items = args[1].as_list()
+            .ok_or_else(|| "pfilter expects a list as second argument".to_string())?;
+
+        // Check if predicate is a native function
+        let native_pred = pred.as_native_function()
+            .ok_or_else(|| "pfilter currently only supports native functions".to_string())?;
+
+        // Convert items to SharedValue for thread-safe processing
+        let shared_items: Result<Vec<_>, String> = items.iter()
+            .map(|v| v.make_shared())
+            .collect();
+        let shared_items = shared_items?;
+
+        // Filter in parallel using Rayon
+        let results: Result<Vec<_>, String> = shared_items
+            .par_iter()
+            .filter_map(|shared_val| {
+                // Convert back to Rc-based Value for function call
+                let val = Value::from_shared(shared_val);
+
+                // Apply predicate
+                match (native_pred.func)(&[val.clone()]) {
+                    Ok(result) => {
+                        // Check if result is truthy (not nil and not false)
+                        if result.is_nil() || (result.as_bool() == Some(false)) {
+                            None
+                        } else {
+                            Some(Ok(val))
+                        }
+                    }
+                    Err(e) => Some(Err(e)),
+                }
+            })
+            .collect();
+
+        let results = results?;
+
+        // Return as list
+        Ok(Value::list(results))
+    }));
+
     vm
 }