As usual, you give me much to ponder. For some reason it pleases that the world is not too concerned with what we happen to like.

But it's not true to what is *there*, and if you program for that model, you're going to get terrible performance.

I heard recently of a type system that captures the complexity of functions in their signatures. With that information available to the machine, perhaps the machine could be equipped with a way to plan an execution such that performance is optimised.

Your day with the HPC system sounds fascinating. Do you think that an Ada/Occam-like approach to partitioned distribution could tame the sort address space that you encountered on the day?

Any programming model that relies on large flat shared address spaces is out; message passing that copies stuff is going to be much easier to manage than passing a pointer to memory that might be powered off when you need it

But there'll still be some call for shared memory? Or maybe only for persistence stores?

One of the presenters was working with a million lines of Fortran, almost all of it written by other people. How do we make that safe?

Ultimately only proof can verify safety. (I'm trying to address something like that in my rewrite, which given the high quality of feedback from this list, I hope to post soon.)

On 31 October 2016 at 04:07, Richard A. O'Keefe <ok@cs.otago.ac.nz> wrote:

On 31/10/16 5:44 AM, Rik Howard wrote:

thanks for the reply. Conceptually I like the idea of a single address
space, it can then be a matter of configuration as to whether what
you're addressing is another local process, processor or something more
remote.

The world doesn't care what you or I happen to like.
I completely agree in *liking* a single address space.
But it's not true to what is *there*, and if you program for that
model, you're going to get terrible performance.

I've just been attending a 1-day introduction to our national HPC
system. There are two clusters. One has about 3,300 cores and
the other over 6,000. One is POWER+AIX, the other Intel+Linux.
One has Xeon Phis (amongst other things), the other does not.
Hint: neither of them has a single address space, and while we
know about software distributed memory (indeed, one of the people
here has published innovative research in that area), it is *not*
like a single address space and is not notably easy to use.

It's possible to "tame" single address space. When you start to
learn Ada, you *think* you're dealing with a single address space
language, until you learn about partitioning programs for
distributed execution. For that matter, Occam has the same
property (which is one of the reasons why Occam didn't have
pointers, so that it would be *logically* a matter of indifference
whether two concurrent processors were on the same chip or not).

But even when communication is disguised as memory accessing,
it's still communication, it still *costs* like communication,
and if you want high performance, you had better *measure* it
as communication.

One of the presenters was working with a million lines of Fortran,
almost all of it written by other people. How do we make that safe?