Besides a missing page, a very common source of page faults is copy-on-write (COW).

Page tables have extra flags that allow the OS to mark a page a read-only.

Those page faults only happen when a process tries to write to the page, and not read from it.

When Linux forks a process:

Because Ciro's a software engineer, and he's done enough staring in computers for a lifetime already, and he believes in the power of Git, he didn't pay much attention to this part ;-)

According to the eLife paper, the code appears to have been uploaded to: github.com/d-j-k/puntseq. TODO at least mention the key algorithms used more precisely.

Ciro can however see that it does present interesting problems!

Because it was necessary to wait for 2 days to get our data, the workshop first reused sample data from previous collections done earlier in the year to illustrate the software.

First there is some signal processing/machine learning required to do the base calling, which is not trivial in the Oxford Nanopore, since neighbouring bases can affect the signal of each other. This is mostly handled by Oxford Nanopore itself, or by hardcore programmers in the field however.

After the base calling was done, the data was analyzed using computer programs that match the sequenced 16S sequences to a database of known sequenced species.

This is of course not just a simple direct string matching problem, since like any in experiment, the DNA reads have some errors, so the program has to find the best match even though it is not exact.

The PuntSeq team would later upload the data to well known open databases so that it will be preserved forever! When ready, a link to the data would be uploaded to: www.puntseq.co.uk/data

Why are pages 4 KiB anyways?

There is a trade-off between memory wasted in:

This can be seen with the extreme cases:

x86 designers have found that 4 KiB pages are a good middle ground.

The exact format of table entries is fixed by the hardware.

Each page entry can be seen as a struct with many fields.

The page table is then an array of struct.

On this simplified example, the page table entries contain only two fields:so in this example the hardware designers could have chosen the size of the page table to b 21 instead of 32 as we've used so far.

All real page table entries have other fields, notably fields to set pages to read-only for Copy-on-write. This will be explained elsewhere.

It would be impractical to align things at 21 bits since memory is addressable by bytes and not bits. Therefore, even in only 21 bits are needed in this case, hardware designers would probably choose 32 to make access faster, and just reserve bits the remaining bits for later usage. The actual value on x86 is 32 bits.

Here is a screenshot from the Intel manual image "Formats of CR3 and Paging-Structure Entries with 32-Bit Paging" showing the structure of a page table in all its glory: Figure 1. "x86 page entry format".

The fields are explained in the manual just after.

Minimal example: github.com/cirosantilli/x86-bare-metal-examples/blob/5c672f73884a487414b3e21bd9e579c67cd77621/paging.S

Like everything else in programming, the only way to really understand this is to play with minimal examples.

What makes this a "hard" subject is that the minimal example is large because you need to make your own small OS.

Since DNA is the centerpiece of life, Ciro Santilli is extremely excited about DNA-related technologies, see also: molecular biology technologies.

Then a specific metric is involved, sometimes we want to automatically add it to products.

E.g., in a context considering the common Minkowski inner product matrix where the $\eta$ 4x4 matrix and $\mu$ is a vector in ${\mathbb{R}}^4$which leads to the change of sign of some terms.

Wikipedia defines Mind uploading as a synonym for whole brain emulation. This sounds really weird, as "mind uploading" suggests much more simply brain dumping, or perhaps reuploading a brain dump to a brain.

Superintelligence by Nick Bostrom (2014) section "Whole brain emulation" provides a reasonable setup: post mortem, take a brain, freeze it, then cut it into fine slices with a Microtome, and then inspect slices with an electron microscope after some kind of staining to determine all the synapses.

Likely implies AGI.