The Structure of a Collection. Ver 1.0+

While the C++ template based collections described in the preceding sections provides a very easy to use form of the collection concept, it does not allow for all the types of operations on aggregates that one frequently needs. For example, there is no way in which a member function of a element class to refer to the structure of the collection as a whole. This missing feature makes it difficult to write programs where one element object can refer to other elements in terms of the topology defined by the collection. To solve this problem there is a more elaborate (and more specialized) form of the collection class that has a special syntax.

  Collection NameOfCollectionType: ParentCollection{
      private:
        < private data fields and method functions>
      protected:
        < protected data fields and method functions>
      public:
        < other public data fields and method functions>
      MethodOfElement:
        < data and functions that are added to each element>
      };

The key points to understand are listed below.

• Collections are derived from a special machine dependent root class called SuperKernel. Consequently, every user defined collection is required to be a subclass of SuperKernel or, at least, have the SuperKernel in its ancestry. The SuperKernel class uses the distribution and alignment objects of a collection to initialize the collection and allocate the appropriate element objects on each memory module. The kernel also provides a global name space based on an integer enumeration of the elements of each collection. In other words the kernel numbers each element of the collection and this number can be used by any element to identify and access any other element. The important element access functions provided by the kernel will be described in greater detail later.

• A collection has private, protected and public data and member function fields exactly as any other class. However, unlike a standard class, when a collection object is allocated a copy of the basic collection structure is allocated in the local memory of each processor. Consequently, the data fields are not shared in the same way that element object indices are shared. The method functions in a collection are invoked in SPMD mode, i.e. they execute in an independent thread on each processor. This is explained in more detail later.

• Because the type of the collection element is not specified when the collection is defined, the special keyword ElementType is used to whenever it is necessary to refer to the type of the element.

• A collection also has a set of data fields and member functions that are copied into each element as public fields. These are labeled in the collection as MethodOfElement: fields. The purpose of MethodOfElement fields is to allow each element to ``inherit '' properties of the collection and to define operators that act on the elements with knowledge of the global structure of collection. Fields or method functions within the MethodOfElement section that are defined as virtual are assumed to be overridden by a definition within the element class.

To illustrate how the MethodOfELement field works, we will show how the pC++ compiler translates a collection into the correct template class. We will start with a simple ``hello world'' example. There are four parts to every pC++ program and they must be in the following order. First are the element class definitions. We will use a simple class E with one member function. Next, one must include the definition of the kernel with an include directive as shown below. Third are the definitions of the collections in the program. Last is the main program, which in pC++ version 1.0 is called Processor_Main().

#include "pcxx.h" 

//*** element class definitions

class E{  
public:
  int e_data;
  void sayHi(){ printf("hello"); }
};

//*** kernel.h must be included after the element classes are defined

#include "kernel.h"  

//*** definitions of collections

Collection Set: SuperKernel{
   int i;
   Set(Distribution *T, Align *A);
  MethodOfElement:
    int j;
    virtual void sayHi();
    void hello(){ printf("\nfrom element %d", Ident); }
};

//*** collection constructor: has to be defined
//*** outside of the collection definition

Set::Set(Distribution *T, Align *A):SuperKernel(T,A)
{}

//*** the main program

Processor_Main(){
     Processors P;
     Distribution T(4,&P,BLOCK);
     Align A(4,"[ALIGN(V[i],T[i])]");
     Set<E> x(&T, &A);
     x.sayHi();
     x.hello();
}

The variable Ident is the unique element identifier that is assigned to each element by the SuperKernel. This program will print, up to a permutation of the last 4 lines,

hellohellohellohello
from element 0
from element 3
from element 1
from element 2

class Element: E{
  public:
   int Ident; // from SuperKernel MethodOfElement
   Superkernel<Element> *ThisCollection;
   ...       // additional SuperKernel Fields. 
   int j;    // from Set MethodOfElement
   void hello();
};

The Set collection is translated by the pC++ compiler to a template class of the form

template <class ELementType> TEClass Set: SuperKernel<ElementType>{
    int i;
    Set(Distribution *T, Align *A): SuperKernel(T,A){};
}

The main program is the same except that the collection object definition is translated to

     Set<Element> x(&T, &A);