The file was locked and the copy was not

# Self-authored for the EML case corpus (no external origin). Two writers can
# never interleave, the lock has held for three years, and no torn write has
# ever been observed. How many backups are torn is computed below.
#
# The write lock is correct. It is taken before the first byte and released
# after the last, every writer takes it, a stress test with sixteen concurrent
# writers produced no interleaving in an hour, and the one incident it was
# written for has not recurred. Zero torn writes is a measured zero.
#
# The lock is advisory and it binds the WRITERS. A reader that does not ask for
# it is not stopped, is not queued, and is not told that a write is in progress
# — and the backup is a plain read of the path.
#
# The backup runs once a night. There are forty-one thousand writes a day.

41000 => writes_per_day
40 => mean_write_duration_ms
1 => backup_reads_per_day
86400000 => milliseconds_in_a_day
0 => torn_writes_observed
16 => writers_in_the_stress_test

writes_per_day * mean_write_duration_ms => milliseconds_a_day_mid_write
int(milliseconds_a_day_mid_write * 10000 / milliseconds_in_a_day) => mid_write_per_myriad
int(365 * mid_write_per_myriad / 10000) => torn_backups_per_year

"writes per day             : " + str(writes_per_day) ^0
"mean write duration, ms    : " + str(mean_write_duration_ms) ^0
"ms a day mid-write         : " + str(milliseconds_a_day_mid_write) ^0
"share of the day mid-write : " + str(mid_write_per_myriad) + " per ten thousand" ^0
"" ^0
"backup reads per day       : " + str(backup_reads_per_day) ^0
"torn backups per year      : " + str(torn_backups_per_year) ^0
"torn writes observed       : " + str(torn_writes_observed) ^0
"" ^0

# ---- what the lock verified ----

"the write lock" ^0
"  taken before the first byte : yes" ^0
"  released after the last     : yes" ^0
"  every writer takes it       : yes" ^0
"  stress test, " + str(writers_in_the_stress_test) + " concurrent writers : no interleaving" ^0
"  torn writes observed        : " + str(torn_writes_observed) ^0
"  verdict                     : EXCLUSIVE" ^0
"" ^0
"  the incident it was written for has not recurred, and" ^0
"  the lock is why" ^0
"" ^0

# ---- who is not in the protocol ----

"the reader" ^0
"  asks for the lock  : no" ^0
"  is queued          : no" ^0
"  is told a write is in progress : no" ^0
"  what it gets mid-write : whatever bytes are on disk" ^0
"" ^0
"  an advisory lock is a convention among participants, and" ^0
"  the backup is not a participant because reading was" ^0
"  never the thing anyone was worried about" ^0
"" ^0

# ---- what a torn backup looks like ----

# It is a valid file. The format is line-oriented, so a truncated last record
# is dropped by the reader, and a half-updated record parses. The restore does
# not fail; it produces a state that never existed.
"restoring from one" ^0
"  the file parses     : yes" ^0
"  the restore fails   : no" ^0
"  the state it produces : a mixture of before and after" ^0
"    one write, which no writer ever wrote" ^0
"  a checksum would catch it : only if computed under the" ^0
"    lock, which is the same fix" ^0
"" ^0

# ---- null control ----

# The same lock, with the backup taking it in shared mode.
0 => nc_torn_backups_per_year
mean_write_duration_ms => nc_backup_wait_ms

"null control - the backup takes the lock in shared mode" ^0
"  torn writes observed  : " + str(torn_writes_observed) + ", unchanged" ^0
"  torn backups per year : " + str(nc_torn_backups_per_year) ^0
"  the backup waits, ms  : at most " + str(nc_backup_wait_ms) ^0
"  the lock did not become stronger; the reader joined the" ^0
"  protocol, at a cost of one write's duration a night" ^0
"" ^0

# ---- the rule ----

"what an exclusive write lock guarantees" ^0
"  two writes never interleave : exactly" ^0
"  a read sees a whole write   : not addressed; the lock" ^0
"    binds whoever asks for it, and a reader that does not" ^0
"    ask is outside the mutual exclusion by construction" ^0
"" ^0
"advisory locking is a protocol between the parties that join" ^0
"it; the question is not whether the lock works but who is in" ^0
"the room, and the backup is usually written by someone else" ^0
"" ^0

"The write lock is exclusive and its zero is measured: taken before the first" ^0
"byte, released after the last, " + str(writers_in_the_stress_test) + " concurrent writers with no interleaving," ^0
str(torn_writes_observed) + " torn writes in three years. It is advisory, and the nightly backup reads" ^0
"without taking it, so with the path mid-write " + str(mid_write_per_myriad) + " per ten thousand of the day" ^0
"about " + str(torn_backups_per_year) + " backups a year restore a state no writer ever wrote." ^0

