
The unknown hackers (2000) - luu
https://www.salon.com/2000/05/17/386bsd/
======
indigochill
In the article they criticize the model of memory as a contiguous array. Does
anyone have insight into the more modern mental model and what it offers
beyond the contiguous array model?

~~~
illys
They mention: "the 'linear' idea of address space enshrined in Unix: Memory is
assigned to the next free block of appropriate size (...) You end up with lots
of little pools of memory."

They probably refer to a 386+ way to manage memory - pagination - that allows
to do much better.

The OS considers memory as a number of (originally 4kB) pages, some occupied,
some others free. When you need a larger chunk of free memory, the OS
organizes a set of pages to assemble a segment of memory. The application sees
a regular linear memory, but the OS is not left with pieces of unrelated small
memory spaces: the OS keeps a directory of free pages that can be used in any
order to create the next "any size" linear block.

When the free page stock is exhausted, the OS keeps statistics of the least
critical pages and unloads them to disk (OS code for unload destination, but
it is the processor that provides the triggers), generating free memory pages.

The ghost pages are marked as occupied in the segment description, but
unavailable (no RAM behind). When a program calls such a page, a processor
exception calls an OS routine that reloads the missing page to a free page and
connects it to the "linear" memory segment, as seen by the program. Then
program execution is resumed.

The identification of the least critical pages is a major element in OS
performance, since the unload/reload mechanism makes memory access work at
hard disk speed :-( [Off-topic: pagination/segmentation are great, but I am
more caution about the swapping mechanism, as it has made programmers very
lazy in memory management, and previous computer generation very slow, mostly
during the 1990s and 2000s - when memory was so expensive.]

Keywords if you like to know more: LDT, GDT, Descriptor Table, segmentation,
pagination...

~~~
p_l
classic Unix memory management is based about "break pointers" which describe
highest address of data segment, and a top of stack pointer, which limits the
stack segment. Those areas are linear and you can't free a part in the middle.

This is a historical curiosity from PDP-11 before the advent of paging, but
apparently still used by some malloc() implementations. Modern memory
management doesn't use linear mapping but instead uses paging to create chunks
of accessible memory. Some applications still use a big linear _address space_
by appropriately asking the OS then interoperating with memory management to
only request the memory that is needed

------
anc84
> Open-source pioneers Bill and Lynne Jolitz may be the most famous
> programmers you've never heard of.

Aaaand the tab is closed as my expectations for the story were some hyperbole
nonsense.

"An Article about Bill and Lynne Jolitz who wrote an open-source Unix pretty
much at the same time Linus Torvalds did but failed to gain any traction" for
anyone else who still has an open mind for reading. ;)

~~~
adrian_b
If you expected some hyperbole nonsense, it is obvious that the title was
completely correct, because you had no idea who were those two.

Among not too young users of FreeBSD or other BSD derivatives, it is well
known that those operating systems have been partially based on 386BSD, which
was written by the Jolitzes. Their role for BSDs is indeed as important as the
role of Linus for Linux.

While even inside the BSD community they are not as well known as Linus is
elsewhere, that is normal, because their contributions ended after the first
years, while Linus remained very active until now.

I have started to use both FreeBSD and Linux in 1995, and until around
2003/2004 FreeBSD was much better.

Then the BSD derivatives had very slow transitions to being able to handle
multi-threaded and multi-core processors and also to handle more modern
peripherals, e.g. GPUs, while Linux improved much faster than them.

~~~
anc84
Thank you!

And I am certain that there are "more famous" (whatever that might mean)
programmers individuals do not know because of different interests and
disciplines.

