Carbon-Aware Computing Systems

import asyncio
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from dataclasses import dataclass

@dataclass
class CarbonIntensityData:
    region: str
    timestamp: datetime
    intensity: float  # gCO2/kWh
    forecast: List[float]  # Next 24 hours

@dataclass
class WorkloadRequest:
    id: str
    compute_requirements: Dict[str, int]
    deadline: datetime
    priority: str
    carbon_budget: Optional[float] = None

class CarbonAwareScheduler:
    def __init__(self):
        self.carbon_service = CarbonIntensityService()
        self.resource_manager = ResourceManager()
        self.workload_queue = []
        
    async def schedule_workload(self, workload: WorkloadRequest) -> Dict:
        """Schedule workload with carbon optimization"""
        
        # Get carbon intensity forecasts for available regions
        carbon_forecasts = await self.get_carbon_forecasts()
        
        # Find optimal execution window
        optimal_schedule = await self.find_optimal_execution_time(
            workload, carbon_forecasts
        )
        
        if optimal_schedule:
            # Reserve resources and schedule execution
            reservation = await self.resource_manager.reserve_resources(
                region=optimal_schedule['region'],
                resources=workload.compute_requirements,
                start_time=optimal_schedule['start_time'],
                duration=optimal_schedule['duration']
            )
            
            return {
                'status': 'scheduled',
                'workload_id': workload.id,
                'execution_plan': optimal_schedule,
                'reservation_id': reservation['id'],
                'estimated_emissions': optimal_schedule['estimated_emissions'],
                'carbon_savings': optimal_schedule['carbon_savings']
            }
        else:
            # Fallback to immediate execution with carbon tracking
            return await self.schedule_immediate_execution(workload)
    
    async def find_optimal_execution_time(
        self, 
        workload: WorkloadRequest, 
        carbon_forecasts: Dict[str, CarbonIntensityData]
    ) -> Optional[Dict]:
        """Find the best time/region combination for minimum emissions"""
        
        best_option = None
        min_emissions = float('inf')
        
        # Evaluate each region and time window
        for region, forecast_data in carbon_forecasts.items():
            for hour_offset in range(0, 24):  # Next 24 hours
                execution_time = datetime.utcnow() + timedelta(hours=hour_offset)
                
                # Check if execution time meets deadline
                if execution_time > workload.deadline:
                    continue
                
                # Estimate carbon emissions for this time/region
                carbon_intensity = forecast_data.forecast[hour_offset]
                estimated_duration = self.estimate_execution_time(workload)
                energy_consumption = self.estimate_energy_consumption(workload)
                
                total_emissions = (
                    energy_consumption * estimated_duration * carbon_intensity / 1000
                )  # kgCO2
                
                # Apply priority weighting
                priority_multiplier = {
                    'low': 1.0,      # Can wait for optimal time
                    'medium': 1.5,   # Some time flexibility
                    'high': 3.0      # Less carbon optimization
                }.get(workload.priority, 1.0)
                
                weighted_emissions = total_emissions * priority_multiplier
                
                if weighted_emissions < min_emissions:
                    min_emissions = weighted_emissions
                    baseline_emissions = self.get_baseline_emissions(workload)
                    
                    best_option = {
                        'region': region,
                        'start_time': execution_time,
                        'duration': estimated_duration,
                        'estimated_emissions': total_emissions,
                        'carbon_savings': max(0, baseline_emissions - total_emissions),
                        'carbon_intensity': carbon_intensity,
                        'delay_hours': hour_offset
                    }
        
        return best_option
    
    async def get_carbon_forecasts(self) -> Dict[str, CarbonIntensityData]:
        """Fetch carbon intensity forecasts for available regions"""
        regions = ['us-east-1', 'us-west-1', 'eu-north-1', 'eu-central-1']
        forecasts = {}
        
        for region in regions:
            forecast = await self.carbon_service.get_forecast(region)
            forecasts[region] = forecast
            
        return forecasts
    
    def estimate_energy_consumption(self, workload: WorkloadRequest) -> float:
        """Estimate energy consumption in kWh"""
        cpu_hours = workload.compute_requirements.get('cpu_cores', 1)
        memory_gb = workload.compute_requirements.get('memory_gb', 4)
        
        # Rough estimates for energy consumption
        cpu_energy = cpu_hours * 0.1  # 100W per core
        memory_energy = memory_gb * 0.004  # 4W per GB
        
        return cpu_energy + memory_energy
    
    def estimate_execution_time(self, workload: WorkloadRequest) -> float:
        """Estimate execution time in hours"""
        # Simplified estimation based on workload characteristics
        base_time = 1.0  # 1 hour baseline
        
        complexity_factor = workload.compute_requirements.get('complexity', 1.0)
        return base_time * complexity_factor

