def calculate_azure_tco_without_blind_spot(instance, dimension, number_of_vms,
storage, scenario):
if scenario == "linux":
upfront_cost = instance["linux"] * (
1 - instance["discount"]) * number_of_vms * 36 / 1000
elif scenario == "windows_with_hybrid_benefit":
upfront_cost = instance["windows_with_hybrid_benefit"] * (
1 - instance["discount"]) * number_of_vms * 36 / 1000
else:
upfront_cost = instance["windows"] * (
1 - instance["discount"]) * number_of_vms * 36 / 1000
egress_cost = instance["egress"] * upfront_cost
managed_disk_cost = 0
if storage > 0:
managed_disk_cost = number_of_vms * managed_disk[pow(
2, math.ceil(math.log2(storage)))] * 36 / 1000
number_of_racks, dimension_tco = calculate_dimension_tco(
dimension, number_of_vms)
security_cost = calculate_security_cost(number_of_vms, number_of_racks)
return upfront_cost + egress_cost + managed_disk_cost + security_cost
def calculate_ec2_tco_without_blind_spot(instance, dimension, number_of_vms,
storage):
upfront_cost = instance["price_per_month"] * (
1 - instance["discount"]) * number_of_vms * 36 / 1000
egress_cost = instance["egress"] * upfront_cost
ebs_cost = number_of_vms * storage * instance["ebs_gb_month"] * 36 / 1000
number_of_racks, dimension_tco = calculate_dimension_tco(
dimension, number_of_vms)
security_cost = calculate_security_cost(number_of_vms, number_of_racks)
return upfront_cost + egress_cost + ebs_cost + security_cost
def build_azure_cost_curves(instance, scenario):
all_azure_cost_curves = []
all_dimension_cost_curves = []
flags = [False, True]
for blind_cost_flag in flags:
for dimension_node_type, dimension_node in dimension_nodes.items():
blind_cost = "with" if blind_cost_flag else "without"
dimension = dimension_node.copy()
dimension["vCPU"] = instance["vCPU"]
dimension["memory"] = instance["memory"]
dimension_cost_curve = []
dimension_cost_curve.append(dimension_node_type + "_" +
str(instance["vCPU"]) + "_" +
str(instance["memory"]))
for number_of_vms in vm_range: #range(vm_start, vm_end, vm_increment):
racks, dimension_tco = calculate_dimension_tco(
dimension, number_of_vms)
dimension_cost_curve.append(
str(round(dimension_tco / number_of_vms, 2)))
all_dimension_cost_curves.append(dimension_cost_curve)
for storage in storage_range: #(storage_start, storage_end, storage_increment):
azure_cost_curve = []
azure_cost_curve.append(dimension["alias"] + "_" +
instance["name"] + "_" + str(storage) +
"_" + blind_cost)
for number_of_vms in vm_range: #range(vm_start, vm_end, vm_increment):
azure_tco_per_vm = calculate_azure_tco_with_blind_spot(
instance, dimension, number_of_vms, storage, scenario
) / number_of_vms if blind_cost_flag else calculate_azure_tco_without_blind_spot(
instance, dimension, number_of_vms, storage,
scenario) / number_of_vms
azure_cost_curve.append(round(azure_tco_per_vm, 2))
all_azure_cost_curves.append(azure_cost_curve)
return all_dimension_cost_curves, all_azure_cost_curves
def build_competitive_matrix_azure(instance, scenario):
intersection_points = {}
transformed_competitive_matrix = []
titles = [
"M1s Medium without oversubscription",
"M1s Medium with oversubscription",
"M1d Medium without oversubscription",
"M1d Medium with oversubscription"
]
blank = [" ", " ", " ", " ", " "]
competitive_matrix = []
flags = [False, True]
for blind_cost_flag in flags:
competitive_matrix = []
for dimension_node_type, dimension_node in dimension_nodes.items():
dimension = dimension_node.copy()
dimension["vCPU"] = instance["vCPU"]
dimension["memory"] = instance["memory"]
for storage in storage_range: #(storage_start, storage_end, storage_increment):
for number_of_vms in vm_range: #range(vm_start, vm_end, vm_increment):
number_of_racks, dimension_tco = calculate_dimension_tco(
dimension, number_of_vms)
dimension_tco_per_vm = dimension_tco / number_of_vms
azure_tco_per_vm = calculate_azure_tco_with_blind_spot(
instance, dimension, number_of_vms, storage, scenario
) / number_of_vms if blind_cost_flag else calculate_azure_tco_without_blind_spot(
instance, dimension, number_of_vms, storage,
scenario) / number_of_vms
if dimension_tco_per_vm <= azure_tco_per_vm:
percentage_better = round(
(azure_tco_per_vm - dimension_tco_per_vm) * 100 /
dimension_tco_per_vm, 1)
intersection_points[storage] = str(
number_of_vms
) #+ " (" + str(percentage_better) + "%)"
break
intersection_points[storage] = "Azure better"
competitive_matrix.append(
[value for key, value in intersection_points.items()])
i = 0
for storage in storage_range: #(storage_start, storage_end, storage_increment):
temp = []
for j in range(0, len(competitive_matrix), 1):
temp.append(competitive_matrix[j][i])
i = i + 1
transformed_competitive_matrix.append([str(storage) + " Gb"] +
temp)
instance_name_with = [instance["name"] + " with blind cost"] + titles
instance_name_without = [instance["name"] + " without blind cost"] + titles
length = len(
storage_range
) #len(list(range(storage_start, storage_end, storage_increment)))
transformed_competitive_matrix.insert(0, instance_name_without)
transformed_competitive_matrix.insert(length + 1, instance_name_with)
transformed_competitive_matrix.append(blank)
return transformed_competitive_matrix