Subject: G1 meeting Wednesday

From: [email-masked] (Mary E Zosel)
Date: Mon, 7 Sep 92 15:16:32 -0700

Group 1
following are some of the things I would like to resolve
Wednesday afternoon --- in case you want to research your
answers ahead of time (fat chance), or want to attend
another subgroup meeting and just express some opinions via
proxy (more likely).  As before, we will meet as soon as we
have a quorem of a few folks on Wednesday afternoon - perhaps
between 1:30 and 2.
   -mary-

---------
proposed discussion agenda
---------

Discussion items for HPF Subgroup 1 Meeting - Wed. Sept 9

Fortran 90 Subset (technically first reading)

1.  How formal should the subset specification be?  How involved
in Fortran-90 syntax should we get?

2.  Module rename? The short version I wrote up for the
document does not propose rename on the USE.  The version 
that Rich Fuhler sent does propose rename.  
Should rename be in our formal proposal?

3.  Changes / additions / deletions to the list of proposed items
for formal committee vote: (limit interface block, modules, 
new intrinsics, F90 form declarations).  

4.  Does the discussion of HPF extension subset belong in chapter 9?

5.  Document editorial form:  Any suggestions about editorial work we 
should do to improve the Fortran 90 / subset discussion 
in the document? See sections 1.2, 1.4, 2.1 and chapter 9.

6.  Technically, this is the "first reading" for the subset.  Is there
additional work we should do?

-------------------------------------------------------------

Storage Association (second reading - final call to get this right)

1. Do we want SEQUENCE and NOSEQUENCE or SEQUENTIAL and NONSEQUENTIAL?  
Rick Swift says  "existing keyword means what we want
 - avoid new keywords".
Maureen Hoffert says "don't overload a keyword with use in a
 different context".
The F90 document uses SEQUENCE as a property of a derived type. 
It says (R424 - p33) "If SEQUENCE is present, all derived types
 specified in component definitions must be sequence types." 
And in (5.1.1.7) "if a derived type has the SEQUENCE property, a 
scalar entity of the type is a sequence structure."  
A sequence type is defined in 4.4: By default, no storage 
sequence is implied by the order of the component 
definitions (of a derived type)).  However, if the 
definition of a derived type contains a SEQUENCE statment, 
the type is a sequence type.  The order of the component 
definitions in a sequence type specifies a storage sequence 
for objects of that type.
4.4.2 says why SEQUENCE is important:  if a derived type 
is used in two different subroutines (with no modules), 
then the derived type is the same type ONLY if the type 
name is the same, and it has all the same components, 
with identical names, shapes, etc. AND the derived type 
has the SEQUENCE property in both type declarations.

2.  Assumptions about arrays with no explicit mappings. (again)
Given COMMON /ABC/ X(2,512), Y(10000)   in one subroutine, and 
         COMMON /ABC/ X(32,32),  Y(10000)  in a second subroutine.
Suppose also that there is an explicit mapping for Y(BLOCK) in
both subroutines, but no explicit mapping for X.   
 
By our current rules, the COMMON is nonsequential: 
the explicitly mapped component (Y) matches in type, shape, etc. and 
the other component (X) matches in size and number.

Question: whose responsibility is it to make sure that the compiler
does the right thing in the case of separate compilation?  Is it
the user's responsibility to declare X sequential to make sure that
the compiler is not tempted to optimize and perhaps choose
different distributions.  Or is it the compiler's responsibility to
somehow learn about all instances of ABC before making any 
optimizations based on distribution of X (beyond some
default 1d-blocked distribution)????

3. Are all the definitions in 8.1 needed?

4. Document editorial form: We need a volunteer to improve 
section 8.4.  The discussion (8.4.2) needs work, possibly
with additional examples.

5  Any additional suggestions about editorial work needed
for chapter 8, or 1.3.6?