writes_per_day = 41000
mean_write_duration_ms = 40
backup_reads_per_day = 1
milliseconds_in_a_day = 86400000
torn_writes_observed = 0
writers_in_the_stress_test = 16
milliseconds_a_day_mid_write = writes_per_day * mean_write_duration_ms
mid_write_per_myriad = int(milliseconds_a_day_mid_write * 10000 / milliseconds_in_a_day)
torn_backups_per_year = int(365 * mid_write_per_myriad / 10000)
print("writes per day             : " + str(writes_per_day))
print("mean write duration, ms    : " + str(mean_write_duration_ms))
print("ms a day mid-write         : " + str(milliseconds_a_day_mid_write))
print("share of the day mid-write : " + str(mid_write_per_myriad) + " per ten thousand")
print("")
print("backup reads per day       : " + str(backup_reads_per_day))
print("torn backups per year      : " + str(torn_backups_per_year))
print("torn writes observed       : " + str(torn_writes_observed))
print("")
print("the write lock")
print("  taken before the first byte : yes")
print("  released after the last     : yes")
print("  every writer takes it       : yes")
print("  stress test, " + str(writers_in_the_stress_test) + " concurrent writers : no interleaving")
print("  torn writes observed        : " + str(torn_writes_observed))
print("  verdict                     : EXCLUSIVE")
print("")
print("  the incident it was written for has not recurred, and")
print("  the lock is why")
print("")
print("the reader")
print("  asks for the lock  : no")
print("  is queued          : no")
print("  is told a write is in progress : no")
print("  what it gets mid-write : whatever bytes are on disk")
print("")
print("  an advisory lock is a convention among participants, and")
print("  the backup is not a participant because reading was")
print("  never the thing anyone was worried about")
print("")
print("restoring from one")
print("  the file parses     : yes")
print("  the restore fails   : no")
print("  the state it produces : a mixture of before and after")
print("    one write, which no writer ever wrote")
print("  a checksum would catch it : only if computed under the")
print("    lock, which is the same fix")
print("")
nc_torn_backups_per_year = 0
nc_backup_wait_ms = mean_write_duration_ms
print("null control - the backup takes the lock in shared mode")
print("  torn writes observed  : " + str(torn_writes_observed) + ", unchanged")
print("  torn backups per year : " + str(nc_torn_backups_per_year))
print("  the backup waits, ms  : at most " + str(nc_backup_wait_ms))
print("  the lock did not become stronger; the reader joined the")
print("  protocol, at a cost of one write's duration a night")
print("")
print("what an exclusive write lock guarantees")
print("  two writes never interleave : exactly")
print("  a read sees a whole write   : not addressed; the lock")
print("    binds whoever asks for it, and a reader that does not")
print("    ask is outside the mutual exclusion by construction")
print("")
print("advisory locking is a protocol between the parties that join")
print("it; the question is not whether the lock works but who is in")
print("the room, and the backup is usually written by someone else")
print("")
print("The write lock is exclusive and its zero is measured: taken before the first")
print("byte, released after the last, " + str(writers_in_the_stress_test) + " concurrent writers with no interleaving,")
print(str(torn_writes_observed) + " torn writes in three years. It is advisory, and the nightly backup reads")
print("without taking it, so with the path mid-write " + str(mid_write_per_myriad) + " per ten thousand of the day")
print("about " + str(torn_backups_per_year) + " backups a year restore a state no writer ever wrote.")

writes per day             : 41000
mean write duration, ms    : 40
ms a day mid-write         : 1640000
share of the day mid-write : 189 per ten thousand

backup reads per day       : 1
torn backups per year      : 6
torn writes observed       : 0

the write lock
  taken before the first byte : yes
  released after the last     : yes
  every writer takes it       : yes
  stress test, 16 concurrent writers : no interleaving
  torn writes observed        : 0
  verdict                     : EXCLUSIVE

  the incident it was written for has not recurred, and
  the lock is why

the reader
  asks for the lock  : no
  is queued          : no
  is told a write is in progress : no
  what it gets mid-write : whatever bytes are on disk

  an advisory lock is a convention among participants, and
  the backup is not a participant because reading was
  never the thing anyone was worried about

restoring from one
  the file parses     : yes
  the restore fails   : no
  the state it produces : a mixture of before and after
    one write, which no writer ever wrote
  a checksum would catch it : only if computed under the
    lock, which is the same fix

null control - the backup takes the lock in shared mode
  torn writes observed  : 0, unchanged
  torn backups per year : 0
  the backup waits, ms  : at most 40
  the lock did not become stronger; the reader joined the
  protocol, at a cost of one write's duration a night

what an exclusive write lock guarantees
  two writes never interleave : exactly
  a read sees a whole write   : not addressed; the lock
    binds whoever asks for it, and a reader that does not
    ask is outside the mutual exclusion by construction

advisory locking is a protocol between the parties that join
it; the question is not whether the lock works but who is in
the room, and the backup is usually written by someone else

The write lock is exclusive and its zero is measured: taken before the first
byte, released after the last, 16 concurrent writers with no interleaving,
0 torn writes in three years. It is advisory, and the nightly backup reads
without taking it, so with the path mid-write 189 per ten thousand of the day
about 6 backups a year restore a state no writer ever wrote.

Trace event types