🚀 go-pugleaf

In article <44d1n3$6tn@murrow.corp.sgi.com>,
John R. Mashey <mash@mash.engr.sgi.com> wrote:

>Of course, if somebody does an operating system that
>uses 128-bit addressing to address every byte in the world uniquely, *and* this
>takes over the world, it might be an impetus for 128-bitters :-)

IBM has a 128 bit address system which they tried to take over the world
with, the AS/400.  That isn't the only operating system with long addresses
(but it may be the only commercially successful one).

There is an implicit assumption in the discussion so far that the integer
register word size is the virtual address size.  If we're trying to look
20 years ahead I don't think this is a necessary assumption.  I don't
think it is necessary now, but the popularity of low level languages and
a lingering overreaction to Intel's 8086 series limit acceptance
of other addressing models.

So here is a prediction of the computing world in 20 years.  It is not the
only possible future, but I think it is plausible.

User interface programs (editors, business applications, databases, etc.)
are programmed in a high level language.  Maybe it looks something like
a derivative of C++, TCL, Motif UIL, SQL, etc.  But it lacks the features
which made C popular in the 1980s.  It doesn't expose machine details.
It isn't fast but the processor is, and who cares if it takes an extra 10
microseconds to process a mouse click or 1 microsecond to format a database
request that is served from a disk with a 2 millisecond access time.  It has
semi-transparent support for remote objects.

Computationally intensive programs use FORTRAN 2005 or a fast subset of C++.
They work on a few small data sets, much less than 2^64 bytes each.

The first group can't tell that their systems use (64 bit object, 64 bit
offset) register pairs to address memory.  They don't see the pointer
format (and in fact with bounds and type checking the language pointer/
descriptor type may not use the machine's format).  They don't see any
impact on performance, because user interface processing and I/O
dominate runtime.

The second group may need to know the machine's addressing model, but
they are also the ones least affected by it, especially once preprocessors
and optimizers finish working on their code.

-- 
    John Carr (jfc@mit.edu)