Re: Address bits again, Article on new mainframe use

John Levine <johnl@taugh.com> writes:

According to Michael S  <already5chosen@yahoo.com>:

x86 Real mode segmentation is a hack to the address space. 80286
protected mode segmentation is something else. The only similarity
between the two is maximal size of segment is the same.

>
The 386 had 32 bit segments which should have made segmented code
practical and efficient and allowed giant programs with lots of
gigabyte segments. But Intel shot themselves in the foot. One problem
was that loading a segment register to switch segments remained
extremely slow so you still needed to write your program to avoid
doing so.

Yes, that was certainly a problem for those willing to use segments.
The question is if many people were willing.  My impression is that
people were not really willing to use them on the 80286, and 4GB
segments would not have changed that.

The other was that they mapped all the segments into a 32 bit linear
address space, and paged the linear address space.  That meant that
the total size of all active segments had to fit into 4GB, at which
point people said fine, whatever, set all the segment registers to
map a single 4GB segment onto the linear address space and used it as
a flat address machine.

That was not a problem while the 386 was current.  It could also only
deal with 4GB of physical RAM, and the 386 machines I had contact with
had at most 8MB of RAM; there were bigger systems around, but not
being able to use more then 4GB was not a problem at the time.  If the
reason for using segments would have been to be able to address more
memory, then going to 64 bits was certainly the better answer (and
that was taken eventually).

By contrast, if the reason for segments is that you want to use them
for memory safety, then two other properties of the 386 were not so
great:

* Only 8192 segments IIRC (hmm, what do the other 3 bits in a segment
  register do?); that was ok while memories were small, but if you
  want to have a segment for each C object, you quickly run out of
  segments with programs that, say, build trees using malloc()ed
  memory or such (even a tree with 8193 nodes would run out of
  segments).

* IIRC the segment size has a pretty large granularity (however,
  <https://en.wikipedia.org/wiki/X86_memory_segmentation#80286_protected_mode>
  says that the segments are limited to 16MB of size; maybe it was
  either the size limit or the large granularity), which is not so
  great.

I once read the "Intel 386 Microprocessor oral history panel : design
and development"
<https://www.computerhistory.org/collections/catalog/102702019>.  My
impression from reading that is that they actually wanted a flat
memory space, but were damned to do a followup for the 80286, so what
they did was something that allowed OS designers to provide a flat
address space, and also extended 80286 segments to 32 bits, without
too much implementation cost.  I think they did well.

Having a separate page table per segment as you suggest elsewhere
would have slowed down segments even more, for no gain in the 386's
day.  If more virtual memory per process was desired, a future
extension could have been to have a different way to construct the
linear address (e.g., using a larger segment descriptor that contains
a 52-bit base address or somesuch), and then use paging for the linear
address with PAE.  If segments had been embraced by software
developers, eventually one would have had something AMD64-like, with
segment descriptors with 64-bit base addresses and 64-bit limits, and
64-bit segment registers.

- anton
--
'Anyone trying for "industrial quality" ISA should avoid undefined behavior.'
  Mitch Alsup, <c17fcd89-f024-40e7-a594-88a85ac10d20o@googlegroups.com>