Each tenant added one more and all of them slowed

# 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

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.")

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.

Trace event types