Die Auto-Parallelisierungs Option (APO)

Die -apo Option der MIPSpro Compiler aktiviert die automatische Parallelisierung. Der Compiler untersucht Datenabhängigkeiten innerhalb von Schleifen und falls keine Abhängigkeiten bestehen werden diese Schleifen parallel ausgeführt.

Durch Compiler-pragmas kann die Parallelisierung durch den Programmierer noch zusätzlich untersützt werden. Diese Anweisungen müssen direkt vor derjenigen Schleife stehen, auf die sie angewendet werden sollen. (Die Ausnahme davon: #pragma no concurrentize und #pragma concurrentize wirken entweder auf das gesamte file oder eine Funktion)

#pragma concurrent call

Diese Direktive teilt dem Compiler mit, dass ein Funktionsaufruf innerhalb der Schleife die Parallelisierung nicht stört.

#pragma concurrent

Der Compiler soll eine Abhängigkeit, die durch 2 Referenzen auf ein Array entsteht, ignorieren.

#pragma serial

Die folgende Schleife soll nicht parallelisiert werden.

#pragma prefer concurrent

Falls es möglich ist, soll die folgende Schleife parallelisiert werden.

#pragma permutation (array_name)

Der angegebene Array ist eine Permutation. D.h.: Der Array enthält keine zwei gleichen Werte.

void sub1(int n) { 
  int i; 
  extern int a[], b[]; 
  for(i=0; i<n; i++) { 
    a[b[i]] = i; 
  } 
  #pragma permutation (b) 
  for(i=0; i<n; i++) { 
    a[b[i]] = i; 
  } 
}

#pragma permutation (array_name) wirkt sich auf alle Schleifen in einer Funktion aus. Im obiogen Beispiel also auch auf die erste for-Schleife. Diese Direktive wird dazu verwendet, dass Arrays indirekt adressiert werden können.

#pragma no concurrentize und #pragma concurrentize

#pragma no concurrentize unterdrückt die Paralleliserung eines ganzen Files oder einer Funktion, je nachdem wo es plaziert wird, ausserhalb oder innerhalb einer Funktion. #pragma concurrentize hebt #pragma no concurrentize für die Funktion auf, in der es steht.

#include <stdio.h>

#define SIZE	4

int main() {

  int i, j, k;
  float matrix1[SIZE][SIZE], matrix2[SIZE][SIZE], result[SIZE][SIZE];

  #pragma prefer concurrent
  for (i=0; i<SIZE; i++) {
    matrix1[i][j] = i;
    matrix2[i][j] = j;
    result[i][j] = 0;
  }

  printf("matrix1:\n");
  for (i=0; i<SIZE; i++) {
    for (j=0; j<SIZE; j++) 
      printf("%f ", matrix1[i][j]);
printf("\n");
  }

  printf("matrix2:\n");
  for (i=0; i<SIZE; i++) {
    for (j=0; j<SIZE; j++) 
      printf("%f ", matrix2[i][j]);
printf("\n");
  }

  #pragma prefer concurrent
  for (i=0; i<SIZE; i++)
    for (j=0; j<SIZE; j++)
      for (k=0; k<SIZE; k++)
        result[i][j] += matrix1[k][j] * matrix2[i][k];

  printf("result:\n");
  for (i=0; i<SIZE; i++) {
    for (j=0; j<SIZE; j++) 
      printf("%f ", result[i][j]);
printf("\n");
  }  

  return(0);

}

Mail to: Oliver Schönbrunner