The two writers used the same key and different clocks

# Self-authored for the EML case corpus (no external origin). Conflicts resolve
# deterministically by last-write-wins and both hosts run a disciplined clock.
# How often the later write loses is computed below.
#
# The resolution rule is deterministic and that matters. Every replica applies
# the same comparison and converges on the same value, so there is no split
# brain and no operator has to choose; the alternative considered was a merge
# function, which the data model cannot support. Clocks are disciplined and the
# monitored offset stays under forty milliseconds.
#
# Last-write-wins compares TIMESTAMPS. Two writes are ordered by whichever
# host's clock read higher, and for two writes closer together than the offset
# between those clocks that is not the order they happened in.
#
# Conflicting writes are a median of twelve milliseconds apart.

8400000 => writes_per_day
24000 => conflicting_pairs_per_day
12 => median_gap_ms
40 => monitored_clock_offset_ms
19600 => pairs_closer_together_than_the_offset
0 => divergent_replicas

int(pairs_closer_together_than_the_offset / 2) => pairs_resolved_backwards
int(pairs_resolved_backwards * 10000 / conflicting_pairs_per_day) => backwards_per_myriad
conflicting_pairs_per_day - pairs_closer_together_than_the_offset => pairs_the_clocks_can_order

"writes per day                   : " + str(writes_per_day) ^0
"conflicting pairs per day        : " + str(conflicting_pairs_per_day) ^0
"median gap between them, ms      : " + str(median_gap_ms) ^0
"monitored clock offset, ms       : " + str(monitored_clock_offset_ms) ^0
"" ^0
"pairs the clocks can order       : " + str(pairs_the_clocks_can_order) ^0
"pairs closer than the offset     : " + str(pairs_closer_together_than_the_offset) ^0
"of those, resolved backwards     : " + str(pairs_resolved_backwards) ^0
"share of conflicts resolved backwards : " + str(backwards_per_myriad) + " per ten thousand" ^0
"divergent replicas               : " + str(divergent_replicas) ^0
"" ^0

# ---- what the rule guarantees ----

"last-write-wins" ^0
"  every replica applies the same comparison : yes" ^0
"  replicas converge on the same value       : yes" ^0
"  divergent replicas observed               : " + str(divergent_replicas) ^0
"  an operator has to choose                 : never" ^0
"  the alternative considered : a merge function the data" ^0
"    model cannot support" ^0
"  verdict : CONVERGENT" ^0
"" ^0
"  determinism is real and it is what makes this operable" ^0
"" ^0

# ---- what it compares ----

"the two operands" ^0
"  a timestamp from host A : A's clock" ^0
"  a timestamp from host B : B's clock" ^0
"  what makes them comparable : an assumption that the" ^0
"    offset between the clocks is smaller than the gap" ^0
"    between the writes" ^0
"  is that assumption monitored : the offset is; the gap" ^0
"    is not" ^0
"" ^0
"  the clock discipline is good and the quantity it is" ^0
"  good enough for is the one nobody measured" ^0
"" ^0

# ---- what convergence means here ----

# Every replica agrees, and what they agree on is the write whose host's clock
# was ahead. Consistency is total and the surviving value is the earlier edit
# about half the time.
"the outcome for one backwards pair" ^0
"  replicas agreeing on the value : all" ^0
"  the value they agree on        : the earlier write" ^0
"  a log line saying so           : none, both writes" ^0
"    succeeded and neither is an error" ^0
"  how a user notices             : their edit is gone" ^0
"" ^0

# ---- null control ----

# The same rule with a logical clock - a version vector - so ordering comes
# from causality rather than from two wall clocks.
0 => nc_pairs_resolved_backwards
pairs_closer_together_than_the_offset => nc_pairs_detected_as_concurrent

"null control - a version vector instead of a wall clock" ^0
"  divergent replicas      : " + str(divergent_replicas) + ", unchanged" ^0
"  pairs resolved backwards: " + str(nc_pairs_resolved_backwards) ^0
"  pairs reported concurrent : " + str(nc_pairs_detected_as_concurrent) + ", which is what they are" ^0
"  the rule did not become more deterministic; the ordering" ^0
"  stopped coming from two unrelated clocks" ^0
"" ^0

# ---- the rule ----

"what last-write-wins guarantees" ^0
"  every replica converges on one value : exactly" ^0
"  that value is the last write         : not addressed;" ^0
"    the comparison is between two clocks, and two clocks" ^0
"    order two events only when they are further apart" ^0
"    than the clocks are" ^0
"" ^0
"a conflict rule can be perfectly deterministic and still be" ^0
"deciding on the wrong quantity; clock discipline bounds the" ^0
"error and the writes have to be further apart than the bound" ^0
"" ^0

"The rule is deterministic and every replica converges - " + str(divergent_replicas) + " divergences, no" ^0
"operator ever chooses. It compares two hosts' clocks, monitored to within" ^0
str(monitored_clock_offset_ms) + " ms, against conflicting writes a median of " + str(median_gap_ms) + " ms apart, so " + str(pairs_closer_together_than_the_offset) ^0
"pairs a day are closer together than the clocks are and about " + str(pairs_resolved_backwards) + " of them -" ^0
str(backwards_per_myriad) + " per ten thousand of conflicts - converge on the earlier edit." ^0

