Discussion
reading the amd64 architecture programmer's manual:
One of the more common types of strings used by applications are byte data-type strings known as ASCII strings, which can be used to represent character data.
i agree that a varint encoding like utf-8 sucks too, but come on
as someone who has constantly repeatedly restructured lazy computations (which end up pulling in tons and tons of i/o and computation, and effectively cannot be cached or prefetched) into clear data dependencies that can be scheduled, i think a page fault is in fact a failure of scheduling
first off, files are not pages. fuck off. you can map a shared memory region if you want shared memory
second, copy-on-write is a cheap hack for latency benchmarks and should never have been the default mechanism used for parallelism. it is an active abdication of scheduling the movement of memory across processes, because POSIX has absolutely no concept of any communication that's not instant!!!!! now!!!!!! everywhere!!!!!!!
now, you won't hear me supporting microsoft's diatribe against fork(). not only EEE, but also a massive skill issue: https://www.microsoft.com/en-us/research/wp-content/uploads/2019/04/fork-hotos19.pdf
Moreover, a fundamental challenge with fork is that, since it conflates the process and the address space in which it runs,
ah. indeed. conflating a process. and an address space. the thing which is defined per-process
fork is hostile to user-mode implementation of OS functionality,
not mine!
breaking everything from buffered IO to kernel-bypass networking.
page faulting is breaking everything. i'm ruined. oh what a world what a world
Perhaps most problematically, fork doesn’t compose
it's actually quite a structured abstraction for multiprocessing. it's not perfect, but it's in the tool belt
every layer of a system from the kernel to the smallest user-mode library must support it.
again.........it's page faulting. cmon
Systems that support fork and exec efficiently are forced to duplicate per-process state lazily.
yes, that is how semantics for syscalls work. microsoft should try it
This encourages the centralisation of state, a major problem for systems not structured using monolithic kernels.
copy-on-write is very much not centralized. monolithic kernels actually have a much worse time doing this
On the other hand, research systems that avoid implementing fork are unable to run the enormous body of software that uses it.
ok. so you don't want to write a compatibility layer. but you feel entitled to the enormous body of software regardless
not even worth going past the first page. let's go back to what a fault is:
After the service routine completes, the machine state prior to the faulting instruction is restored, and the instruction is retried.
ah, so the machine state is completely unchanged after a page fault? because that sounds pretty compositional to me
ok, done with faults. next:
Traps — A trap is a precise exception
I'VE HEARD THIS ONE BEFORE
Software interrupts and certain breakpoint exceptions used in debugging are traps.
those are not the same thing, but that's fine
ah. now we learn:
Aborts — Aborts are imprecise exceptions.
"precision" has never, ever been defined before in this text. let's see if they're using higher-order logic:
The instruction causing the exception, and possibly an indeterminate additional number of instructions, complete execution before the service routine is invoked.
see i like this because it's async!!!! the processor should let me do some more async stuff!!!!
Because they are imprecise, aborts typically do not allow reliable program restart.
"imprecise" has NEVER been defined
