add data packages and remove empty submodule

packages/data/tst/examples/performance.rs

@@ -0,0 +1,167 @@
+use std::io::{self, Write};
+use std::time::{Duration, Instant};
+use tst::TST;
+
+// Function to generate a test value of specified size
+fn generate_test_value(index: usize, size: usize) -> Vec<u8> {
+    let base_value = format!("val{:08}", index);
+    let mut value = Vec::with_capacity(size);
+
+    // Fill with repeating pattern to reach desired size
+    while value.len() < size {
+        value.extend_from_slice(base_value.as_bytes());
+    }
+
+    // Truncate to exact size
+    value.truncate(size);
+
+    value
+}
+
+// Number of records to insert
+const TOTAL_RECORDS: usize = 100_000;
+// How often to report progress (every X records)
+const PROGRESS_INTERVAL: usize = 1_000;
+// How many records to use for performance sampling
+const PERFORMANCE_SAMPLE_SIZE: usize = 100;
+
+fn main() -> Result<(), tst::Error> {
+    // Create a temporary directory for the database
+    let db_path = std::env::temp_dir().join("tst_performance_test");
+
+    // Completely remove and recreate the directory to ensure a clean start
+    if db_path.exists() {
+        std::fs::remove_dir_all(&db_path)?;
+    }
+    std::fs::create_dir_all(&db_path)?;
+
+    println!("Creating ternary search tree at: {}", db_path.display());
+    println!("Will insert {} records and show progress...", TOTAL_RECORDS);
+
+    // Create a new TST
+    let mut tree = TST::new(db_path.to_str().unwrap(), true)?;
+
+    // Track overall time
+    let start_time = Instant::now();
+
+    // Track performance metrics
+    let mut insertion_times = Vec::with_capacity(TOTAL_RECORDS / PROGRESS_INTERVAL);
+    let mut last_batch_time = Instant::now();
+    let mut last_batch_records = 0;
+
+    // Insert records and track progress
+    for i in 0..TOTAL_RECORDS {
+        let key = format!("key:{:08}", i);
+        // Generate a 100-byte value
+        let value = generate_test_value(i, 100);
+
+        // Time the insertion of every Nth record for performance sampling
+        if i % PERFORMANCE_SAMPLE_SIZE == 0 {
+            let insert_start = Instant::now();
+            tree.set(&key, value)?;
+            let insert_duration = insert_start.elapsed();
+
+            // Only print detailed timing for specific samples to avoid flooding output
+            if i % (PERFORMANCE_SAMPLE_SIZE * 10) == 0 {
+                println!("Record {}: Insertion took {:?}", i, insert_duration);
+            }
+        } else {
+            tree.set(&key, value)?;
+        }
+
+        // Show progress at intervals
+        if (i + 1) % PROGRESS_INTERVAL == 0 || i == TOTAL_RECORDS - 1 {
+            let records_in_batch = i + 1 - last_batch_records;
+            let batch_duration = last_batch_time.elapsed();
+            let records_per_second = records_in_batch as f64 / batch_duration.as_secs_f64();
+
+            insertion_times.push((i + 1, batch_duration));
+
+            print!(
+                "\rProgress: {}/{} records ({:.2}%) - {:.2} records/sec",
+                i + 1,
+                TOTAL_RECORDS,
+                (i + 1) as f64 / TOTAL_RECORDS as f64 * 100.0,
+                records_per_second
+            );
+            io::stdout().flush().unwrap();
+
+            last_batch_time = Instant::now();
+            last_batch_records = i + 1;
+        }
+    }
+
+    let total_duration = start_time.elapsed();
+    println!("\n\nPerformance Summary:");
+    println!(
+        "Total time to insert {} records: {:?}",
+        TOTAL_RECORDS, total_duration
+    );
+    println!(
+        "Average insertion rate: {:.2} records/second",
+        TOTAL_RECORDS as f64 / total_duration.as_secs_f64()
+    );
+
+    // Show performance trend
+    println!("\nPerformance Trend (records inserted vs. time per batch):");
+    for (i, (record_count, duration)) in insertion_times.iter().enumerate() {
+        if i % 10 == 0 || i == insertion_times.len() - 1 {
+            // Only show every 10th point to avoid too much output
+            println!(
+                "  After {} records: {:?} for {} records ({:.2} records/sec)",
+                record_count,
+                duration,
+                PROGRESS_INTERVAL,
+                PROGRESS_INTERVAL as f64 / duration.as_secs_f64()
+            );
+        }
+    }
+
+    // Test access performance with distributed samples
+    println!("\nTesting access performance with distributed samples...");
+    let mut total_get_time = Duration::new(0, 0);
+    let num_samples = 1000;
+
+    // Use a simple distribution pattern instead of random
+    for i in 0..num_samples {
+        // Distribute samples across the entire range
+        let sample_id = (i * (TOTAL_RECORDS / num_samples)) % TOTAL_RECORDS;
+        let key = format!("key:{:08}", sample_id);
+
+        let get_start = Instant::now();
+        let _ = tree.get(&key)?;
+        total_get_time += get_start.elapsed();
+    }
+
+    println!(
+        "Average time to retrieve a record: {:?}",
+        total_get_time / num_samples as u32
+    );
+
+    // Test prefix search performance
+    println!("\nTesting prefix search performance...");
+    let prefixes = ["key:0", "key:1", "key:5", "key:9"];
+
+    for prefix in &prefixes {
+        let list_start = Instant::now();
+        let keys = tree.list(prefix)?;
+        let list_duration = list_start.elapsed();
+
+        println!(
+            "Found {} keys with prefix '{}' in {:?}",
+            keys.len(),
+            prefix,
+            list_duration
+        );
+    }
+
+    // Clean up (optional)
+    if std::env::var("KEEP_DB").is_err() {
+        std::fs::remove_dir_all(&db_path)?;
+        println!("\nCleaned up database directory");
+    } else {
+        println!("\nDatabase kept at: {}", db_path.display());
+    }
+
+    Ok(())
+}