Why advanced networking matters in Azure - Performance Analysis

Time Complexity: Why advanced networking matters

O(n²)

Understanding Time Complexity

When using advanced networking in Azure, it's important to know how the time to set up and manage resources changes as your network grows.

We want to understand how the number of operations grows when adding more network components.

Scenario Under Consideration

Analyze the time complexity of creating multiple virtual networks and connecting them with peering.

// Create n virtual networks
for (int i = 0; i < n; i++) {
  CreateVirtualNetwork(vnetName + i);
}

// Peer each virtual network with every other
for (int i = 0; i < n; i++) {
  for (int j = i + 1; j < n; j++) {
    CreateVNetPeering(vnetName + i, vnetName + j);
  }
}
    

This sequence creates n virtual networks and connects each pair with peering links.

Identify Repeating Operations

Look at what repeats as n grows:

• Primary operation: Creating virtual networks and creating peering connections.
• How many times: Creating networks happens n times; peering happens for every pair, about n×(n-1)/2 times.

How Execution Grows With Input

As you add more networks, the number of peering connections grows much faster than the networks themselves.

Input Size (n)	Approx. Api Calls/Operations
10	10 networks + 45 peerings = 55 operations
100	100 networks + 4,950 peerings = 5,050 operations
1000	1000 networks + 499,500 peerings = 500,500 operations

Pattern observation: The peering operations grow much faster than the network creations, roughly like the square of n.

Final Time Complexity

Time Complexity: O(n²)

This means that as you add more networks, the total operations increase roughly by the square of the number of networks.

Common Mistake

[X] Wrong: "Adding more networks only increases operations linearly because each network is created once."

[OK] Correct: While creating networks is linear, connecting every pair grows much faster, making the total operations grow quadratically.

Interview Connect

Understanding how network operations grow helps you design scalable cloud architectures and shows you can think about real-world system limits.

Self-Check

"What if we only connected each network to a fixed number of others instead of all pairs? How would the time complexity change?"