writes_per_day = 8400000
conflicting_pairs_per_day = 24000
median_gap_ms = 12
monitored_clock_offset_ms = 40
pairs_closer_together_than_the_offset = 19600
divergent_replicas = 0
pairs_resolved_backwards = int(pairs_closer_together_than_the_offset / 2)
backwards_per_myriad = int(pairs_resolved_backwards * 10000 / conflicting_pairs_per_day)
pairs_the_clocks_can_order = conflicting_pairs_per_day - pairs_closer_together_than_the_offset
print("writes per day                   : " + str(writes_per_day))
print("conflicting pairs per day        : " + str(conflicting_pairs_per_day))
print("median gap between them, ms      : " + str(median_gap_ms))
print("monitored clock offset, ms       : " + str(monitored_clock_offset_ms))
print("")
print("pairs the clocks can order       : " + str(pairs_the_clocks_can_order))
print("pairs closer than the offset     : " + str(pairs_closer_together_than_the_offset))
print("of those, resolved backwards     : " + str(pairs_resolved_backwards))
print("share of conflicts resolved backwards : " + str(backwards_per_myriad) + " per ten thousand")
print("divergent replicas               : " + str(divergent_replicas))
print("")
print("last-write-wins")
print("  every replica applies the same comparison : yes")
print("  replicas converge on the same value       : yes")
print("  divergent replicas observed               : " + str(divergent_replicas))
print("  an operator has to choose                 : never")
print("  the alternative considered : a merge function the data")
print("    model cannot support")
print("  verdict : CONVERGENT")
print("")
print("  determinism is real and it is what makes this operable")
print("")
print("the two operands")
print("  a timestamp from host A : A's clock")
print("  a timestamp from host B : B's clock")
print("  what makes them comparable : an assumption that the")
print("    offset between the clocks is smaller than the gap")
print("    between the writes")
print("  is that assumption monitored : the offset is; the gap")
print("    is not")
print("")
print("  the clock discipline is good and the quantity it is")
print("  good enough for is the one nobody measured")
print("")
print("the outcome for one backwards pair")
print("  replicas agreeing on the value : all")
print("  the value they agree on        : the earlier write")
print("  a log line saying so           : none, both writes")
print("    succeeded and neither is an error")
print("  how a user notices             : their edit is gone")
print("")
nc_pairs_resolved_backwards = 0
nc_pairs_detected_as_concurrent = pairs_closer_together_than_the_offset
print("null control - a version vector instead of a wall clock")
print("  divergent replicas      : " + str(divergent_replicas) + ", unchanged")
print("  pairs resolved backwards: " + str(nc_pairs_resolved_backwards))
print("  pairs reported concurrent : " + str(nc_pairs_detected_as_concurrent) + ", which is what they are")
print("  the rule did not become more deterministic; the ordering")
print("  stopped coming from two unrelated clocks")
print("")
print("what last-write-wins guarantees")
print("  every replica converges on one value : exactly")
print("  that value is the last write         : not addressed;")
print("    the comparison is between two clocks, and two clocks")
print("    order two events only when they are further apart")
print("    than the clocks are")
print("")
print("a conflict rule can be perfectly deterministic and still be")
print("deciding on the wrong quantity; clock discipline bounds the")
print("error and the writes have to be further apart than the bound")
print("")
print("The rule is deterministic and every replica converges - " + str(divergent_replicas) + " divergences, no")
print("operator ever chooses. It compares two hosts' clocks, monitored to within")
print(str(monitored_clock_offset_ms) + " ms, against conflicting writes a median of " + str(median_gap_ms) + " ms apart, so " + str(pairs_closer_together_than_the_offset))
print("pairs a day are closer together than the clocks are and about " + str(pairs_resolved_backwards) + " of them -")
print(str(backwards_per_myriad) + " per ten thousand of conflicts - converge on the earlier edit.")

writes per day                   : 8400000
conflicting pairs per day        : 24000
median gap between them, ms      : 12
monitored clock offset, ms       : 40

pairs the clocks can order       : 4400
pairs closer than the offset     : 19600
of those, resolved backwards     : 9800
share of conflicts resolved backwards : 4083 per ten thousand
divergent replicas               : 0

last-write-wins
  every replica applies the same comparison : yes
  replicas converge on the same value       : yes
  divergent replicas observed               : 0
  an operator has to choose                 : never
  the alternative considered : a merge function the data
    model cannot support
  verdict : CONVERGENT

  determinism is real and it is what makes this operable

the two operands
  a timestamp from host A : A's clock
  a timestamp from host B : B's clock
  what makes them comparable : an assumption that the
    offset between the clocks is smaller than the gap
    between the writes
  is that assumption monitored : the offset is; the gap
    is not

  the clock discipline is good and the quantity it is
  good enough for is the one nobody measured

the outcome for one backwards pair
  replicas agreeing on the value : all
  the value they agree on        : the earlier write
  a log line saying so           : none, both writes
    succeeded and neither is an error
  how a user notices             : their edit is gone

null control - a version vector instead of a wall clock
  divergent replicas      : 0, unchanged
  pairs resolved backwards: 0
  pairs reported concurrent : 19600, which is what they are
  the rule did not become more deterministic; the ordering
  stopped coming from two unrelated clocks

what last-write-wins guarantees
  every replica converges on one value : exactly
  that value is the last write         : not addressed;
    the comparison is between two clocks, and two clocks
    order two events only when they are further apart
    than the clocks are

a conflict rule can be perfectly deterministic and still be
deciding on the wrong quantity; clock discipline bounds the
error and the writes have to be further apart than the bound

The rule is deterministic and every replica converges - 0 divergences, no
operator ever chooses. It compares two hosts' clocks, monitored to within
40 ms, against conflicting writes a median of 12 ms apart, so 19600
pairs a day are closer together than the clocks are and about 9800 of them -
4083 per ten thousand of conflicts - converge on the earlier edit.

Trace event types