OxiGDAL Edge Computing Platform

Edge computing platform for OxiGDAL with offline-first architecture and minimal footprint for resource-constrained devices.

Features

Core Capabilities

• Lightweight Edge Runtime: Optimized runtime for embedded and IoT devices
• Offline-First Architecture: Local-first data processing with optional cloud sync
• Minimal Footprint: Binary size reduction and reduced dependency tree
• Resource Management: CPU, memory, and storage constraints for edge devices

Synchronization

• Edge-to-Cloud Sync: Flexible synchronization protocols (manual, periodic, incremental, batch, real-time)
• CRDT-Based Conflict Resolution: Automatic conflict resolution using Conflict-free Replicated Data Types
• Sync Protocols: Vector clocks for causality tracking
• Batch Operations: Efficient batching for bandwidth-limited environments

Data Management

• Local Caching: LRU, LFU, TTL, and size-based eviction policies
• Edge-Optimized Compression: LZ4, Snappy, and Deflate with adaptive selection
• Persistent Storage: Optional persistent cache for offline operation

Performance

• Binary Size Optimization: Minimal dependencies for embedded deployment
• Resource-Constrained Support: Configurable memory, CPU, and storage limits
• Async Runtime: Tokio-based async execution with minimal features

Quick Start

use oxigdal_edge::{EdgeRuntime, EdgeConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create edge runtime with minimal footprint
    let config = EdgeConfig::minimal();
    let runtime = EdgeRuntime::new(config).await?;

    // Start runtime
    runtime.start().await?;

    // Process data locally
    let result = runtime.execute(async {
        // Your edge processing logic
        Ok(42)
    }).await?;

    // Stop runtime
    runtime.stop().await?;

    Ok(())
}

Configuration Modes

Minimal Mode (Embedded Devices)

let config = EdgeConfig::minimal();
// - 1 MB cache
// - Fast compression
// - Offline mode
// - Manual sync

Offline-First Mode

let config = EdgeConfig::offline_first();
// - 50 MB cache
// - Persistent storage
// - Batch sync
// - Balanced compression

Custom Configuration

let config = EdgeConfig {
    mode: RuntimeMode::Hybrid,
    constraints: ResourceConstraints {
        max_memory_bytes: 10 * 1024 * 1024,
        max_cpu_percent: 50.0,
        max_storage_bytes: 20 * 1024 * 1024,
        max_concurrent_ops: 5,
        operation_timeout_secs: 30,
    },
    cache_config: CacheConfig::minimal(),
    compression_level: CompressionLevel::Fast,
    sync_strategy: SyncStrategy::Incremental,
    data_dir: PathBuf::from(".edge"),
    enable_metrics: true,
    heartbeat_interval_secs: 60,
};

Cache Management

use oxigdal_edge::{Cache, CacheConfig, CachePolicy};

let config = CacheConfig {
    max_size: 10 * 1024 * 1024, // 10 MB
    policy: CachePolicy::Lru,
    ttl_secs: Some(3600), // 1 hour
    persistent: true,
    cache_dir: Some(PathBuf::from(".cache")),
    max_entries: 1000,
};

let cache = Cache::new(config)?;

// Store data
cache.put("key".to_string(), Bytes::from("data"))?;

// Retrieve data
if let Some(data) = cache.get("key")? {
    println!("Retrieved: {:?}", data);
}

Compression

use oxigdal_edge::{EdgeCompressor, CompressionStrategy, CompressionLevel};

// Fast compression for real-time
let compressor = EdgeCompressor::fast();
let compressed = compressor.compress(data)?;

// Adaptive compression
let adaptive = AdaptiveCompressor::new(CompressionLevel::Balanced);
let (compressed, strategy) = adaptive.compress(data)?;
let decompressed = adaptive.decompress(&compressed, strategy)?;

Synchronization

use oxigdal_edge::sync::{SyncManager, SyncStrategy, SyncItem};

let cache = Arc::new(Cache::new(CacheConfig::minimal())?);
let manager = SyncManager::new(SyncStrategy::Incremental, cache)?;

// Add items to sync queue
let item = SyncItem::new(
    "item-1".to_string(),
    "key-1".to_string(),
    vec![1, 2, 3],
    1,
);
manager.add_pending(item);

// Start automatic sync
manager.start().await?;

// Or trigger manual sync
manager.sync_now().await?;

Conflict Resolution

use oxigdal_edge::{ConflictResolver, CrdtMap, VectorClock};

let resolver = ConflictResolver::new("edge-node-1".to_string());

// Create CRDT map for automatic conflict resolution
let mut map = resolver.create_map();
map.insert("key1", "value1");
map.insert("key2", "value2");

// Merge with another node's data
let mut map2 = CrdtMap::new("edge-node-2".to_string());
map2.insert("key2", "value2_updated");
map.merge(&map2);

Resource Management

use oxigdal_edge::{ResourceManager, ResourceConstraints};

let constraints = ResourceConstraints::minimal();
let manager = ResourceManager::new(constraints)?;

// Track operations
let _op_guard = manager.start_operation()?;

// Track memory
let _mem_guard = manager.allocate_memory(1024)?;

// Check health
let health = manager.health_check();
match health {
    HealthStatus::Healthy => println!("System healthy"),
    HealthStatus::Degraded => println!("System degraded"),
    HealthStatus::Critical => println!("System critical"),
}

Performance Benchmarks

Run benchmarks comparing edge vs cloud performance:

cargo bench --package oxigdal-edge

Key metrics:

• Cache operations: 100k+ ops/sec
• LZ4 compression: 500+ MB/s
• Snappy compression: 1+ GB/s
• Memory allocation tracking: < 100ns overhead
• CRDT operations: 1M+ ops/sec

Architecture

┌─────────────────────────────────────────┐
│         Edge Runtime                     │
│  ┌────────────┐  ┌──────────────┐       │
│  │ Executor   │  │ Scheduler    │       │
│  └────────────┘  └──────────────┘       │
└─────────────────────────────────────────┘
         │                    │
         ▼                    ▼
┌──────────────┐      ┌──────────────┐
│   Cache      │      │   Resource   │
│              │      │   Manager    │
└──────────────┘      └──────────────┘
         │                    │
         ▼                    ▼
┌──────────────┐      ┌──────────────┐
│ Compression  │      │     Sync     │
│              │      │   Manager    │
└──────────────┘      └──────────────┘
         │                    │
         ▼                    ▼
┌─────────────────────────────────────────┐
│         Local Storage                    │
│  (Optional Persistent Cache)            │
└─────────────────────────────────────────┘

Use Cases

1. IoT Sensors: Process geospatial sensor data locally on edge devices
2. Mobile Mapping: Offline-first mobile GIS applications
3. Remote Monitoring: Field data collection with intermittent connectivity
4. Embedded Systems: Geospatial processing on resource-constrained devices
5. Distributed Edge Networks: Multi-node edge computing with CRDT sync

COOLJAPAN Policies

• ✅ Pure Rust implementation (no C/Fortran dependencies)
• ✅ No unwrap() usage (comprehensive error handling)
• ✅ All files < 2000 lines
• ✅ Workspace dependencies
• ✅ Comprehensive tests and benchmarks

License

Apache-2.0

Authors

COOLJAPAN OU (Team Kitasan)