nettype SimpleNet(n) {coord I = n;};

nettype Star(m,n[m])
{
   coord I=m;
   node {I>=0: fast*n[I] scalar;};
   link {I>0: [I]->[0], [0]->[I];};
   parent [0];
};

void [*]MxM(float *x, float *y, float *z, repl n)
{
   repl double powers;
   repl nprocs, nrows[MAXNPROCS], n;
   MPC_Processors_static_info(&nprocs, &powers)
   Partition(nprocs, powers, nrows, n);
   {
      net Star(nprocs, nrows) w;
      ([([w]nprocs)w])ParMult([w]x, [w]y, [w]z, [w]nrows, [w]n);
   }
}

void [net SimpleNet(p)v] ParMult(float *dx, float *dy, float *dz, repl *r, repl n)
{
   repl s = 0;
   int myn, i;
   int *d, *l c;

   myn = r[I coordof r];
   ([(p)v])MPC_Bcast(&s, dy, 1, n*n, dy, 1);
   d = calloc(p, sizeof(int));
   l = calloc(p, sizeof(int));
   for(i=0, d[0] = 0; i<p; i++)
   {
      l[i] =r[i]*n;
      if(i+1<p) d[i+1] =l[i]+d[i];
   }
   c=l[I coordof c];
   ([(p)v])MPC_Scatter(&s, dx,d,l,c,dx);
   SeqMult(dx, dy, dz, myn, n);
   ([(p)v])MPC_Gather(&s, dz, d, l, c, dz);
}

void SeqMult(float *a, float *b, float *c, int m, int n)
{

   int i, j, k, ixn;
   double s;

   for(i=0; i<m; i++)
      for(j=0, ixn=i*n; j<n; j++) {
         s+=a[ixn+k]*(double)(b[k*n+j]);
         c[ixn+j]=s;
      }
}

void Partition(int p, double *v, int *r, int n)
{
   int sr, i;
   double sv;

   for(i=0, sv=0.0; i<p; i++) sv+v[i];
   for(i=0, sr=0; i<p; i++) {
      r[i]=(int)(v[i]/sv*n);
      sr+=r[i];
   }
   if (sr!=n) r[0]+=n-sr;
}

Formal parameters x, y, and z of basic function MxM are distributed over entire computing space, and parameter n is replicated over the entire computing space. It is meant that n holds the dimension of matrices. It is also meant that x points to n*n-member array, and the component of this distributed array belonging to the virtual host-processor holds matrix X. Similarly, [host]y points to an array holding matrix Y, and [host]z point to array holding resulting matrix Z.
   Call to library nodal function MPC_Processors_static_info made on the entire computing space returns the number of actual processors and their relative performances. So, after this call replicated variable nprocs will hold the number of actual processors, and replicated array powers will hold their relative performances.
   Call to nodal function Partition is also performed on the entire computing space. Based on relative performances of actual processors, this function computes how many rows of the resulting matrix should be computed by every actual processor. So, after this call nrows[i] will hold the number of rows to compute by i-th actual processor.
   After that automatic network w is defined. Its type is defined completely only in run time. Network w, which executes the rest of computations and communications, is defined in such a way, that the more powerful the virtual processor, the greater number of rows it computes. The mpC environment will ensure the optimal mapping of the virtual processors constituting the entire computing space. So, just one process from processes running on each actual processors will be involved in multiplication of matrices, and the more powerful the actual processor is, the greater number of rows it computes.
There is a call to network function ParMult on network w two lines below. In this call, topological argument [w]nprocs specifies a network type as an instance of parametrized network type SimpleNet, and network argument w specifies a region of the computing space treated by function ParMult as a network of this type.
   Definition of function ParMult declares identifier v of a network being a special network formal parameter of the function. Since network v has a parametrized type, topological parameter p is also declared in this header. In the function body, special formal parameter p is treated as an unmodifiable variable of type int replicated over network formal parameter v the rest of formal parameters (regular formal parameters) of the function are also distributed over v.
   Actually, p holds the number of virtual processors in network v, n holds the dimension of matrices, r points to p-member array, i-th element of which holds the number of rows of resulting matrix that i-th virtual processor of network v computes. Each component of dy points to an array to contain n*n matrix Y. Each component of dz points to an array to contain rows of Z computed on the corresponding virtual processor. Each component of dx points to an array to contain the row of X used in computations on the corresponding virtual processor. In addition, throughout the function execution the components of dx, dy, dz belonging to the parent of network v are reputed to arrays holding matrices X, Y and Z correspondingly.
   Variable s is replicated over v. Variables myn, i, d, l and c all distributed over v.
After execution of the first executable (asynchronous) statement, each component of myn will contain the number of rows of the resulting matrix that computes the corresponding virtual processor. After it is a call to so-called embedded network function MPC_Bcast which declared in a standard mpC header as follows:

int [net SimpleNet(n)] MPC_Bcast(
   repl const *coordinates_of_source,
   void *source_buffer,
   const source_step,
   repl const count,
   void *destination_buffer,
   const *destination_step);

int [net SimpleNet(n) w] MPC_Scatter(
   repl const *coordinates_of_source,
   void *source_buffer,
   const *displacements,
   const *sendcounts,
   int receivecount,
   void *destination_buffer);

int [net SimpleNet(n) w] MPC_Gather (
   repl const *coordinates_of_destination,
   void *destination_buffer,
   const *displacements,
   const *receivecounts,
   int sendcount,
   void *source_buffer);
This call gathers resulting matrix Z each virtual processor of v sending its portion of the result to the parent of v.

   Figure 2 illustrates how the mpC program allows to speed up the multiplication of two dense square matrices, if the user starts from single powerful workstation zeta and enhances his computing facilities step by step by means of adding less powerful workstations gamma, beta, and delta. One can see that the mpC programming environment ensures good speedup in these case also.
   Another interesting result can be extracted from Figure 1 and table 3. One can see that the slow network consisting of workstations gamma and delta (virtual parallel machine gd), the performance each of which is about 60% of the performance of workstation zeta, demonstrates a little bit higher performance (when multiplying two dense square matrices) than single workstation zeta.

   Finally, figure 3 shows clearly, that even for very heterogeneous distributed memory machine consisting of high-performance HP workstation and old low performance Sun workstation omega, the mpC program allows to utilize its parallel potential, speeding up the multiplication of two dense square matrices (comparing to sequential C program running on zeta). At the same time, the use its MPI counterpart, which distributes the workload equally, does not allow to do it slowing down the matrix multiplication essentially.