AWS Graviton4 vs. Intel Sapphire Rapids: EC2 Cost-Performance Benchmark

// ec2-benchmark-runner.go
// Compares Graviton4 vs Sapphire Rapids integer throughput per dollar
// Run on target EC2 instance with `go run ec2-benchmark-runner.go`
package main

import (
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"log\"
    \"math\"
    \"net/http\"
    \"os\"
    \"runtime\"
    \"time\"
)

// InstanceMetadata holds EC2 instance details from IMDSv2
type InstanceMetadata struct {
    InstanceType string `json:\"instance-type\"`
    Architecture string `json:\"architecture\"`
}

// BenchmarkResult stores throughput and cost metrics
type BenchmarkResult struct {
    InstanceType    string
    Architecture    string
    OpsPerSecond    float64
    HourlyCost      float64
    OpsPerDollar    float64
    BenchmarkDuration time.Duration
}

// fetchIMDSv2 retrieves instance metadata using IMDSv2 token
func fetchIMDSv2(ctx context.Context) (*InstanceMetadata, error) {
    // Get IMDSv2 token
    tokenClient := &http.Client{Timeout: 2 * time.Second}
    tokenReq, err := http.NewRequestWithContext(ctx, \"PUT\", \"http://169.254.169.254/latest/api/token\", nil)
    if err != nil {
        return nil, fmt.Errorf(\"failed to create token request: %w\", err)
    }
    tokenReq.Header.Set(\"X-aws-ec2-metadata-token-ttl-seconds\", \"21600\")
    tokenResp, err := tokenClient.Do(tokenReq)
    if err != nil {
        return nil, fmt.Errorf(\"failed to fetch IMDSv2 token: %w\", err)
    }
    defer tokenResp.Body.Close()
    if tokenResp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf(\"IMDSv2 token request failed with status: %d\", tokenResp.StatusCode)
    }
    var token string
    fmt.Fscanf(tokenResp.Body, \"%s\", &token)

    // Fetch instance type
    instanceClient := &http.Client{Timeout: 2 * time.Second}
    instanceReq, err := http.NewRequestWithContext(ctx, \"GET\", \"http://169.254.169.254/latest/meta-data/instance-type\", nil)
    if err != nil {
        return nil, fmt.Errorf(\"failed to create instance type request: %w\", err)
    }
    instanceReq.Header.Set(\"X-aws-ec2-metadata-token\", token)
    instanceResp, err := instanceClient.Do(instanceReq)
    if err != nil {
        return nil, fmt.Errorf(\"failed to fetch instance type: %w\", err)
    }
    defer instanceResp.Body.Close()
    if instanceResp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf(\"instance type request failed with status: %d\", instanceResp.StatusCode)
    }
    var instanceType string
    fmt.Fscanf(instanceResp.Body, \"%s\", &instanceType)

    // Determine architecture
    arch := runtime.GOARCH
    return &InstanceMetadata{InstanceType: instanceType, Architecture: arch}, nil
}

// runIntegerBenchmark simulates SPEC CPU 2017 integer workload (502.gcc_r)
func runIntegerBenchmark(ctx context.Context, duration time.Duration) (float64, error) {
    start := time.Now()
    var ops uint64 = 0
    // Simulate integer operations: bitwise, arithmetic, control flow
    for time.Since(start) < duration {
        select {
        case <-ctx.Done():
            return 0, fmt.Errorf(\"benchmark cancelled\")
        default:
            // Simulate 1000 integer ops per iteration
            for i := 0; i < 1000; i++ {
                _ = i ^ (i << 3) & 0xFFFF
                _ = math.Sqrt(float64(i)) // Convert to float for mixed workload
            }
            ops += 1000
        }
    }
    elapsed := time.Since(start).Seconds()
    return float64(ops) / elapsed, nil
}

// getHourlyCost returns instance hourly cost (hardcoded for demo, use AWS Pricing API in prod)
func getHourlyCost(instanceType string) float64 {
    costs := map[string]float64{
        \"c8g.4xlarge\": 0.6128, // Graviton4 us-east-1
        \"c7i.4xlarge\": 0.8320, // Sapphire Rapids us-east-1
    }
    if cost, ok := costs[instanceType]; ok {
        return cost
    }
    return 0.0
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
    defer cancel()

    // Fetch instance metadata
    meta, err := fetchIMDSv2(ctx)
    if err != nil {
        log.Fatalf(\"Failed to fetch instance metadata: %v\", err)
    }
    fmt.Printf(\"Running benchmark on %s (%s)\\n\", meta.InstanceType, meta.Architecture)

    // Run benchmark for 60 seconds
    benchmarkDuration := 60 * time.Second
    opsPerSecond, err := runIntegerBenchmark(ctx, benchmarkDuration)
    if err != nil {
        log.Fatalf(\"Benchmark failed: %v\", err)
    }

    // Calculate cost metrics
    hourlyCost := getHourlyCost(meta.InstanceType)
    if hourlyCost == 0 {
        log.Fatalf(\"Unknown instance type: %s\", meta.InstanceType)
    }
    opsPerDollar := opsPerSecond * 3600 / hourlyCost // 3600 seconds per hour

    // Print results
    result := BenchmarkResult{
        InstanceType:    meta.InstanceType,
        Architecture:    meta.Architecture,
        OpsPerSecond:    opsPerSecond,
        HourlyCost:      hourlyCost,
        OpsPerDollar:    opsPerDollar,
        BenchmarkDuration: benchmarkDuration,
    }
    jsonResult, _ := json.MarshalIndent(result, \"\", \"  \")
    fmt.Println(string(jsonResult))
}

# graviton_break_even.py
# Calculates break-even period for migrating from Sapphire Rapids to Graviton4
# Requires: pip install boto3 pandas
import boto3
import pandas as pd
from datetime import datetime, timedelta
import sys
import json

class EC2CostCalculator:
    def __init__(self, region=\"us-east-1\"):
        self.region = region
        self.pricing_client = boto3.client(\"pricing\", region_name=\"us-east-1\") # Pricing API is only us-east-1
        self.cloudwatch = boto3.client(\"cloudwatch\", region_name=region)
        self.instance_costs = {} # Cache for instance costs

    def get_on_demand_cost(self, instance_type):
        \"\"\"Fetch on-demand hourly cost for instance type using AWS Pricing API\"\"\"
        if instance_type in self.instance_costs:
            return self.instance_costs[instance_type]
        try:
            response = self.pricing_client.get_products(
                ServiceCode=\"AmazonEC2\",
                Filters=[
                    {\"Type\": \"TERM_MATCH\", \"Field\": \"instanceType\", \"Value\": instance_type},
                    {\"Type\": \"TERM_MATCH\", \"Field\": \"location\", \"Value\": \"US East (N. Virginia)\"},
                    {\"Type\": \"TERM_MATCH\", \"Field\": \"operatingSystem\", \"Value\": \"Linux\"},
                    {\"Type\": \"TERM_MATCH\", \"Field\": \"tenancy\", \"Value\": \"Shared\"},
                    {\"Type\": \"TERM_MATCH\", \"Field\": \"preInstalledSw\", \"Value\": \"NA\"},
                ],
                MaxResults=1
            )
            if not response[\"PriceList\"]:
                raise ValueError(f\"No pricing data found for {instance_type}\")
            price_item = json.loads(response[\"PriceList\"][0])
            terms = price_item[\"terms\"][\"OnDemand\"]
            term_key = next(iter(terms))
            price_dimensions = terms[term_key][\"priceDimensions\"]
            dimension_key = next(iter(price_dimensions))
            hourly_cost = float(price_dimensions[dimension_key][\"pricePerUnit\"][\"USD\"])
            self.instance_costs[instance_type] = hourly_cost
            return hourly_cost
        except Exception as e:
            print(f\"Error fetching cost for {instance_type}: {e}\", file=sys.stderr)
            # Fallback to hardcoded values if API fails
            fallback = {\"c8g.4xlarge\": 0.6128, \"c7i.4xlarge\": 0.8320}
            return fallback.get(instance_type, 0.0)

    def get_workload_metrics(self, cluster_id, start_time, end_time):
        \"\"\"Fetch average CPU utilization and throughput from CloudWatch for a cluster\"\"\"
        try:
            # Get CPU utilization
            cpu_response = self.cloudwatch.get_metric_statistics(
                Namespace=\"AWS/EC2\",
                MetricName=\"CPUUtilization\",
                Dimensions=[{\"Name\": \"ClusterId\", \"Value\": cluster_id}],
                StartTime=start_time,
                EndTime=end_time,
                Period=3600, # Hourly aggregates
                Statistics=[\"Average\"]
            )
            avg_cpu = pd.DataFrame(cpu_response[\"Datapoints\"])[\"Average\"].mean() if cpu_response[\"Datapoints\"] else 0.0

            # Get network throughput (proxy for I/O workload)
            net_response = self.cloudwatch.get_metric_statistics(
                Namespace=\"AWS/EC2\",
                MetricName=\"NetworkOut\",
                Dimensions=[{\"Name\": \"ClusterId\", \"Value\": cluster_id}],
                StartTime=start_time,
                EndTime=end_time,
                Period=3600,
                Statistics=[\"Sum\"]
            )
            total_net_out = pd.DataFrame(net_response[\"Datapoints\"])[\"Sum\"].sum() if net_response[\"Datapoints\"] else 0.0
            hours = (end_time - start_time).total_seconds() / 3600
            avg_net_mbps = (total_net_out * 8 / 1e6) / hours if hours > 0 else 0.0

            return {\"avg_cpu\": avg_cpu, \"avg_net_mbps\": avg_net_mbps, \"hours\": hours}
        except Exception as e:
            print(f\"Error fetching CloudWatch metrics: {e}\", file=sys.stderr)
            return None

    def calculate_break_even(self, current_instance, target_instance, workload_hours_per_day=24, migration_cost=5000):
        \"\"\"Calculate break-even period in months for migration\"\"\"
        current_cost = self.get_on_demand_cost(current_instance)
        target_cost = self.get_on_demand_cost(target_instance)
        if current_cost == 0 or target_cost == 0:
            raise ValueError(\"Invalid instance types\")
        hourly_savings = current_cost - target_cost
        if hourly_savings <= 0:
            return float(\"inf\") # No savings
        daily_savings = hourly_savings * workload_hours_per_day
        monthly_savings = daily_savings * 30
        break_even_months = migration_cost / monthly_savings
        return round(break_even_months, 1)

def main():
    if len(sys.argv) != 3:
        print(\"Usage: python graviton_break_even.py  \")
        print(\"Example: python graviton_break_even.py c7i.4xlarge c8g.4xlarge\")
        sys.exit(1)
    current_instance = sys.argv[1]
    target_instance = sys.argv[2]
    calculator = EC2CostCalculator(region=\"us-east-1\")
    try:
        break_even = calculator.calculate_break_even(current_instance, target_instance, migration_cost=7500)
        if break_even == float(\"inf\"):
            print(f\"No cost savings migrating from {current_instance} to {target_instance}\")
        else:
            print(f\"Break-even period: {break_even} months (migration cost: $7500)\")
            print(f\"Current hourly cost: ${calculator.get_on_demand_cost(current_instance):.4f}\")
            print(f\"Target hourly cost: ${calculator.get_on_demand_cost(target_instance):.4f}\")
    except Exception as e:
        print(f\"Calculation failed: {e}\", file=sys.stderr)
        sys.exit(1)

if __name__ == \"__main__\":
    main()

# benchmark-cluster.tf
# Deploys identical benchmark clusters on Graviton4 (c8g) and Sapphire Rapids (c7i)
# Requires: Terraform 1.7+, AWS provider 5.0+

terraform {
  required_version = \">= 1.7.0\"
  required_providers {
    aws = {
      source  = \"hashicorp/aws\"
      version = \">= 5.0.0\"
    }
  }
  # Store state in S3 (uncomment for production use)
  # backend \"s3\" {
  #   bucket = \"my-benchmark-terraform-state\"
  #   key    = \"graviton4-vs-sapphire-rapids/terraform.tfstate\"
  #   region = \"us-east-1\"
  # }
}

provider \"aws\" {
  region = \"us-east-1\"
}

# Common variables
variable \"benchmark_duration_hours\" {
  description = \"How long to run benchmarks (for Spot instance max lifetime)\"
  type        = number
  default     = 72
  validation {
    condition     = var.benchmark_duration_hours > 0 && var.benchmark_duration_hours <= 168
    error_message = \"Benchmark duration must be between 1 and 168 hours.\"
  }
}

variable \"cluster_size\" {
  description = \"Number of nodes per cluster\"
  type        = number
  default     = 4
  validation {
    condition     = var.cluster_size >= 2 && var.cluster_size <= 16
    error_message = \"Cluster size must be between 2 and 16 nodes.\"
  }
}

# Graviton4 cluster (c8g.4xlarge)
resource \"aws_instance\" \"graviton_benchmark\" {
  count                  = var.cluster_size
  ami                    = \"ami-0c7217cdde317cfec\" # Amazon Linux 2023.5 ARM64
  instance_type          = \"c8g.4xlarge\"
  subnet_id              = aws_subnet.benchmark_subnet.id
  vpc_security_group_ids = [aws_security_group.benchmark_sg.id]
  iam_instance_profile   = aws_iam_instance_profile.benchmark_profile.name
  # Use Spot instances for cost savings (max 72 hour lifetime)
  spot_instance_request = {
    spot_price           = \"0.70\" # Above Graviton4 on-demand, below Sapphire Rapids
    valid_until          = timeadd(timestamp(), \"${var.benchmark_duration_hours}h\")
    instance_interruption_behavior = \"terminate\"
  }
  user_data = templatefile(\"${path.module}/benchmark-userdata.sh\", {
    instance_family = \"graviton4\"
    benchmark_duration = var.benchmark_duration_hours
  })
  tags = {
    Name        = \"graviton4-benchmark-node-${count.index}\"
    Environment = \"benchmark\"
    Project     = \"graviton4-vs-sapphire-rapids\"
  }
  # Ensure Spot instance is terminated after benchmark ends
  lifecycle {
    create_before_destroy = true
  }
}

# Sapphire Rapids cluster (c7i.4xlarge)
resource \"aws_instance\" \"sapphire_benchmark\" {
  count                  = var.cluster_size
  ami                    = \"ami-03a6eaae9938c858c\" # Amazon Linux 2023.5 x86_64
  instance_type          = \"c7i.4xlarge\"
  subnet_id              = aws_subnet.benchmark_subnet.id
  vpc_security_group_ids = [aws_security_group.benchmark_sg.id]
  iam_instance_profile   = aws_iam_instance_profile.benchmark_profile.name
  spot_instance_request = {
    spot_price           = \"0.80\" # Below Sapphire Rapids on-demand ($0.8320)
    valid_until          = timeadd(timestamp(), \"${var.benchmark_duration_hours}h\")
    instance_interruption_behavior = \"terminate\"
  }
  user_data = templatefile(\"${path.module}/benchmark-userdata.sh\", {
    instance_family = \"sapphire-rapids\"
    benchmark_duration = var.benchmark_duration_hours
  })
  tags = {
    Name        = \"sapphire-rapids-benchmark-node-${count.index}\"
    Environment = \"benchmark\"
    Project     = \"graviton4-vs-sapphire-rapids\"
  }
  lifecycle {
    create_before_destroy = true
  }
}

# Common networking resources
resource \"aws_vpc\" \"benchmark_vpc\" {
  cidr_block           = \"10.0.0.0/16\"
  enable_dns_support   = true
  enable_dns_hostnames = true
  tags = {
    Name = \"benchmark-vpc\"
  }
}

resource \"aws_subnet\" \"benchmark_subnet\" {
  vpc_id                  = aws_vpc.benchmark_vpc.id
  cidr_block              = \"10.0.1.0/24\"
  map_public_ip_on_launch = true
  availability_zone       = \"us-east-1a\"
  tags = {
    Name = \"benchmark-subnet\"
  }
}

resource \"aws_security_group\" \"benchmark_sg\" {
  vpc_id = aws_vpc.benchmark_vpc.id
  # Allow SSH from trusted IPs (replace with your IP)
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = \"tcp\"
    cidr_blocks = [\"0.0.0.0/0\"] # TODO: Restrict to your IP in production
  }
  # Allow all outbound traffic
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = \"-1\"
    cidr_blocks = [\"0.0.0.0/0\"]
  }
  tags = {
    Name = \"benchmark-sg\"
  }
}

# IAM role for instances to fetch S3 benchmark results
resource \"aws_iam_role\" \"benchmark_role\" {
  name = \"benchmark-ec2-role\"
  assume_role_policy = jsonencode({
    Version = \"2012-10-17\"
    Statement = [{
      Action = \"sts:AssumeRole\"
      Effect = \"Allow\"
      Principal = { Service = \"ec2.amazonaws.com\" }
    }]
  })
}

resource \"aws_iam_role_policy\" \"benchmark_policy\" {
  name = \"benchmark-s3-policy\"
  role = aws_iam_role.benchmark_role.id
  policy = jsonencode({
    Version = \"2012-10-17\"
    Statement = [{
      Action = [\"s3:PutObject\", \"s3:GetObject\"]
      Effect = \"Allow\"
      Resource = \"arn:aws:s3:::my-benchmark-results/*\"
    }]
  })
}

resource \"aws_iam_instance_profile\" \"benchmark_profile\" {
  name = \"benchmark-instance-profile\"
  role = aws_iam_role.benchmark_role.name
}

# Output cost comparison
output \"graviton4_cluster_cost_per_hour\" {
  value = var.cluster_size * 0.6128
  description = \"Total hourly cost for Graviton4 cluster (on-demand)\"
}

output \"sapphire_rapids_cluster_cost_per_hour\" {
  value = var.cluster_size * 0.8320
  description = \"Total hourly cost for Sapphire Rapids cluster (on-demand)\"
}

output \"benchmark_cluster_ips\" {
  value = {
    graviton4 = aws_instance.graviton_benchmark[*].public_ip
    sapphire_rapids = aws_instance.sapphire_benchmark[*].public_ip
  }
}

# Multi-arch Go build for Graviton4 and Sapphire Rapids
GOOS=linux GOARCH=amd64 go build -o bin/myapp-amd64 cmd/main.go
GOOS=linux GOARCH=arm64 go build -o bin/myapp-arm64 cmd/main.go
# Combine into single container image with Buildx
docker buildx build --platform linux/amd64,linux/arm64 -t myrepo/myapp:v1.0 --push .

# Check if Go binary uses AVX-512 instructions
objdump -d myapp-amd64 | grep -i avx512
# If no output, the binary has no AVX-512 code and is a candidate for Graviton4

# Fetch Compute Optimizer recommendations for EC2 instances
aws compute-optimizer get-ec2-instance-recommendations \\
  --instance-arns arn:aws:ec2:us-east-1:123456789012:instance/* \\
  --region us-east-1 \\
  --query \"instanceRecommendations[?currentInstanceType=='c7i.4xlarge'].recommendationOptions[0].instanceType\"