class CarbonIntensityService:
    """Service for fetching real-time carbon intensity data"""
    
    async def get_forecast(self, region: str) -> CarbonIntensityData:
        """Get 24-hour carbon intensity forecast for region"""
        
        # In production, integrate with services like:
        # - WattTime API for US regions  
        # - electricityMap API for global data
        # - Cloud provider carbon APIs
        
        mock_forecast = self.generate_mock_forecast(region)
        
        return CarbonIntensityData(
            region=region,
            timestamp=datetime.utcnow(),
            intensity=mock_forecast[0],
            forecast=mock_forecast
        )
    
    def generate_mock_forecast(self, region: str) -> List[float]:
        """Generate realistic carbon intensity patterns"""
        import random
        
        base_intensity = {
            'us-east-1': 480,   # Coal/gas heavy
            'us-west-1': 220,   # Renewables heavy
            'eu-north-1': 45,   # Hydro/wind heavy
            'eu-central-1': 320 # Mixed grid
        }.get(region, 400)
        
        # Generate 24-hour forecast with daily patterns
        forecast = []
        for hour in range(24):
            # Lower intensity during day (more solar)
            time_factor = 0.7 if 6 <= hour <= 18 else 1.0
            # Add some randomness
            variation = random.uniform(0.8, 1.2)
            
            intensity = base_intensity * time_factor * variation
            forecast.append(intensity)
            
        return forecast

# Usage example
async def main():
    scheduler = CarbonAwareScheduler()
    
    # Create a batch processing workload
    workload = WorkloadRequest(
        id="data-processing-job-123",
        compute_requirements={
            'cpu_cores': 16,
            'memory_gb': 64,
            'complexity': 2.0
        },
        deadline=datetime.utcnow() + timedelta(hours=12),
        priority='medium',
        carbon_budget=0.5  # 0.5 kg CO2 budget
    )
    
    result = await scheduler.schedule_workload(workload)
    print(f"Scheduling result: {result}")

# Run the scheduler
# asyncio.run(main())

import React, { useState, useEffect } from 'react';
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, BarChart, Bar } from 'recharts';

interface CarbonMetrics {
  timestamp: string;
  totalEmissions: number;    // kg CO2
  savedEmissions: number;    // kg CO2 saved through optimization
  carbonIntensity: number;   // gCO2/kWh
  energyConsumption: number; // kWh
  workloadsProcessed: number;
  averageDelay: number;      // minutes
}

interface ServiceEmissions {
  serviceName: string;
  emissions: number;
  percentage: number;
  trend: 'up' | 'down' | 'stable';
}

