This list is of no particular orderning, neither of importance nor chronological. It is written in the order in which I remembered them as I was writing this.
Puppy Linux
In one of this week’s assignments was How Low Can You Go?, testing the physical limits of virtual memory allocation for Debian before kernel panic occurs.
While I was doing this, I remembered this little Linux distro, Puppy Linux.
It’s a distro that lives entirely in memory, much like the Tails distro, but for performance purposes instead of security purposes.
I find it pretty cool because it can work quite well on machines with memory space as low as 128 MB, while using it for the actual OS itself.
vfork()
This link provides documentation for the vfork() procedure mentioned in OSC chapter 10.
The segment on historic description and notes are quite interesting to me, because it gives a peek into ye olden days of computing where something had to be introduced just to address the evident problem of producing a copy of some process’s address space if only reading or exec() occurs.
The notes part is also very interesting because it noted that vfork() can be implemented without an MMU which makes no sense and sounds like it requires wizardry.
Implementing fork without MMU
Well it turns out, it was, in fact, wizardry.
This link covers the description of an implementation of fork() without an MMU on an embedded-intended RTOS, Embox.
And just as suspected, it’s incredibly complicated (but also, really really cool).
So much so that reading it feels like reading ancient runes–though then again, half of the source code is in Cyrillic.
slob, slab, slub of linux kernel
This link gives a more in-depth top-down view the concept of slab, slob, and slub as discussed in OSC ch. 10, with high-level explanations followed by code examples for concrete context into what’s going on.
The bulk of the article is a translation of one of the references listed below, which is in Mandarin that I unfortunately cannot read.
The article itself is a pretty interesting look into how (mostly) slab allocates/manages memory for kernel data structures.
Prepaging and Applications to Array Algorithms
This paper looks into some prepaging algorithms and their performances on matrix calculations.
No comment, I can’t even admit that I understand this paper at all, it’s just really really cool to read.
Using Vmstat to Monitor System Performance
This link explains the use of the vmstat command to monitor virtual memory usages and other related statistics.
That’s it, that’s all there is to it.
Trapping Virtual Memory Acccess
This link explains a very real example of exploiting virtual memory TOCTOU vulnerability to basically do whatever, particularly during page fault resolution.
An interesting read, even if you’re not a security person
Braess Paradox
This link explains the phenomenon known as the Braess Paradox, that is, when road increase actually increases road congestion rather than decreasing it.
I think it’s interesting because it’s a literal real life depiction of Belamy’s anomaly, one that occurs almost by natural design of human intuition.
Physical Page Allocation
This link explains the way Buddy allocation works in Linux.
I think it’s interesting because I was wholly unaware that Knuth was involved in this, out of all people.
What is NUMA?
This is an article from the Linux kernel team explaining NUMA.
Yea that’s it, I can’t actually understand things involving NUMA beyond this article, but it was pretty interesting nonetheless.
That’s it for now. またね！