And also this only happens on multi-socked (not just multi-core) systems. So the underlying problem is likely related to cache coherency issues across NUMA nodes.

I'm assuming that the linker exits before the program it linked is executed. I'd hope so! If so then this is clearly an OS bug.

How does your comment contradict the parent one?

The parent uses weasel words https://en.wikipedia.org/wiki/Weasel_word that, while technically correct, imply something false. The comment is refuting the implication.

Here the implication is that there is a fundamental design flaw in the OS that may cause widespread issues, when really this is a bug in quite a narrow edge case: it may happen when building colossal projects repeatedly on very high spec computers, the article suggests that the team at Microsoft investigating the bug couldn't reproduce it since they couldn't build Chrome as quickly as the author could.

Memory-mapped I/O is a lot more precise a description of "writing" and more unusual than simply writing out, and execution similarly is not a normal read path for a just-written file.

The parent made it sounds like you could just write a loop with for(;;) { write_file("x"); read_file("x"); } and expect discrepancies. That's not the case and it's wilfully misleading to suggest it is.

The parent said "in some cases". I guess it could be misinterpreted, but I took that to mean "in some very specific access patterns" (rather than, say, "in any access pattern some random small proportion of the time").

Um, also, in some cases, I might win the lottery.

Writing a binary executable file is not a common situation, only compilers do that. If you add the unusual heavy IO, this is a fringe case.

> Writing a binary executable file is not a common situation, only compilers do that.

Not only compilers. Decompressors (.zip, etc.), installers and auto-updaters. There are more use cases for writing out executables than just compilers.

Although these cases probably write sequentially and don't need to memory map the file and update sections in a random access fashion.

Look, there are a handful of details in the description that, for the right person, clearly and right away indicates that it's a very very specific, even fringe case. Saying that "basically it means..." as if it was a general case is terribly misguided because it's not. There are already a few comments explaining just that. Insisting in a misunderstanding is not very useful.

[Edit: whoops, never mind, thanks. Might be worth adding the memory-mapped part to your comment to clarify for others too.]

You're right that it is an example of a case that matches the "basic" description of the conditions to hit the bug, but it probably won't satisfy any of the three conditions when they are considered in detail:

* The files being written probably won't be using memory mapped IO (I'd expect them to use the equivalent of fwrite instead) as the installer won't need to make complex changes to the binaries in the same way that a compiler/linker would

* There will likely be a significant delay between writing the file and running it compared with a build process that uses its own build output as part of the build (even in the build process case, the bug went away for a year, possibly due to an additional delay between the write and execute steps)

* Once the installer has run, the system will probably not be under heavy load (the author was running a highly parallel build on a 24-core machine, and this bug was still only hit in 3% of builds)

Really the earlier post was just misleading, as it implies the bug is much easier to hit than it really is.

There are other use cases where this might occur, though – JITs that store JITed binaries on disk.

That’s rare (usually there you’d read it back in and execute in your process space), but it’d be at least a second realistic scenario.

Not the same. Notice the memory mapped file bit.

I agree. But the comment I was referring to said "in some cases"; it never claimed it was a common case.

I don't know if you're trolling.

> if a program writes a PE file (EXE or DLL) using memory mapped file I/O and

Write

> if that program is then immediately executed (or loaded

Read immediately

> then a necessary file-buffer flush may fail

You get bad data in memory.

You've abstracted very specific conditions to the point of absurdity. I don't see any reason for that except for pulling a strawman and taking a stab at Windows.