# Example 884 — Each tenant added one more and all of them slowed `each_tenant_added_one_more_and_all_of_them_slowed.eml` - Ten tenants share a cluster, each measures that adding one more worker raises its own throughput, and every measurement is correct. What one tenant's extra worker does to the other nine is computed below. ## EML ```eml # Self-authored for the EML case corpus (no external origin). Ten tenants share # a cluster, each measures that adding one more worker raises its own # throughput, and every measurement is correct. What one tenant's extra worker # does to the other nine is computed below. # # Each tenant's measurement is careful. It reads its own real throughput before # and after; the gain it sees is genuine; the scheduler is fair and every worker # is counted; and the intent is exactly 'more throughput for us'. # # The gain from a worker is private and its contention cost is spread over all # ten, so each addition is rational for the tenant who makes it and a loss for # the cluster - and when all ten add, all ten are slower. 10 => tenants 100 => throughput_per_tenant_before 10 => gain_to_the_adder_per_worker 2 => contention_cost_to_each_tenant_per_worker gain_to_the_adder_per_worker - contention_cost_to_each_tenant_per_worker => net_to_the_adder contention_cost_to_each_tenant_per_worker * tenants => cost_to_the_cluster_per_worker gain_to_the_adder_per_worker - cost_to_the_cluster_per_worker => net_to_the_cluster_per_worker contention_cost_to_each_tenant_per_worker * tenants => cost_to_each_when_all_add gain_to_the_adder_per_worker - cost_to_each_when_all_add => net_to_each_when_all_add throughput_per_tenant_before + net_to_each_when_all_add => throughput_per_tenant_after throughput_per_tenant_before * tenants => cluster_throughput_before throughput_per_tenant_after * tenants => cluster_throughput_after int((cluster_throughput_before - cluster_throughput_after) * 10000 / cluster_throughput_before) => cluster_loss_per_myriad "tenants : " + str(tenants) ^0 "throughput per tenant, before : " + str(throughput_per_tenant_before) ^0 "one extra worker, gain to adder : " + str(gain_to_the_adder_per_worker) ^0 "one extra worker, cost to each : " + str(contention_cost_to_each_tenant_per_worker) ^0 "" ^0 "net to the adder : " + str(net_to_the_adder) + ", so the adder adds" ^0 "net to the cluster : " + str(net_to_the_cluster_per_worker) + ", a loss" ^0 "when all ten add, net to each : " + str(net_to_each_when_all_add) ^0 "throughput per tenant, after : " + str(throughput_per_tenant_after) ^0 "cluster throughput before / after : " + str(cluster_throughput_before) + " / " + str(cluster_throughput_after) ^0 "cluster loss : " + str(cluster_loss_per_myriad) + " per ten thousand" ^0 "" ^0 # ---- what each tenant verified ---- "each tenant's measurement" ^0 " reads : its own real throughput before and after" ^0 " gain : genuine, " + str(gain_to_the_adder_per_worker) + " from its own worker" ^0 " scheduler : fair, every worker counted" ^0 " intent : more throughput for us" ^0 " measurements wrong : 0" ^0 " verdict : ADDING A WORKER RAISES OUR THROUGHPUT" ^0 "" ^0 " measuring the real before-and-after of its own throughput" ^0 " is the part done right here, and it is why the gain each" ^0 " tenant sees is not imagined" ^0 "" ^0 # ---- what the extra worker does to the others ---- "private gain, shared cost" ^0 " what the adder gets : " + str(gain_to_the_adder_per_worker) + ", all of it" ^0 " what the worker costs : " + str(contention_cost_to_each_tenant_per_worker) + " to each of " + str(tenants) + " tenants, " + str(cost_to_the_cluster_per_worker) + " in all" ^0 " what the adder pays of that : " + str(contention_cost_to_each_tenant_per_worker) + ", its one share" ^0 " so for the adder : " + str(net_to_the_adder) + ", worth doing" ^0 " so for the cluster : " + str(net_to_the_cluster_per_worker) + ", not worth doing" ^0 " when everyone reasons the same : each pays all ten shares" ^0 " and gains one, " + str(net_to_each_when_all_add) ^0 "" ^0 # ---- what the tenants got ---- "the outcome" ^0 " each tenant, before : " + str(throughput_per_tenant_before) ^0 " each tenant, after everyone added : " + str(throughput_per_tenant_after) ^0 " is any tenant's measurement wrong : no" ^0 " is any tenant's addition irrational : no; each nets " + str(net_to_the_adder) ^0 " is the sum of ten rational additions rational : no; it is" ^0 " a loss of " + str(cluster_loss_per_myriad) + " per ten thousand for everyone" ^0 "" ^0 # ---- null control ---- # The same cluster with the shared cost charged to the adder (a quota or a price # per worker equal to its contention), so the adder sees the cluster's number. 8 => nc_net_to_the_adder_uncharged gain_to_the_adder_per_worker - cost_to_the_cluster_per_worker => nc_net_to_the_adder_charged_the_full_cost 100 => nc_throughput_per_tenant_when_no_one_adds "null control - charge the adder the whole contention cost" ^0 " net to the adder, cost uncharged : " + str(nc_net_to_the_adder_uncharged) ^0 " net to the adder, full cost charged : " + str(nc_net_to_the_adder_charged_the_full_cost) ^0 " throughput per tenant when no one adds : " + str(nc_throughput_per_tenant_when_no_one_adds) ^0 " no worker and no scheduler changed; the private gain" ^0 " stopped hiding the shared cost" ^0 "" ^0 # ---- the rule ---- "what a per-tenant throughput measurement guarantees" ^0 " adding a worker raised the adder's throughput : exactly," ^0 " real before-and-after, fair scheduler" ^0 " adding workers raises throughput : not addressed; each" ^0 " worker's gain is private and its cost is shared, so ten" ^0 " rational additions take the cluster from " + str(cluster_throughput_before) + " to " + str(cluster_throughput_after) ^0 "" ^0 "a cost spread over everyone is nearly free to the one who causes it, and a" ^0 "gain kept by one is fully his; ten such sums, each correct, add to a loss that" ^0 "none of the ten chose and all of the ten pay" ^0 "" ^0 "Each tenant measures a real gain of " + str(gain_to_the_adder_per_worker) + " from its own worker and pays only" ^0 "" + str(contention_cost_to_each_tenant_per_worker) + " of the " + str(cost_to_the_cluster_per_worker) + " it costs - adding nets " + str(net_to_the_adder) + ". All ten add, each pays all ten shares," ^0 "and every tenant falls from " + str(throughput_per_tenant_before) + " to " + str(throughput_per_tenant_after) + ", " + str(cluster_loss_per_myriad) + " per ten thousand, until the" ^0 "adder is charged the whole cost." ^0 ``` ## Python (deterministic transpilation) ```python tenants = 10 throughput_per_tenant_before = 100 gain_to_the_adder_per_worker = 10 contention_cost_to_each_tenant_per_worker = 2 net_to_the_adder = gain_to_the_adder_per_worker - contention_cost_to_each_tenant_per_worker cost_to_the_cluster_per_worker = contention_cost_to_each_tenant_per_worker * tenants net_to_the_cluster_per_worker = gain_to_the_adder_per_worker - cost_to_the_cluster_per_worker cost_to_each_when_all_add = contention_cost_to_each_tenant_per_worker * tenants net_to_each_when_all_add = gain_to_the_adder_per_worker - cost_to_each_when_all_add throughput_per_tenant_after = throughput_per_tenant_before + net_to_each_when_all_add cluster_throughput_before = throughput_per_tenant_before * tenants cluster_throughput_after = throughput_per_tenant_after * tenants cluster_loss_per_myriad = int((cluster_throughput_before - cluster_throughput_after) * 10000 / cluster_throughput_before) print("tenants : " + str(tenants)) print("throughput per tenant, before : " + str(throughput_per_tenant_before)) print("one extra worker, gain to adder : " + str(gain_to_the_adder_per_worker)) print("one extra worker, cost to each : " + str(contention_cost_to_each_tenant_per_worker)) print("") print("net to the adder : " + str(net_to_the_adder) + ", so the adder adds") print("net to the cluster : " + str(net_to_the_cluster_per_worker) + ", a loss") print("when all ten add, net to each : " + str(net_to_each_when_all_add)) print("throughput per tenant, after : " + str(throughput_per_tenant_after)) print("cluster throughput before / after : " + str(cluster_throughput_before) + " / " + str(cluster_throughput_after)) print("cluster loss : " + str(cluster_loss_per_myriad) + " per ten thousand") print("") print("each tenant's measurement") print(" reads : its own real throughput before and after") print(" gain : genuine, " + str(gain_to_the_adder_per_worker) + " from its own worker") print(" scheduler : fair, every worker counted") print(" intent : more throughput for us") print(" measurements wrong : 0") print(" verdict : ADDING A WORKER RAISES OUR THROUGHPUT") print("") print(" measuring the real before-and-after of its own throughput") print(" is the part done right here, and it is why the gain each") print(" tenant sees is not imagined") print("") print("private gain, shared cost") print(" what the adder gets : " + str(gain_to_the_adder_per_worker) + ", all of it") print(" what the worker costs : " + str(contention_cost_to_each_tenant_per_worker) + " to each of " + str(tenants) + " tenants, " + str(cost_to_the_cluster_per_worker) + " in all") print(" what the adder pays of that : " + str(contention_cost_to_each_tenant_per_worker) + ", its one share") print(" so for the adder : " + str(net_to_the_adder) + ", worth doing") print(" so for the cluster : " + str(net_to_the_cluster_per_worker) + ", not worth doing") print(" when everyone reasons the same : each pays all ten shares") print(" and gains one, " + str(net_to_each_when_all_add)) print("") print("the outcome") print(" each tenant, before : " + str(throughput_per_tenant_before)) print(" each tenant, after everyone added : " + str(throughput_per_tenant_after)) print(" is any tenant's measurement wrong : no") print(" is any tenant's addition irrational : no; each nets " + str(net_to_the_adder)) print(" is the sum of ten rational additions rational : no; it is") print(" a loss of " + str(cluster_loss_per_myriad) + " per ten thousand for everyone") print("") nc_net_to_the_adder_uncharged = 8 nc_net_to_the_adder_charged_the_full_cost = gain_to_the_adder_per_worker - cost_to_the_cluster_per_worker nc_throughput_per_tenant_when_no_one_adds = 100 print("null control - charge the adder the whole contention cost") print(" net to the adder, cost uncharged : " + str(nc_net_to_the_adder_uncharged)) print(" net to the adder, full cost charged : " + str(nc_net_to_the_adder_charged_the_full_cost)) print(" throughput per tenant when no one adds : " + str(nc_throughput_per_tenant_when_no_one_adds)) print(" no worker and no scheduler changed; the private gain") print(" stopped hiding the shared cost") print("") print("what a per-tenant throughput measurement guarantees") print(" adding a worker raised the adder's throughput : exactly,") print(" real before-and-after, fair scheduler") print(" adding workers raises throughput : not addressed; each") print(" worker's gain is private and its cost is shared, so ten") print(" rational additions take the cluster from " + str(cluster_throughput_before) + " to " + str(cluster_throughput_after)) print("") print("a cost spread over everyone is nearly free to the one who causes it, and a") print("gain kept by one is fully his; ten such sums, each correct, add to a loss that") print("none of the ten chose and all of the ten pay") print("") print("Each tenant measures a real gain of " + str(gain_to_the_adder_per_worker) + " from its own worker and pays only") print("" + str(contention_cost_to_each_tenant_per_worker) + " of the " + str(cost_to_the_cluster_per_worker) + " it costs - adding nets " + str(net_to_the_adder) + ". All ten add, each pays all ten shares,") print("and every tenant falls from " + str(throughput_per_tenant_before) + " to " + str(throughput_per_tenant_after) + ", " + str(cluster_loss_per_myriad) + " per ten thousand, until the") print("adder is charged the whole cost.") ``` ## stdout (executed) ```text tenants : 10 throughput per tenant, before : 100 one extra worker, gain to adder : 10 one extra worker, cost to each : 2 net to the adder : 8, so the adder adds net to the cluster : -10, a loss when all ten add, net to each : -10 throughput per tenant, after : 90 cluster throughput before / after : 1000 / 900 cluster loss : 1000 per ten thousand each tenant's measurement reads : its own real throughput before and after gain : genuine, 10 from its own worker scheduler : fair, every worker counted intent : more throughput for us measurements wrong : 0 verdict : ADDING A WORKER RAISES OUR THROUGHPUT measuring the real before-and-after of its own throughput is the part done right here, and it is why the gain each tenant sees is not imagined private gain, shared cost what the adder gets : 10, all of it what the worker costs : 2 to each of 10 tenants, 20 in all what the adder pays of that : 2, its one share so for the adder : 8, worth doing so for the cluster : -10, not worth doing when everyone reasons the same : each pays all ten shares and gains one, -10 the outcome each tenant, before : 100 each tenant, after everyone added : 90 is any tenant's measurement wrong : no is any tenant's addition irrational : no; each nets 8 is the sum of ten rational additions rational : no; it is a loss of 1000 per ten thousand for everyone null control - charge the adder the whole contention cost net to the adder, cost uncharged : 8 net to the adder, full cost charged : -10 throughput per tenant when no one adds : 100 no worker and no scheduler changed; the private gain stopped hiding the shared cost what a per-tenant throughput measurement guarantees adding a worker raised the adder's throughput : exactly, real before-and-after, fair scheduler adding workers raises throughput : not addressed; each worker's gain is private and its cost is shared, so ten rational additions take the cluster from 1000 to 900 a cost spread over everyone is nearly free to the one who causes it, and a gain kept by one is fully his; ten such sums, each correct, add to a loss that none of the ten chose and all of the ten pay Each tenant measures a real gain of 10 from its own worker and pays only 2 of the 20 it costs - adding nets 8. All ten add, each pays all ten shares, and every tenant falls from 100 to 90, 1000 per ten thousand, until the adder is charged the whole cost. ``` ## Round-trip `ok: true` — round-trip fixpoint reached (python1 == python2) ## Trace event types eml:run:start · eml:assign · eml:output · eml:run:done