Issue #7: Implement Comprehensive Benchmarking Suite

crates/rasn-arrow/Cargo.toml

@@ -21,3 +21,7 @@ criterion = "0.5"
 [[bench]]
 name = "lookup_bench"
 harness = false
+
+[[bench]]
+name = "arrow_lookup"
+harness = false

crates/rasn-arrow/benches/arrow_lookup.rs

@@ -0,0 +1,80 @@
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use rasn_arrow::IpRangeTableV4;
+use std::path::Path;
+
+fn load_table() -> IpRangeTableV4 {
+    let path = Path::new("data/arrow/ip2asn-v4.parquet");
+    IpRangeTableV4::from_parquet(path).expect("Failed to load test data")
+}
+
+fn bench_single_lookup(c: &mut Criterion) {
+    let table = load_table();
+
+    c.bench_function("arrow_single_lookup", |b| {
+        b.iter(|| {
+            // 8.8.8.8 = 0x08080808 (Google DNS)
+            table.find_ip(black_box(0x08080808))
+        })
+    });
+}
+
+fn bench_scalar_vs_simd(c: &mut Criterion) {
+    let table = load_table();
+
+    let mut group = c.benchmark_group("lookup_comparison");
+
+    group.bench_function("scalar_lookup", |b| {
+        b.iter(|| table.find_ip_scalar(black_box(0x08080808)))
+    });
+
+    #[cfg(target_arch = "x86_64")]
+    {
+        if is_x86_feature_detected!("avx2") {
+            group.bench_function("simd_lookup", |b| {
+                b.iter(|| table.find_ip(black_box(0x08080808)))
+            });
+        }
+    }
+
+    group.finish();
+}
+
+fn bench_batch_lookups(c: &mut Criterion) {
+    let table = load_table();
+
+    // Test different batch sizes
+    let sizes = [10, 100, 1000];
+
+    let test_ips: Vec<u32> = vec![
+        0x08080808, // 8.8.8.8 (Google)
+        0x01010101, // 1.1.1.1 (Cloudflare)
+        0x08080404, // 8.8.4.4 (Google)
+        0x09090909, // 9.9.9.9 (Quad9)
+        0xC0000201, // 192.0.2.1 (TEST-NET-1)
+    ];
+
+    let mut group = c.benchmark_group("batch_lookups");
+
+    for size in sizes.iter() {
+        group.throughput(Throughput::Elements(*size as u64));
+
+        group.bench_with_input(BenchmarkId::from_parameter(size), size, |b, &size| {
+            b.iter(|| {
+                for i in 0..size {
+                    let ip = test_ips[i % test_ips.len()];
+                    black_box(table.find_ip(ip));
+                }
+            });
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_single_lookup,
+    bench_scalar_vs_simd,
+    bench_batch_lookups
+);
+criterion_main!(benches);

crates/rasn-client/Cargo.toml

@@ -18,3 +18,8 @@ thiserror.workspace = true
 
 [dev-dependencies]
 tokio-test = "0.4"
+criterion = "0.5"
+
+[[bench]]
+name = "client_performance"
+harness = false

crates/rasn-client/benches/client_performance.rs

@@ -0,0 +1,23 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use rasn_client::ApiClient;
+
+fn bench_client_creation(c: &mut Criterion) {
+    c.bench_function("api_client_creation", |b| {
+        b.iter(|| black_box(ApiClient::new("test-api-key".to_string())))
+    });
+}
+
+fn bench_client_with_config(c: &mut Criterion) {
+    c.bench_function("api_client_with_config", |b| {
+        b.iter(|| {
+            black_box(ApiClient::with_config(
+                "key".to_string(),
+                "https://api.test.com".to_string(),
+                std::time::Duration::from_secs(5),
+            ))
+        })
+    });
+}
+
+criterion_group!(benches, bench_client_creation, bench_client_with_config);
+criterion_main!(benches);

crates/rasn-resolver/Cargo.toml

@@ -17,3 +17,8 @@ lru = "0.12"
 
 [dev-dependencies]
 tokio-test = "0.4"
+criterion = "0.5"
+
+[[bench]]
+name = "dns_resolution"
+harness = false

crates/rasn-resolver/benches/dns_resolution.rs

@@ -0,0 +1,20 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use rasn_resolver::DnsResolver;
+
+fn bench_resolver_creation(c: &mut Criterion) {
+    c.bench_function("dns_resolver_creation", |b| {
+        b.iter(|| black_box(DnsResolver::new().unwrap()))
+    });
+}
+
+fn bench_cache_operations(c: &mut Criterion) {
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let resolver = DnsResolver::new().unwrap();
+
+    c.bench_function("dns_cache_stats", |b| {
+        b.iter(|| rt.block_on(async { black_box(resolver.cache_stats().await) }))
+    });
+}
+
+criterion_group!(benches, bench_resolver_creation, bench_cache_operations);
+criterion_main!(benches);