(j3.2006) Integration of co-arrays with the intrinsic shift functions

[Craig Rasmussen]

On Jul 16, 2007, at 1:42 PM, Jim Xia wrote:

>
> This piece of code seems odd.
>

You are absolutely correct.  I have proved my point (regarding the  
complexity of programming to the assembly language level of co- 
arrays) by hurrying through the example and unintentionally making  
mistakes.

I believe this is an absolutely critical point.  I have been  
commissioned at Los Alamos to develop a strategic plan for software  
tools and programming models to cover the next 10 years.  In the  
process of developing the plan, we interviewed over 30 individuals at  
our national laboratories and universities.  Some conclusions of the  
interviews:
1. The complexity of the task to migrate our codes to the  
heterogeneous architectures of the future is enormous.
2. We are seeing a reduction in the number of knowledgeable Fortran  
programmers and there is serious discussions underway to migrate our  
applications away from Fortran.  Part of this discussion is that  
there may not even be Fortran compilers available for some of the  
computational elements (like GPUs) we see in the future.
3. We require portability of our applications across very disparate  
hardware architectures.  The only solution to this is to program in a  
very high level language and allow the compiler to "port" the  
applications between architectures.  Maintaining different versions  
of our applications is simply impossible because each new version  
costs on the order of $100 million.
4. Several individuals are proposing a data-parallel programming  
model as a solution to the "software crisis".  The data-parallel  
model reduces complexity for the programmer as well as for the  
compiler (because data dependencies have been factored out).  Los  
Alamos had a CM5 and everyone I talked to who programmed on it liked  
it.  At least one code still exists from that era.  The developer  
tells me of the code (a 3D stencil point calculation like the simple  
1D example I gave):
      a. The code size was reduced by a factor of 1/3 in moving to a  
data-parallel model.
      b. Indexing errors were found at the edges of the cells  
(similar to the errors I made).

> Although this code seems to approve Craig's point, I still agree  
> with Bill that the language should be neutral with regard to memory  
> models underneath the co-array.  It should not explicitly adopt one  
> model versus another,  Allowing intrinisics like co_cshift may  
> appear to someone that the language implicitly state what memory  
> model it is supporting.
>

I have serious questions regarding your points.  Why should the  
Fortran committee not begin the process of defining array  
distributions?  Is there serious harm in doing so?  What do we fear?   
Will Fortran never attempt to integrate co-arrays with the data- 
parallel model in Fortran 90?

Thanks for your response,
Craig

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://j3-fortran.org/pipermail/j3/attachments/20070717/030c6ad6/attachment.html