export const CarbonMetricsDashboard: React.FC = () => {
  const [metrics, setMetrics] = useState<CarbonMetrics[]>([]);
  const [serviceBreakdown, setServiceBreakdown] = useState<ServiceEmissions[]>([]);
  const [timeRange, setTimeRange] = useState<'24h' | '7d' | '30d'>('24h');
  
  useEffect(() => {
    fetchCarbonMetrics();
  }, [timeRange]);
  
  const fetchCarbonMetrics = async () => {
    try {
      const response = await fetch(`/api/carbon-metrics?range=${timeRange}`);
      const data = await response.json();
      setMetrics(data.metrics);
      setServiceBreakdown(data.serviceBreakdown);
    } catch (error) {
      console.error('Failed to fetch carbon metrics:', error);
    }
  };
  
  const totalEmissions = metrics.reduce((sum, m) => sum + m.totalEmissions, 0);
  const totalSavings = metrics.reduce((sum, m) => sum + m.savedEmissions, 0);
  const carbonEfficiency = totalSavings / (totalEmissions + totalSavings) * 100;
  
  return (
    <div className="p-6 space-y-6">
      {/* Summary Cards */}
      <div className="grid grid-cols-1 md:grid-cols-4 gap-6">
        <div className="bg-white dark:bg-gray-800 rounded-lg p-6 shadow-lg">
          <h3 className="text-sm font-medium text-gray-500 dark:text-gray-400">Total Emissions</h3>
          <p className="text-2xl font-bold text-gray-900 dark:text-white">
            {totalEmissions.toFixed(1)} kg CO₂
          </p>
        </div>
        
        <div className="bg-green-50 dark:bg-green-900/20 rounded-lg p-6 shadow-lg">
          <h3 className="text-sm font-medium text-green-600 dark:text-green-400">Carbon Saved</h3>
          <p className="text-2xl font-bold text-green-900 dark:text-green-100">
            {totalSavings.toFixed(1)} kg CO₂
          </p>
        </div>
        
        <div className="bg-blue-50 dark:bg-blue-900/20 rounded-lg p-6 shadow-lg">
          <h3 className="text-sm font-medium text-blue-600 dark:text-blue-400">Carbon Efficiency</h3>
          <p className="text-2xl font-bold text-blue-900 dark:text-blue-100">
            {carbonEfficiency.toFixed(1)}%
          </p>
        </div>
        
        <div className="bg-purple-50 dark:bg-purple-900/20 rounded-lg p-6 shadow-lg">
          <h3 className="text-sm font-medium text-purple-600 dark:text-purple-400">Avg Delay</h3>
          <p className="text-2xl font-bold text-purple-900 dark:text-purple-100">
            {(metrics.reduce((sum, m) => sum + m.averageDelay, 0) / metrics.length || 0).toFixed(0)} min
          </p>
        </div>
      </div>
      
      {/* Time Range Selector */}
      <div className="flex space-x-4">
        {(['24h', '7d', '30d'] as const).map((range) => (
          <button
            key={range}
            onClick={() => setTimeRange(range)}
            className={`px-4 py-2 rounded-lg font-medium transition-colors ${
              timeRange === range 
                ? 'bg-green-500 text-white' 
                : 'bg-gray-200 dark:bg-gray-700 text-gray-700 dark:text-gray-300'
            }`}
          >
            {range}
          </button>
        ))}
      </div>
      
      {/* Carbon Emissions Timeline */}
      <div className="bg-white dark:bg-gray-800 rounded-lg p-6 shadow-lg">
        <h3 className="text-lg font-semibold mb-4 text-gray-900 dark:text-white">Carbon Emissions Over Time</h3>
        <ResponsiveContainer width="100%" height={300}>
          <LineChart data={metrics}>
            <CartesianGrid strokeDasharray="3 3" />
            <XAxis dataKey="timestamp" />
            <YAxis />
            <Tooltip />
            <Line type="monotone" dataKey="totalEmissions" stroke="#ef4444" name="Total Emissions (kg CO₂)" />
            <Line type="monotone" dataKey="savedEmissions" stroke="#10b981" name="Saved Emissions (kg CO₂)" />
          </LineChart>
        </ResponsiveContainer>
      </div>
      
      {/* Service Breakdown */}
      <div className="bg-white dark:bg-gray-800 rounded-lg p-6 shadow-lg">
        <h3 className="text-lg font-semibold mb-4 text-gray-900 dark:text-white">Emissions by Service</h3>
        <ResponsiveContainer width="100%" height={300}>
          <BarChart data={serviceBreakdown}>
            <CartesianGrid strokeDasharray="3 3" />
            <XAxis dataKey="serviceName" />
            <YAxis />
            <Tooltip />
            <Bar dataKey="emissions" fill="#3b82f6" />
          </BarChart>
        </ResponsiveContainer>
      </div>
      
      {/* Optimization Recommendations */}
      <div className="bg-yellow-50 dark:bg-yellow-900/20 rounded-lg p-6 shadow-lg">
        <h3 className="text-lg font-semibold mb-4 text-yellow-800 dark:text-yellow-200">
          Carbon Optimization Recommendations
        </h3>
        <div className="space-y-3">
          <div className="flex items-center space-x-3">
            <div className="w-2 h-2 bg-green-500 rounded-full"></div>
            <p className="text-yellow-800 dark:text-yellow-200">
              Migrate batch jobs to US West region during peak solar hours (10-16 UTC)
            </p>
          </div>
          <div className="flex items-center space-x-3">
            <div className="w-2 h-2 bg-blue-500 rounded-full"></div>
            <p className="text-yellow-800 dark:text-yellow-200">
              Schedule ML training workloads during low-carbon intensity periods
            </p>
          </div>
          <div className="flex items-center space-x-3">
            <div className="w-2 h-2 bg-purple-500 rounded-full"></div>
            <p className="text-yellow-800 dark:text-yellow-200">
              Enable aggressive auto-scaling for development environments
            </p>
          </div>
        </div>
      </div>
    </div>
  );
};