743 lines
27 KiB
Rust
743 lines
27 KiB
Rust
//! Comprehensive integration tests for edge-aware training system
|
|
//!
|
|
//! Tests cross-platform compatibility, federated coordination,
|
|
//! and performance characteristics across target platforms.
|
|
|
|
use rustytorch::revolutionary::*;
|
|
use std::collections::HashMap;
|
|
use std::time::{Duration, SystemTime};
|
|
use tokio::time::sleep;
|
|
|
|
/// Test ARM NEON optimization path
|
|
#[tokio::test]
|
|
async fn test_arm_neon_optimization() {
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
|
|
let arm_opts = ArmOptimizations {
|
|
enable_neon: true,
|
|
memory_prefetch: true,
|
|
cache_optimization: true,
|
|
big_little_scheduling: true,
|
|
target_arch: ArmArchitecture::CortexA,
|
|
};
|
|
|
|
optimizer.configure_arm(arm_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::ARM).unwrap();
|
|
|
|
// Verify NEON optimizations are applied
|
|
assert!(metrics.performance_improvement > 2.0); // NEON should provide >2x speedup
|
|
assert!(metrics.target_specific.contains_key("neon_enabled"));
|
|
assert_eq!(metrics.target_specific["neon_enabled"], 1.0);
|
|
assert_eq!(metrics.target_specific["vector_width"], 128.0);
|
|
|
|
// Verify cache optimizations
|
|
assert!(metrics.target_specific.contains_key("cache_optimized"));
|
|
assert!(metrics.memory_reduction_ratio > 0.0);
|
|
|
|
println!("ARM NEON optimization test passed: {:.2}x performance improvement",
|
|
metrics.performance_improvement);
|
|
}
|
|
|
|
/// Test RISC-V vector extension optimization
|
|
#[tokio::test]
|
|
async fn test_riscv_vector_optimization() {
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
|
|
let riscv_opts = RiscVOptimizations {
|
|
enable_rvv: true,
|
|
vector_length: RiscVVectorLength::VLEN512,
|
|
custom_instructions: vec!["custom_matmul".to_string(), "custom_conv".to_string()],
|
|
memory_model: RiscVMemoryModel::TSO,
|
|
target_variant: RiscVVariant::Vector,
|
|
};
|
|
|
|
optimizer.configure_riscv(riscv_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::RISCV).unwrap();
|
|
|
|
// Verify RVV optimizations provide significant speedup
|
|
assert!(metrics.performance_improvement > 5.0); // RVV + custom instructions
|
|
assert!(metrics.target_specific.contains_key("rvv_enabled"));
|
|
assert_eq!(metrics.target_specific["vector_length"], 512.0);
|
|
assert_eq!(metrics.target_specific["custom_instructions"], 2.0);
|
|
|
|
// Verify power efficiency improvements
|
|
assert!(metrics.power_efficiency_gain > 1.0);
|
|
|
|
println!("RISC-V RVV optimization test passed: {:.2}x performance improvement",
|
|
metrics.performance_improvement);
|
|
}
|
|
|
|
/// Test WebAssembly SIMD optimization
|
|
#[tokio::test]
|
|
async fn test_wasm_simd_optimization() {
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
|
|
let wasm_opts = WasmOptimizations {
|
|
enable_simd: true,
|
|
enable_threads: true,
|
|
memory_growth: WasmMemoryGrowth::Dynamic { max_pages: 4096 },
|
|
target_runtime: WasmRuntime::Browser,
|
|
bulk_memory: true,
|
|
};
|
|
|
|
optimizer.configure_wasm(wasm_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::WASM).unwrap();
|
|
|
|
// Verify WASM SIMD and threading optimizations
|
|
assert!(metrics.performance_improvement > 1.5); // SIMD + threads
|
|
assert!(metrics.target_specific.contains_key("wasm_simd_enabled"));
|
|
assert!(metrics.target_specific.contains_key("wasm_threads_enabled"));
|
|
assert_eq!(metrics.target_specific["max_pages"], 4096.0);
|
|
|
|
println!("WASM SIMD optimization test passed: {:.2}x performance improvement",
|
|
metrics.performance_improvement);
|
|
}
|
|
|
|
/// Test Mobile GPU optimization for different vendors
|
|
#[tokio::test]
|
|
async fn test_mobile_gpu_optimization() {
|
|
let gpu_vendors = vec![
|
|
MobileGpuVendor::Mali,
|
|
MobileGpuVendor::Adreno,
|
|
MobileGpuVendor::PowerVR,
|
|
MobileGpuVendor::Apple,
|
|
];
|
|
|
|
for vendor in gpu_vendors {
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
|
|
let mobile_gpu_opts = MobileGpuOptimizations {
|
|
gpu_vendor: vendor,
|
|
compute_shaders: true,
|
|
tile_based_rendering: true,
|
|
bandwidth_optimization: true,
|
|
power_efficiency: true,
|
|
};
|
|
|
|
optimizer.configure_mobile_gpu(mobile_gpu_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::MobileGPU).unwrap();
|
|
|
|
// Verify GPU acceleration provides significant speedup
|
|
assert!(metrics.performance_improvement > 3.0); // GPU should provide >3x speedup
|
|
assert!(metrics.memory_reduction_ratio > 0.2); // TBR memory savings
|
|
assert!(metrics.power_efficiency_gain > 1.0);
|
|
|
|
// Verify vendor-specific optimizations
|
|
match vendor {
|
|
MobileGpuVendor::Mali => assert!(metrics.target_specific.contains_key("mali_optimized")),
|
|
MobileGpuVendor::Adreno => assert!(metrics.target_specific.contains_key("adreno_optimized")),
|
|
MobileGpuVendor::PowerVR => assert!(metrics.target_specific.contains_key("powervr_optimized")),
|
|
MobileGpuVendor::Apple => assert!(metrics.target_specific.contains_key("apple_gpu_optimized")),
|
|
_ => {}
|
|
}
|
|
|
|
println!("Mobile GPU {:?} optimization test passed: {:.2}x performance improvement",
|
|
vendor, metrics.performance_improvement);
|
|
}
|
|
}
|
|
|
|
/// Test IoT ultra-low power optimization
|
|
#[tokio::test]
|
|
async fn test_iot_ultra_low_power_optimization() {
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
|
|
let iot_opts = IoTOptimizations {
|
|
ultra_low_power: true,
|
|
minimal_memory: true,
|
|
wake_on_inference: true,
|
|
mesh_networking: true,
|
|
target_platform: IoTPlatform::ESP32,
|
|
};
|
|
|
|
optimizer.configure_iot(iot_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::IoT).unwrap();
|
|
|
|
// Verify ultra-low power optimizations
|
|
assert!(metrics.power_efficiency_gain > 10.0); // 10x power efficiency target
|
|
assert!(metrics.memory_reduction_ratio > 0.8); // 80% memory reduction
|
|
assert!(metrics.target_specific.contains_key("ultra_low_power"));
|
|
assert!(metrics.target_specific.contains_key("esp32_optimized"));
|
|
assert_eq!(metrics.target_specific["memory_footprint_kb"], 64.0);
|
|
|
|
println!("IoT ultra-low power optimization test passed: {:.2}x power efficiency",
|
|
metrics.power_efficiency_gain);
|
|
}
|
|
|
|
/// Test federated coordination for massive scale
|
|
#[tokio::test]
|
|
async fn test_federated_coordination_massive_scale() {
|
|
let (coordinator, sender) = FederatedCoordinator::new(
|
|
"test-coordinator".to_string(),
|
|
SelectionStrategy::Intelligent,
|
|
GradientCompression {
|
|
algorithm: CompressionAlgorithm::TopK,
|
|
compression_ratio: 0.01, // 99% compression for 100K devices
|
|
error_correction: true,
|
|
adaptive_compression: true,
|
|
},
|
|
AggregationStrategy {
|
|
algorithm: AggregationAlgorithm::FedAvg,
|
|
weighting: WeightingScheme::Adaptive,
|
|
byzantine_tolerance: ByzantineTolerance {
|
|
enabled: true,
|
|
max_byzantine_fraction: 0.1,
|
|
detection_algorithm: ByzantineDetection::Krum,
|
|
},
|
|
differential_privacy: Some(DifferentialPrivacy {
|
|
epsilon: 1.0,
|
|
delta: 1e-5,
|
|
noise_mechanism: NoiseMechanism::Gaussian,
|
|
clipping_threshold: 1.0,
|
|
}),
|
|
},
|
|
);
|
|
|
|
// Register 10,000 devices (scaled down from 100K for test performance)
|
|
let device_count = 10_000;
|
|
for i in 0..device_count {
|
|
let device_type = match i % 8 {
|
|
0 => EdgeDeviceType::HighEndMobile,
|
|
1 => EdgeDeviceType::StandardMobile,
|
|
2 => EdgeDeviceType::LowEndMobile,
|
|
3 => EdgeDeviceType::IoTSensor,
|
|
4 => EdgeDeviceType::EdgeServer,
|
|
5 => EdgeDeviceType::Embedded,
|
|
6 => EdgeDeviceType::Automotive,
|
|
7 => EdgeDeviceType::Industrial,
|
|
_ => EdgeDeviceType::StandardMobile,
|
|
};
|
|
|
|
let device = create_test_federated_device(&format!("device-{:06}", i), device_type);
|
|
coordinator.register_device(device).await.unwrap();
|
|
}
|
|
|
|
let metrics = coordinator.get_metrics();
|
|
assert_eq!(metrics.total_devices, device_count);
|
|
|
|
// Test device selection at massive scale
|
|
let selection_criteria = SelectionCriteria {
|
|
min_battery_level: 0.3,
|
|
min_bandwidth_mbps: 5.0,
|
|
max_latency_ms: 200,
|
|
required_availability_minutes: 30,
|
|
min_data_quality: 0.7,
|
|
};
|
|
|
|
let target_devices = 1000; // Select 1000 devices from 10K
|
|
let selection_result = coordinator.select_devices(target_devices, selection_criteria).await.unwrap();
|
|
|
|
// Verify selection performance and results
|
|
assert_eq!(selection_result.selected_devices.len(), target_devices as usize);
|
|
assert!(selection_result.selection_time < Duration::from_secs(5)); // Should complete within 5 seconds
|
|
|
|
// Test training round with selected devices
|
|
let training_config = TrainingConfig {
|
|
local_epochs: 3,
|
|
local_batch_size: 16, // Smaller batch for edge devices
|
|
learning_rate: 0.001,
|
|
gradient_clipping: Some(1.0),
|
|
early_stopping_patience: Some(5),
|
|
};
|
|
|
|
let round_id = coordinator.start_training_round(
|
|
selection_result.selected_devices.clone(),
|
|
training_config,
|
|
Duration::from_secs(600), // 10 minute deadline
|
|
).await.unwrap();
|
|
|
|
// Simulate gradient aggregation with compressed data
|
|
let mut device_gradients = HashMap::new();
|
|
for device_id in &selection_result.selected_devices {
|
|
// Simulate compressed gradients (very small due to high compression)
|
|
device_gradients.insert(device_id.clone(), vec![0u8; 100]); // 100 bytes per device
|
|
}
|
|
|
|
let aggregated_gradients = coordinator.aggregate_gradients(round_id, device_gradients).await.unwrap();
|
|
|
|
// Verify aggregation completed successfully
|
|
assert!(!aggregated_gradients.is_empty());
|
|
|
|
println!("Federated coordination massive scale test passed:");
|
|
println!("- Registered {} devices", device_count);
|
|
println!("- Selected {} devices in {:?}", selection_result.selected_devices.len(), selection_result.selection_time);
|
|
println!("- Completed training round and aggregation");
|
|
}
|
|
|
|
/// Test cross-platform deployment validation
|
|
#[tokio::test]
|
|
async fn test_cross_platform_deployment_validation() {
|
|
// Test all target platforms with comprehensive validation
|
|
let target_platforms = vec![
|
|
(EdgeTarget::ARM, ArmOptimizations::default()),
|
|
(EdgeTarget::RISCV, RiscVOptimizations::default()),
|
|
(EdgeTarget::WASM, WasmOptimizations::default()),
|
|
(EdgeTarget::MobileGPU, MobileGpuOptimizations::default()),
|
|
(EdgeTarget::IoT, IoTOptimizations::default()),
|
|
];
|
|
|
|
let mut all_metrics = HashMap::new();
|
|
|
|
for (target, _) in &target_platforms {
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
|
|
// Configure optimizations based on target
|
|
match target {
|
|
EdgeTarget::ARM => {
|
|
optimizer.configure_arm(ArmOptimizations::default());
|
|
}
|
|
EdgeTarget::RISCV => {
|
|
optimizer.configure_riscv(RiscVOptimizations::default());
|
|
}
|
|
EdgeTarget::WASM => {
|
|
optimizer.configure_wasm(WasmOptimizations::default());
|
|
}
|
|
EdgeTarget::MobileGPU => {
|
|
optimizer.configure_mobile_gpu(MobileGpuOptimizations::default());
|
|
}
|
|
EdgeTarget::IoT => {
|
|
optimizer.configure_iot(IoTOptimizations::default());
|
|
}
|
|
EdgeTarget::Embedded => {
|
|
// Use default embedded optimizations
|
|
}
|
|
}
|
|
|
|
let metrics = optimizer.optimize_for_target(*target).unwrap();
|
|
all_metrics.insert(*target, metrics);
|
|
|
|
// Verify all platforms show performance improvements
|
|
let target_metrics = all_metrics.get(target).unwrap();
|
|
assert!(target_metrics.performance_improvement > 1.0);
|
|
assert!(target_metrics.optimization_time < Duration::from_secs(1));
|
|
}
|
|
|
|
// Verify platform-specific performance characteristics
|
|
let arm_metrics = all_metrics.get(&EdgeTarget::ARM).unwrap();
|
|
let riscv_metrics = all_metrics.get(&EdgeTarget::RISCV).unwrap();
|
|
let wasm_metrics = all_metrics.get(&EdgeTarget::WASM).unwrap();
|
|
let mobile_gpu_metrics = all_metrics.get(&EdgeTarget::MobileGPU).unwrap();
|
|
let iot_metrics = all_metrics.get(&EdgeTarget::IoT).unwrap();
|
|
|
|
// ARM should have good performance with NEON
|
|
assert!(arm_metrics.performance_improvement > 2.0);
|
|
|
|
// RISC-V should have the best future potential with RVV
|
|
assert!(riscv_metrics.performance_improvement > arm_metrics.performance_improvement);
|
|
|
|
// Mobile GPU should have highest raw performance
|
|
assert!(mobile_gpu_metrics.performance_improvement > arm_metrics.performance_improvement);
|
|
|
|
// IoT should have highest power efficiency
|
|
assert!(iot_metrics.power_efficiency_gain > mobile_gpu_metrics.power_efficiency_gain);
|
|
|
|
// WASM should have decent performance despite interpreter overhead
|
|
assert!(wasm_metrics.performance_improvement > 1.2);
|
|
|
|
println!("Cross-platform deployment validation test passed:");
|
|
for (target, metrics) in &all_metrics {
|
|
println!("- {:?}: {:.2}x performance, {:.2}x power efficiency",
|
|
target, metrics.performance_improvement, metrics.power_efficiency_gain);
|
|
}
|
|
}
|
|
|
|
/// Test adaptive model configuration based on device capabilities
|
|
#[tokio::test]
|
|
async fn test_adaptive_model_configuration() {
|
|
// Test different device capability scenarios
|
|
let capability_scenarios = vec![
|
|
("high_end", EdgeCapabilities {
|
|
compute_units: 8,
|
|
memory_mb: 16_384,
|
|
simd_support: SIMDClass::NEON,
|
|
power_budget: PowerClass::Unlimited,
|
|
network: NetworkClass::HighSpeed,
|
|
edge_class: EdgeClass::HighEnd,
|
|
optimization_flags: HashMap::new(),
|
|
}),
|
|
("mid_range", EdgeCapabilities {
|
|
compute_units: 4,
|
|
memory_mb: 4096,
|
|
simd_support: SIMDClass::NEON,
|
|
power_budget: PowerClass::HighBattery,
|
|
network: NetworkClass::WiFi,
|
|
edge_class: EdgeClass::Mid,
|
|
optimization_flags: HashMap::new(),
|
|
}),
|
|
("low_end", EdgeCapabilities {
|
|
compute_units: 2,
|
|
memory_mb: 1024,
|
|
simd_support: SIMDClass::None,
|
|
power_budget: PowerClass::StandardBattery,
|
|
network: NetworkClass::Cellular4G,
|
|
edge_class: EdgeClass::Low,
|
|
optimization_flags: HashMap::new(),
|
|
}),
|
|
("iot", EdgeCapabilities {
|
|
compute_units: 1,
|
|
memory_mb: 64,
|
|
simd_support: SIMDClass::None,
|
|
power_budget: PowerClass::UltraLowPower,
|
|
network: NetworkClass::LPWAN,
|
|
edge_class: EdgeClass::IoT,
|
|
optimization_flags: HashMap::new(),
|
|
}),
|
|
];
|
|
|
|
for (scenario_name, capabilities) in capability_scenarios {
|
|
// Test model configuration adaptation
|
|
let config = create_adaptive_transformer_config(&capabilities);
|
|
|
|
match capabilities.edge_class {
|
|
EdgeClass::HighEnd => {
|
|
assert_eq!(config.dimension_scale, 1.0);
|
|
assert_eq!(config.num_layers, 12);
|
|
assert!(matches!(config.precision, QuantizationLevel::FP32 | QuantizationLevel::FP16));
|
|
}
|
|
EdgeClass::Mid => {
|
|
assert_eq!(config.dimension_scale, 0.7);
|
|
assert_eq!(config.num_layers, 8);
|
|
assert_eq!(config.precision, QuantizationLevel::FP16);
|
|
assert!(config.gradient_checkpointing);
|
|
}
|
|
EdgeClass::Low => {
|
|
assert_eq!(config.dimension_scale, 0.3);
|
|
assert_eq!(config.num_layers, 4);
|
|
assert_eq!(config.precision, QuantizationLevel::INT8);
|
|
assert!(config.gradient_checkpointing);
|
|
}
|
|
EdgeClass::IoT => {
|
|
assert_eq!(config.dimension_scale, 0.1);
|
|
assert_eq!(config.num_layers, 2);
|
|
assert_eq!(config.precision, QuantizationLevel::INT4);
|
|
assert!(config.gradient_checkpointing);
|
|
assert!(!config.mixed_precision);
|
|
}
|
|
}
|
|
|
|
// Test federated configuration adaptation
|
|
let fed_config = create_federated_config(&capabilities);
|
|
|
|
match capabilities.network {
|
|
NetworkClass::HighSpeed => {
|
|
assert_eq!(fed_config.max_devices_per_round, 100000); // Target: 100K devices
|
|
assert_eq!(fed_config.compression_ratio, 0.1);
|
|
}
|
|
NetworkClass::WiFi => {
|
|
assert_eq!(fed_config.max_devices_per_round, 50000);
|
|
assert_eq!(fed_config.compression_ratio, 0.05);
|
|
}
|
|
NetworkClass::Cellular4G => {
|
|
assert_eq!(fed_config.max_devices_per_round, 10000);
|
|
assert_eq!(fed_config.compression_ratio, 0.01);
|
|
}
|
|
NetworkClass::LPWAN => {
|
|
assert_eq!(fed_config.max_devices_per_round, 1000);
|
|
assert_eq!(fed_config.compression_ratio, 0.001);
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
println!("Adaptive configuration test passed for {}: scale={:.1}, layers={}, precision={:?}",
|
|
scenario_name, config.dimension_scale, config.num_layers, config.precision);
|
|
}
|
|
}
|
|
|
|
/// Test performance targets across all platforms
|
|
#[tokio::test]
|
|
async fn test_performance_targets() {
|
|
let mut all_results = HashMap::new();
|
|
|
|
// Test ARM performance targets
|
|
{
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
let arm_opts = ArmOptimizations {
|
|
enable_neon: true,
|
|
target_arch: ArmArchitecture::AppleSilicon,
|
|
..Default::default()
|
|
};
|
|
optimizer.configure_arm(arm_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::ARM).unwrap();
|
|
all_results.insert("ARM_Apple_Silicon", metrics);
|
|
}
|
|
|
|
// Test RISC-V performance targets
|
|
{
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
let riscv_opts = RiscVOptimizations {
|
|
enable_rvv: true,
|
|
vector_length: RiscVVectorLength::VLEN512,
|
|
target_variant: RiscVVariant::Vector,
|
|
..Default::default()
|
|
};
|
|
optimizer.configure_riscv(riscv_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::RISCV).unwrap();
|
|
all_results.insert("RISCV_Vector_512", metrics);
|
|
}
|
|
|
|
// Test WASM performance targets
|
|
{
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
let wasm_opts = WasmOptimizations {
|
|
enable_simd: true,
|
|
enable_threads: true,
|
|
target_runtime: WasmRuntime::Wasmtime,
|
|
..Default::default()
|
|
};
|
|
optimizer.configure_wasm(wasm_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::WASM).unwrap();
|
|
all_results.insert("WASM_SIMD_Threads", metrics);
|
|
}
|
|
|
|
// Test Mobile GPU performance targets
|
|
{
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
let gpu_opts = MobileGpuOptimizations {
|
|
gpu_vendor: MobileGpuVendor::Apple,
|
|
compute_shaders: true,
|
|
tile_based_rendering: true,
|
|
bandwidth_optimization: true,
|
|
power_efficiency: true,
|
|
};
|
|
optimizer.configure_mobile_gpu(gpu_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::MobileGPU).unwrap();
|
|
all_results.insert("Apple_GPU", metrics);
|
|
}
|
|
|
|
// Test IoT performance targets
|
|
{
|
|
let mut optimizer = EdgeTargetOptimizer::new();
|
|
let iot_opts = IoTOptimizations {
|
|
ultra_low_power: true,
|
|
minimal_memory: true,
|
|
wake_on_inference: true,
|
|
target_platform: IoTPlatform::ESP32,
|
|
..Default::default()
|
|
};
|
|
optimizer.configure_iot(iot_opts);
|
|
let metrics = optimizer.optimize_for_target(EdgeTarget::IoT).unwrap();
|
|
all_results.insert("ESP32_ULP", metrics);
|
|
}
|
|
|
|
// Validate performance targets are met
|
|
println!("Performance Target Validation Results:");
|
|
println!("=====================================");
|
|
|
|
for (platform, metrics) in &all_results {
|
|
println!("{}: {:.2}x perf, {:.2}x power efficiency, {:.1}% memory reduction",
|
|
platform,
|
|
metrics.performance_improvement,
|
|
metrics.power_efficiency_gain,
|
|
metrics.memory_reduction_ratio * 100.0);
|
|
|
|
// Performance target assertions
|
|
match platform {
|
|
platform if platform.contains("ARM") => {
|
|
assert!(metrics.performance_improvement >= 2.5, "ARM performance target not met");
|
|
}
|
|
platform if platform.contains("RISCV") => {
|
|
assert!(metrics.performance_improvement >= 3.0, "RISC-V performance target not met");
|
|
}
|
|
platform if platform.contains("WASM") => {
|
|
assert!(metrics.performance_improvement >= 1.8, "WASM performance target not met");
|
|
}
|
|
platform if platform.contains("GPU") => {
|
|
assert!(metrics.performance_improvement >= 4.0, "Mobile GPU performance target not met");
|
|
}
|
|
platform if platform.contains("ESP32") => {
|
|
assert!(metrics.power_efficiency_gain >= 10.0, "IoT power efficiency target not met");
|
|
assert!(metrics.memory_reduction_ratio >= 0.8, "IoT memory reduction target not met");
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
println!("\nAll performance targets validated successfully!");
|
|
}
|
|
|
|
// Helper functions for test setup
|
|
|
|
fn create_test_federated_device(device_id: &str, device_type: EdgeDeviceType) -> FederatedDevice {
|
|
use std::collections::HashSet;
|
|
|
|
FederatedDevice {
|
|
device_id: device_id.to_string(),
|
|
device_type,
|
|
status: DeviceStatus::Available,
|
|
network_info: NetworkInfo {
|
|
connection_type: ConnectionType::WiFi,
|
|
bandwidth_mbps: 50.0,
|
|
latency_ms: 20,
|
|
reliability: 0.95,
|
|
data_plan: DataPlan {
|
|
unlimited: true,
|
|
monthly_allowance_gb: None,
|
|
current_usage_gb: 0.0,
|
|
cost_per_gb: None,
|
|
},
|
|
},
|
|
power_status: PowerStatus {
|
|
battery_level: 0.8,
|
|
is_charging: false,
|
|
power_source: PowerSource::Battery,
|
|
estimated_battery_life_minutes: Some(240),
|
|
},
|
|
compute_capabilities: ComputeCapabilities {
|
|
cpu_cores: 4,
|
|
ram_mb: 4096,
|
|
has_gpu: matches!(device_type, EdgeDeviceType::HighEndMobile | EdgeDeviceType::EdgeServer),
|
|
simd_support: true,
|
|
estimated_flops: 1e9,
|
|
memory_bandwidth_gbps: 10.0,
|
|
},
|
|
data_info: DataInfo {
|
|
sample_count: 1000,
|
|
quality_score: 0.9,
|
|
privacy_level: PrivacyLevel::Personal,
|
|
distribution: DataDistribution {
|
|
distribution_type: "normal".to_string(),
|
|
parameters: HashMap::new(),
|
|
},
|
|
},
|
|
availability: AvailabilitySchedule {
|
|
timezone_offset_hours: 0,
|
|
available_hours: (0..24).collect(),
|
|
preferred_duration_minutes: 30,
|
|
blackout_periods: vec![],
|
|
},
|
|
performance_metrics: PerformanceMetrics {
|
|
avg_training_time_seconds: 300.0,
|
|
avg_upload_time_seconds: 10.0,
|
|
accuracy_contribution: 0.85,
|
|
reliability_score: 0.9,
|
|
communication_efficiency: 0.8,
|
|
},
|
|
last_seen: SystemTime::now(),
|
|
}
|
|
}
|
|
|
|
fn create_adaptive_transformer_config(capabilities: &EdgeCapabilities) -> EdgeTransformerConfig {
|
|
match capabilities.edge_class {
|
|
EdgeClass::HighEnd => EdgeTransformerConfig {
|
|
dimension_scale: 1.0,
|
|
num_layers: 12,
|
|
num_heads: 12,
|
|
precision: if capabilities.memory_mb > 16_384 { QuantizationLevel::FP32 } else { QuantizationLevel::FP16 },
|
|
gradient_checkpointing: false,
|
|
mixed_precision: true,
|
|
},
|
|
EdgeClass::Mid => EdgeTransformerConfig {
|
|
dimension_scale: 0.7,
|
|
num_layers: 8,
|
|
num_heads: 8,
|
|
precision: QuantizationLevel::FP16,
|
|
gradient_checkpointing: true,
|
|
mixed_precision: true,
|
|
},
|
|
EdgeClass::Low => EdgeTransformerConfig {
|
|
dimension_scale: 0.3,
|
|
num_layers: 4,
|
|
num_heads: 4,
|
|
precision: QuantizationLevel::INT8,
|
|
gradient_checkpointing: true,
|
|
mixed_precision: false,
|
|
},
|
|
EdgeClass::IoT => EdgeTransformerConfig {
|
|
dimension_scale: 0.1,
|
|
num_layers: 2,
|
|
num_heads: 2,
|
|
precision: QuantizationLevel::INT4,
|
|
gradient_checkpointing: true,
|
|
mixed_precision: false,
|
|
},
|
|
}
|
|
}
|
|
|
|
fn create_federated_config(capabilities: &EdgeCapabilities) -> FederatedConfig {
|
|
let (compression_ratio, max_devices, update_frequency) = match capabilities.network {
|
|
NetworkClass::HighSpeed => (0.1, 100000, Duration::from_secs(10)), // Target: 100K devices
|
|
NetworkClass::WiFi => (0.05, 50000, Duration::from_secs(30)),
|
|
NetworkClass::Cellular4G => (0.01, 10000, Duration::from_secs(120)),
|
|
NetworkClass::LPWAN => (0.001, 1000, Duration::from_secs(600)),
|
|
_ => (0.01, 1000, Duration::from_secs(300)),
|
|
};
|
|
|
|
let device_selection = match capabilities.power_budget {
|
|
PowerClass::Unlimited => DeviceSelectionStrategy::PerformanceBased,
|
|
PowerClass::HighBattery => DeviceSelectionStrategy::Hybrid,
|
|
_ => DeviceSelectionStrategy::BatteryAware,
|
|
};
|
|
|
|
FederatedConfig {
|
|
aggregation_strategy: AggregationStrategy::FedAvg,
|
|
compression_ratio,
|
|
update_frequency,
|
|
device_selection,
|
|
max_devices_per_round: max_devices,
|
|
fault_tolerance: FaultToleranceConfig {
|
|
max_failed_devices: max_devices / 10,
|
|
device_timeout: Duration::from_secs(60),
|
|
byzantine_tolerance: true,
|
|
backup_coordinators: vec![
|
|
"backup-coordinator-1.edge.local".to_string(),
|
|
"backup-coordinator-2.edge.local".to_string(),
|
|
],
|
|
},
|
|
}
|
|
}
|
|
|
|
// Additional type definitions needed for the tests
|
|
#[derive(Debug, Clone)]
|
|
struct EdgeTransformerConfig {
|
|
dimension_scale: f32,
|
|
num_layers: u32,
|
|
num_heads: u32,
|
|
precision: QuantizationLevel,
|
|
gradient_checkpointing: bool,
|
|
mixed_precision: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct EdgeCapabilities {
|
|
compute_units: u32,
|
|
memory_mb: u64,
|
|
simd_support: SIMDClass,
|
|
power_budget: PowerClass,
|
|
network: NetworkClass,
|
|
edge_class: EdgeClass,
|
|
optimization_flags: HashMap<String, bool>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
|
enum EdgeClass {
|
|
HighEnd,
|
|
Mid,
|
|
Low,
|
|
IoT,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
enum SIMDClass {
|
|
NEON,
|
|
AVX,
|
|
RVV,
|
|
WASM_SIMD,
|
|
None,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
enum PowerClass {
|
|
Unlimited,
|
|
HighBattery,
|
|
StandardBattery,
|
|
LowPower,
|
|
UltraLowPower,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
enum NetworkClass {
|
|
HighSpeed,
|
|
WiFi,
|
|
Cellular4G,
|
|
LPWAN,
|
|
}
|