preload_example/

preload_example.rs

use dolphin::{load, invoke};
use std::collections::HashMap;

// Define models matching C structs
#[repr(C)]
struct User {
    id: i32,
    name: [u8; 64],
    age: i32,
    balance: f64,
}

impl User {
    fn new(id: i32, name: &str, age: i32, balance: f64) -> Self {
        let mut name_buf = [0u8; 64];
        let name_bytes = name.as_bytes();
        let len = name_bytes.len().min(63);
        name_buf[..len].copy_from_slice(&name_bytes[..len]);
        
        User {
            id,
            name: name_buf,
            age,
            balance,
        }
    }
}

/// Function registry for pre-loaded function addresses
struct FunctionRegistry {
    functions: HashMap<String, usize>,
}

impl FunctionRegistry {
    fn new() -> Self {
        FunctionRegistry {
            functions: HashMap::new(),
        }
    }
    
    /// Pre-load a function and store its address
    fn register(&mut self, library_path: &str, function_name: &str) -> Result<(), String> {
        match load(library_path, function_name) {
            Some(address) => {
                println!("✓ Loaded '{}' at address: 0x{:x}", function_name, address);
                self.functions.insert(function_name.to_string(), address);
                Ok(())
            }
            None => {
                Err(format!("Failed to load function '{}'", function_name))
            }
        }
    }
    
    /// Get a pre-loaded function address
    fn get(&self, function_name: &str) -> Option<usize> {
        self.functions.get(function_name).copied()
    }
    
    /// Invoke a pre-loaded function by name
    fn invoke<T>(&self, function_name: &str, arguments: &[T]) -> Result<(), String> {
        let address = self.get(function_name)
            .ok_or_else(|| format!("Function '{}' not found in registry", function_name))?;
        
        let arg_bytes = unsafe {
            std::slice::from_raw_parts(
                arguments.as_ptr() as *const u8,
                arguments.len() * std::mem::size_of::<T>()
            )
        };
        
        invoke(address, arg_bytes)
    }
    
    /// List all registered functions
    fn list_functions(&self) {
        println!("\nRegistered Functions:");
        println!("{:-<60}", "");
        for (name, address) in &self.functions {
            println!("  {} -> 0x{:x}", name, address);
        }
        println!("{:-<60}", "");
    }
}

fn main() {
    println!("=== Dolphin Pre-Load Example ===\n");
    println!("This example demonstrates loading all function addresses");
    println!("at startup for better performance on repeated calls.\n");
    
    let library_path = "./examples/libexample.dylib";
    let mut registry = FunctionRegistry::new();
    
    // Phase 1: Pre-load all functions at startup
    println!("--- Phase 1: Pre-loading Functions ---");
    
    let functions = vec![
        "calculate_sum",
        "print_message",
        "reverse_string",
        "count_characters",
        "print_user",
        "update_user_balance",
        "print_product",
        "process_order",
        "print_user_list",
    ];
    
    let mut loaded_count = 0;
    for func_name in &functions {
        match registry.register(library_path, func_name) {
            Ok(_) => loaded_count += 1,
            Err(e) => eprintln!("✗ {}", e),
        }
    }
    
    println!("\n✓ Successfully loaded {}/{} functions\n", loaded_count, functions.len());
    registry.list_functions();
    
    // Phase 2: Use pre-loaded functions (faster - no library loading overhead)
    println!("\n--- Phase 2: Using Pre-loaded Functions ---\n");
    
    // Example 1: Calculate sum
    println!("Example 1: Calculate Sum");
    let numbers = vec![5, 10, 15, 20, 25];
    match registry.invoke("calculate_sum", &numbers) {
        Ok(_) => println!("✓ Invoked calculate_sum\n"),
        Err(e) => eprintln!("✗ Error: {}\n", e),
    }
    
    // Example 2: Print message
    println!("Example 2: Print Message");
    let message = "Pre-loaded function call!";
    match registry.invoke("print_message", message.as_bytes()) {
        Ok(_) => println!("✓ Invoked print_message\n"),
        Err(e) => eprintln!("✗ Error: {}\n", e),
    }
    
    // Example 3: Reverse string
    println!("Example 3: Reverse String");
    let text = "Fast Pre-loaded Call";
    match registry.invoke("reverse_string", text.as_bytes()) {
        Ok(_) => println!("✓ Invoked reverse_string\n"),
        Err(e) => eprintln!("✗ Error: {}\n", e),
    }
    
    // Example 4: User model
    println!("Example 4: User Model");
    let user = User::new(42, "John Doe", 30, 5000.00);
    let user_bytes = unsafe {
        std::slice::from_raw_parts(
            &user as *const User as *const u8,
            std::mem::size_of::<User>()
        )
    };
    match registry.invoke("print_user", user_bytes) {
        Ok(_) => println!("✓ Invoked print_user\n"),
        Err(e) => eprintln!("✗ Error: {}\n", e),
    }
    
    // Example 5: Multiple calls to same function (demonstrating performance benefit)
    println!("Example 5: Multiple Calls (demonstrating pre-load benefit)");
    let messages = vec![
        "First call",
        "Second call",
        "Third call",
        "Fourth call",
    ];
    
    for (i, msg) in messages.iter().enumerate() {
        match registry.invoke("print_message", msg.as_bytes()) {
            Ok(_) => println!("  ✓ Call {} completed", i + 1),
            Err(e) => eprintln!("  ✗ Call {} failed: {}", i + 1, e),
        }
    }
    
    // Example 6: Direct address usage (lowest level)
    println!("\n--- Example 6: Direct Address Usage ---");
    if let Some(address) = registry.get("print_message") {
        println!("Using address 0x{:x} directly:", address);
        let direct_msg = "Direct address call!";
        match invoke(address, direct_msg.as_bytes()) {
            Ok(_) => println!("✓ Direct invoke successful\n"),
            Err(e) => eprintln!("✗ Direct invoke failed: {}\n", e),
        }
    }
    
    // Performance comparison note
    println!("--- Performance Notes ---");
    println!("Pre-loading benefits:");
    println!("  • All functions loaded once at startup");
    println!("  • No library loading overhead on each call");
    println!("  • Ideal for applications making many FFI calls");
    println!("  • Can validate all functions exist at startup");
    println!("  • Functions remain loaded for entire program lifetime");
    
    println!("\n=== Example completed ===");
}