When planning international server infrastructure, the speed of light becomes a hard physical constraint. Fiber optic cables transmit data at about 200,000 km/s (two-thirds of light speed in vacuum). The great-circle distance between Copenhagen and Mumbai is approximately 6,700 km, making the theoretical minimum latency:

// Calculate theoretical minimum latency
const distance = 6700; // km
const speed = 200000; // km/s
const minLatency = (distance / speed) * 1000; // ms

console.log(Theoretical minimum latency: ${minLatency.toFixed(2)}ms);
// Output: Theoretical minimum latency: 33.50ms

Actual ping times between Denmark and India typically range from 110-150ms due to:

• Suboptimal cable routes (often via London or Frankfurt)
• Network equipment processing delays
• Peering point congestion

Here's how to measure actual latency using Python:

import subprocess
import statistics

def measure_latency(host, count=10):
    times = []
    for _ in range(count):
        result = subprocess.run(['ping', '-c', '1', host], 
                              stdout=subprocess.PIPE)
        output = result.stdout.decode()
        time = float(output.split('time=')[1].split(' ms')[0])
        times.append(time)
    return statistics.mean(times)

# Example usage
india_gateway = 'dns.google.com'  # Using Google's Mumbai DNS
avg_latency = measure_latency(india_gateway)
print(f"Average latency to India: {avg_latency:.2f}ms")

For infrastructure planning, consider these tools:

// Node.js example using WonderNetwork's API
const axios = require('axios');

async function getLatencyMap(origin) {
    const response = await axios.get(
        https://api.wondernetwork.com/latency-map?origin=${origin}
    );
    return response.data;
}

// Copenhagen to major cities
getLatencyMap('copenhagen')
    .then(data => {
        console.log('India latency:', data.destinations.mumbai.latency);
        console.log('Full latency map:', data);
    });

The Pareto principle applies to latency optimization. For European-Asian traffic:

Calculation formula:

function calculateScore(euLatency, asiaLatency) {
    // Weighted harmonic mean favors balanced latency
    return 2 / ((1/euLatency) + (1/asiaLatency));
}

Major providers publish their latency matrices:

# AWS latency lookup example
import boto3

client = boto3.client('cloudwatch')
response = client.get_metric_data(
    MetricDataQueries=[
        {
            'Id': 'latency',
            'MetricStat': {
                'Metric': {
                    'Namespace': 'AWS/EC2',
                    'MetricName': 'NetworkLatency',
                    'Dimensions': [
                        {
                            'Name': 'Region',
                            'Value': 'ap-south-1'
                        }
                    ]
                },
                'Period': 3600,
                'Stat': 'Average'
            }
        }
    ],
    StartTime=...,
    EndTime=...
)

When building global gaming infrastructure, network latency becomes the single most critical factor affecting player experience. A 100ms difference can determine whether your game feels responsive or unplayable. While theoretical minimums exist (dictated by the speed of light in fiber optics), real-world routing and peering arrangements create significant variations.

Several services provide latency mapping capabilities:

• CloudPing.info: Tests latency between AWS regions
• WonderNetwork's Global Ping: Tests from multiple global locations
• RIPE Atlas: Network measurement platform with global probes

Here's a Python script to automate latency tests using Cloudflare's speed test:

import subprocess
import json

def test_latency(target="1.1.1.1", location="Delhi"):
    cmd = f"ping -c 10 {target}"
    output = subprocess.run(cmd.split(), capture_output=True, text=True)
    
    # Parse ping output
    lines = output.stdout.split('\n')
    stats = lines[-2].split('=')[1].split('/')
    
    return {
        'location': location,
        'min': float(stats[0]),
        'avg': float(stats[1]),
        'max': float(stats[2])
    }

# Example: Test latency from different regions
locations = {
    "Copenhagen": "193.162.153.175",
    "Mumbai": "203.192.185.66",
    "Singapore": "203.117.172.38"
}

results = [test_latency(ip, loc) for loc, ip in locations.items()]
print(json.dumps(results, indent=2))

Based on real measurements and submarine cable routes, the minimum theoretical latency between Copenhagen and Mumbai is approximately 150ms (via the SEA-ME-WE 3 cable). However, typical observed latencies range from 180-220ms due to:

• Terrestrial routing inefficiencies
• Peering point congestion
• TCP/IP protocol overhead

For games requiring sub-100ms response times, consider these architectures:

// Sample server placement algorithm in JavaScript
function optimalServerPlacement(players) {
  const clusters = {};
  
  players.forEach(player => {
    const region = getNearestCluster(player.location);
    clusters[region] = clusters[region] || [];
    clusters[region].push(player);
  });
  
  return Object.keys(clusters).map(region => ({
    region,
    playerCount: clusters[region].length,
    recommendedLocation: getOptimalDataCenter(region)
  }));
}

// Example usage:
const playerLocations = [
  {id: 1, location: 'Copenhagen'},
  {id: 2, location: 'Berlin'},
  {id: 3, location: 'Mumbai'}
];

console.log(optimalServerPlacement(playerLocations));

New approaches are changing the game:

• Edge Computing: AWS Local Zones, Cloudflare Workers
• Anycast Routing: Automatically connects to nearest PoP
• Predictive Networking